Classes Intégrées : Nombre aléatoire

Introduction

 Imaginer que vous avez une série de nombres, tels ceux-ci : 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, et 20.  Imaginer que vous voulez sélectionner un de ces nombres, n'importe lequel d'entre eux. Un nombre est dit aléatoire s'il a été sélectionné parmi un groupe sans modèle spécifique à suivre. Par exemple, si vous décidez de sélectionner la valeur 17 à partir de cette liste, s'il y avait une raison exacte pour laquelle le nombre a été choisi, alors on ne le considèrera pas comme aléatoire. En réalité, il est difficile qu'un nombre soit qualifié d'aléatoire. Pour cette raison, la plupart des nombres aléatoires sont désigné sous le nom pseudo-aléatoires.

Pour soutenir la capacité de créer ou choisir un nombre aléatoire,  .NET Framework fournit la classe aléatoire. Pour commencer, vous pouvez déclarer une variable de cette classe, en utilisant un de ses deux constructeurs. Voici un exemple qui utilise le constructeur par défaut :

using System;

class Program
{
    static int Main()
    {
        Random rndNumber = new Random();
       
        return 0;
    }
}

Après avoir créé la variable, vous pouvez commencer à obtenir des nombres d'elle. Pour ce faire, vous appelez la méthode Next () , qui est prise en charge dans trois versions. Une des versions de cette méthode ne prend aucun argument et sa syntaxe est :

public virtual int Next();

Cette méthode produit d'un nombre entier aléatoirement choisi entre 0 et la valeur MinValue du type de données int. Voici un exemple :

using System;

class Program
{
    static int Main()
    {
        Random rndNumbers = new Random();
        int    rndNumber = rndNumbers.Next();

        Console.WriteLine("Number: {0}", rndNumber);
       
        return 0;
    }
}

Voici un exemple d'exécution du programme :

Number: 1369872590
Press any key to continue . . .

De la même manière, vous pouvez appeler cette version de la méthode Next () à plusieurs reprises pour avoir un nombre aléatoire. Voici un exemple :

using System;

class Program
{
    static int Main()
    {
        Random rndNumbers = new Random();
        int rndNumber = 0;

        for (int nbr = 1; nbr < 9; nbr++)
        {
            rndNumber = rndNumbers.Next();
            Console.WriteLine("Number: {0}", rndNumber);
        }

        return 0;
    }
}

Voici un exemple d'exécution du programme :

Number: 1924504148
Number: 1257846191
Number: 424740120
Number: 1009211682
Number: 544356245
Number: 708951978
Number: 759684741
Number: 1325535324
Press any key to continue . . .

La graine (Seed) d'un nombre aléatoire

Considérez le programme suivant :

using System;

class Program
{
    static int Main()
    {
        Random rndNumbers = new Random();
        int rndNumber = rndNumbers.Next();

        Console.WriteLine("Number: {0}", rndNumber);

        return 0;
    }
}

Voici un exemple d'exécution du programme :

Number: 573991745
Press any key to continue . . .

Voici un autre exemple d'exécution du même programme :

Number: 334223329
Press any key to continue . . .

Noter que les nombres produits sont différents. En créant un programme qui obtient à plusieurs reprises une série de nombres aléatoires, vous pouvez (ou ne pas pouvoir) vouloir que la classe aléatoire produise le même nombre à plusieurs reprises. Une graine est une valeur constante  qui contrôle comment un générateur de nombres aléatoires produirait le même résultat chaque fois qu'il se produit. Par exemple, en utilisant une graine (Seed), vous pouvez l'imposer à la classe aléatoire pour produire le même nombre chaque fois que la méthode  Next () s'appelle. Pour soutenir la capacité d(utiliser une graine, la classe aléatoire est équipée d'un deuxième constructeur dont la syntaxe est :

public Random(int Seed);

Basé sur ceci, pour indiquer une graine (Seed), en déclarant une variable aléatoire, passez un nombre entier constant au constructeur. Voici un exemple :

using System;

class Program
{
    static int Main()
    {
        Random rndNumbers = new Random(20);
        int rndNumber = rndNumbers.Next();

        Console.WriteLine("Number: {0}", rndNumber);

        return 0;
    }
}

Voici un exemple d'exécution du programme :

Number: 375271809
Press any key to continue . . .

Voici un autre exemple d'exécution du même programme :

Number: 375271809
Press any key to continue . . .

Noter que les nombres sont identiques. Considérez ce programme également :

using System;

class Program
{
    static int Main()
    {
        Random rndNumbers = new Random(20);
        int rndNumber = 0;


        for (int nbr = 1; nbr < 5; nbr++)
        {
            rndNumber = rndNumbers.Next();
            Console.WriteLine("Number: {0}", rndNumber);
        }

        return 0;
    }
}

Voici un exemple d'exécution du programme :

Number: 375271809
Number: 1472524622
Number: 1605850688
Number: 1776011503
Press any key to continue . . .

Voici un autre exemple d'exécution du même programme :

Number: 375271809
Number: 1472524622
Number: 1605850688
Number: 1776011503
Press any key to continue . . .

Notez que les séquences sont identiques. Dans les deux cas, ceci indique que, si vous indiquez une graine (Seed), la classe aléatoire produirait le même nombre ou la même séquence de nombres.

Jusqu'ici, nous avions utilisé tout nombre qui s'adapterait à un nombre entier. Dans quelques tâches, vous pouvez vouloir limiter la gamme des nombres qui peuvent être extraits. Heureusement, la classe aléatoire permet ceci. En utilisant la classe aléatoire, vous pouvez produire des nombres positifs aléatoires jusqu'à un maximum de votre choix. Pour soutenir ceci, la classe aléatoire est équipée d'une autre version de la méthode Next () dont la syntaxe est :

public virtual int Next(int maxValue);

L'argument à passer à la méthode détermine le nombre entier le plus élevé qui peut être produit par la méthode Next (). La méthode renvoie un nombre entier. Voici un exemple qui produit des nombres aléatoires de 0 à 20 :

using System;

class Program
{
    static int Main()
    {
        Random rndNumbers = new Random();
        int rndNumber = 0;


        for (int nbr = 1; nbr < 9; nbr++)
        {
            rndNumber = rndNumbers.Next(20);
            Console.WriteLine("Number: {0}", rndNumber);
        }

        return 0;
    }
}

Voici un exemple d'exécution du programme :

Number: 1
Number: 7
Number: 1
Number: 16
Number: 14
Number: 19
Number: 3
Number: 1
Press any key to continue . . .

La version ci-dessus de la méthode Next () produit des nombres commençant par 0. Si vous voulez, vous pouvez indiquer la gamme minimum et maximum des nombres avec lesquels la méthode Next () doit fonctionner. Pour soutenir ceci, la classe aléatoire est équipée d'une version de plus de cette méthode et qui prend deux arguments. Sa syntaxe est :

public virtual int Next(int minValue, int maxValue);

Le premier argument indique la valeur la plus basse qui peut venir de la gamme. Le deuxième argument contient la valeur la plus élevée dont la méthode Next () peut produire. Par conséquent, la méthode fonctionnerait entre les deux valeurs. Voici un exemple qui produit des nombres aléatoires de 6 à 18 :

using System;

class Program
{
    static int Main()
    {
        Random rndNumbers = new Random();
        int rndNumber = 0;


        for (int nbr = 1; nbr < 9; nbr++)
        {
            rndNumber = rndNumbers.Next(6, 18);
            Console.WriteLine("Number: {0}", rndNumber);
        }

        return 0;
    }
}

Voici un exemple d'exécution du programme :

Number: 17
Number: 9
Number: 8
Number: 15
Number: 10
Number: 9
Number: 13
Number: 11
Press any key to continue . . .

Notez que les nombres sont entre 6 et 18.