# Random Classe

## Définition

Représente un générateur de nombres pseudo-aléatoires. Il s’agit d’un algorithme qui produit une séquence de nombres conformes à certains prérequis statistiques liés à l’aspect aléatoire.Represents a pseudo-random number generator, which is an algorithm that produces a sequence of numbers that meet certain statistical requirements for randomness.

``public ref class Random``
``public class Random``
``````[System.Serializable]
public class Random``````
``````[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class Random``````
``type Random = class``
``````[<System.Serializable>]
type Random = class``````
``````[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Random = class``````
``Public Class Random``
Héritage
Random
Attributs

## Exemples

L’exemple suivant crée un générateur de nombres aléatoires unique et appelle ses NextBytes Next méthodes, et NextDouble pour générer des séquences de nombres aléatoires dans différentes plages.The following example creates a single random number generator and calls its NextBytes, Next, and NextDouble methods to generate sequences of random numbers within different ranges.

``````using namespace System;

void main()
{
// Instantiate random number generator using system-supplied value as seed.
Random^ rand = gcnew Random();
// Generate and display 5 random byte (integer) values.
array<Byte>^ bytes = gcnew array<Byte>(4);
rand->NextBytes(bytes);
Console::WriteLine("Five random byte values:");
for each (Byte byteValue in bytes)
Console::Write("{0, 5}", byteValue);
Console::WriteLine();
// Generate and display 5 random integers.
Console::WriteLine("Five random integer values:");
for (int ctr = 0; ctr <= 4; ctr++)
Console::Write("{0,15:N0}", rand->Next());
Console::WriteLine();
// Generate and display 5 random integers between 0 and 100.//
Console::WriteLine("Five random integers between 0 and 100:");
for (int ctr = 0; ctr <= 4; ctr++)
Console::Write("{0,8:N0}", rand->Next(101));
Console::WriteLine();
// Generate and display 5 random integers from 50 to 100.
Console::WriteLine("Five random integers between 50 and 100:");
for (int ctr = 0; ctr <= 4; ctr++)
Console::Write("{0,8:N0}", rand->Next(50, 101));
Console::WriteLine();
// Generate and display 5 random floating point values from 0 to 1.
Console::WriteLine("Five Doubles.");
for (int ctr = 0; ctr <= 4; ctr++)
Console::Write("{0,8:N3}", rand->NextDouble());
Console::WriteLine();
// Generate and display 5 random floating point values from 0 to 5.
Console::WriteLine("Five Doubles between 0 and 5.");
for (int ctr = 0; ctr <= 4; ctr++)
Console::Write("{0,8:N3}", rand->NextDouble() * 5);
}
// The example displays output like the following:
//    Five random byte values:
//      194  185  239   54  116
//    Five random integer values:
//        507,353,531  1,509,532,693  2,125,074,958  1,409,512,757    652,767,128
//    Five random integers between 0 and 100:
//          16      78      94      79      52
//    Five random integers between 50 and 100:
//          56      66      96      60      65
//    Five Doubles.
//       0.943   0.108   0.744   0.563   0.415
//    Five Doubles between 0 and 5.
//       2.934   3.130   0.292   1.432   4.369
``````
``````// Instantiate random number generator using system-supplied value as seed.
var rand = new Random();

// Generate and display 5 random byte (integer) values.
var bytes = new byte[5];
rand.NextBytes(bytes);
Console.WriteLine("Five random byte values:");
foreach (byte byteValue in bytes)
Console.Write("{0, 5}", byteValue);
Console.WriteLine();

// Generate and display 5 random integers.
Console.WriteLine("Five random integer values:");
for (int ctr = 0; ctr <= 4; ctr++)
Console.Write("{0,15:N0}", rand.Next());
Console.WriteLine();

// Generate and display 5 random integers between 0 and 100.
Console.WriteLine("Five random integers between 0 and 100:");
for (int ctr = 0; ctr <= 4; ctr++)
Console.Write("{0,8:N0}", rand.Next(101));
Console.WriteLine();

// Generate and display 5 random integers from 50 to 100.
Console.WriteLine("Five random integers between 50 and 100:");
for (int ctr = 0; ctr <= 4; ctr++)
Console.Write("{0,8:N0}", rand.Next(50, 101));
Console.WriteLine();

// Generate and display 5 random floating point values from 0 to 1.
Console.WriteLine("Five Doubles.");
for (int ctr = 0; ctr <= 4; ctr++)
Console.Write("{0,8:N3}", rand.NextDouble());
Console.WriteLine();

// Generate and display 5 random floating point values from 0 to 5.
Console.WriteLine("Five Doubles between 0 and 5.");
for (int ctr = 0; ctr <= 4; ctr++)
Console.Write("{0,8:N3}", rand.NextDouble() * 5);

// The example displays output like the following:
//    Five random byte values:
//      194  185  239   54  116
//    Five random integer values:
//        507,353,531  1,509,532,693  2,125,074,958  1,409,512,757    652,767,128
//    Five random integers between 0 and 100:
//          16      78      94      79      52
//    Five random integers between 50 and 100:
//          56      66      96      60      65
//    Five Doubles.
//       0.943   0.108   0.744   0.563   0.415
//    Five Doubles between 0 and 5.
//       2.934   3.130   0.292   1.432   4.369
``````
``````Module Example
Public Sub Main()
' Instantiate random number generator using system-supplied value as seed.
Dim rand As New Random()
' Generate and display 5 random byte (integer) values.
Dim bytes(4) As Byte
rand.NextBytes(bytes)
Console.WriteLine("Five random byte values:")
For Each byteValue As Byte In bytes
Console.Write("{0, 5}", byteValue)
Next
Console.WriteLine()
' Generate and display 5 random integers.
Console.WriteLine("Five random integer values:")
For ctr As Integer = 0 To 4
Console.Write("{0,15:N0}", rand.Next)
Next
Console.WriteLine()
' Generate and display 5 random integers between 0 and 100.'
Console.WriteLine("Five random integers between 0 and 100:")
For ctr As Integer = 0 To 4
Console.Write("{0,8:N0}", rand.Next(101))
Next
Console.WriteLine()
' Generate and display 5 random integers from 50 to 100.
Console.WriteLine("Five random integers between 50 and 100:")
For ctr As Integer = 0 To 4
Console.Write("{0,8:N0}", rand.Next(50, 101))
Next
Console.WriteLine()
' Generate and display 5 random floating point values from 0 to 1.
Console.WriteLine("Five Doubles.")
For ctr As Integer = 0 To 4
Console.Write("{0,8:N3}", rand.NextDouble())
Next
Console.WriteLine()
' Generate and display 5 random floating point values from 0 to 5.
Console.WriteLine("Five Doubles between 0 and 5.")
For ctr As Integer = 0 To 4
Console.Write("{0,8:N3}", rand.NextDouble() * 5)
Next
End Sub
End Module
' The example displays output like the following:
'    Five random byte values:
'      194  185  239   54  116
'    Five random integer values:
'        507,353,531  1,509,532,693  2,125,074,958  1,409,512,757    652,767,128
'    Five random integers between 0 and 100:
'          16      78      94      79      52
'    Five random integers between 50 and 100:
'          56      66      96      60      65
'    Five Doubles.
'       0.943   0.108   0.744   0.563   0.415
'    Five Doubles between 0 and 5.
'       2.934   3.130   0.292   1.432   4.369
``````

L’exemple suivant génère un entier aléatoire qu’il utilise comme index pour récupérer une valeur de chaîne d’un tableau.The following example generates a random integer that it uses as an index to retrieve a string value from an array.

``````using namespace System;

void main()
{
Random^ rnd = gcnew Random();
array<String^>^ malePetNames = { "Rufus", "Bear", "Dakota", "Fido",
"Vanya", "Samuel", "Koani", "Volodya",
"Prince", "Yiska" };
array<String^>^ femalePetNames = { "Maggie", "Penny", "Saya", "Princess",
"Starlight", "Talla" };

// Generate random indexes for pet names.
int mIndex = rnd->Next(malePetNames->Length);
int fIndex = rnd->Next(femalePetNames->Length);

// Display the result.
Console::WriteLine("Suggested pet name of the day: ");
Console::WriteLine("   For a male:     {0}", malePetNames[mIndex]);
Console::WriteLine("   For a female:   {0}", femalePetNames[fIndex]);
}
// The example displays output similar to the following:
//       Suggested pet name of the day:
//          For a male:     Koani
//          For a female:   Maggie
``````
``````Random rnd = new Random();
string[] malePetNames = { "Rufus", "Bear", "Dakota", "Fido",
"Vanya", "Samuel", "Koani", "Volodya",
"Prince", "Yiska" };
string[] femalePetNames = { "Maggie", "Penny", "Saya", "Princess",
"Starlight", "Talla" };

// Generate random indexes for pet names.
int mIndex = rnd.Next(malePetNames.Length);
int fIndex = rnd.Next(femalePetNames.Length);

// Display the result.
Console.WriteLine("Suggested pet name of the day: ");
Console.WriteLine("   For a male:     {0}", malePetNames[mIndex]);
Console.WriteLine("   For a female:   {0}", femalePetNames[fIndex]);

// The example displays output similar to the following:
//       Suggested pet name of the day:
//          For a male:     Koani
//          For a female:   Maggie
``````
``````Module Example
Public Sub Main()
Dim rnd As New Random()
Dim malePetNames() As String = { "Rufus", "Bear", "Dakota", "Fido",
"Vanya", "Samuel", "Koani", "Volodya",
"Prince", "Yiska" }
Dim femalePetNames() As String = { "Maggie", "Penny", "Saya", "Princess",
"Starlight", "Talla" }

' Generate random indexes for pet names.
Dim mIndex As Integer = rnd.Next(malePetNames.Length)
Dim fIndex As Integer = rnd.Next(femalePetNames.Length)

' Display the result.
Console.WriteLine("Suggested pet name of the day: ")
Console.WriteLine("   For a male:     {0}", malePetNames(mIndex))
Console.WriteLine("   For a female:   {0}", femalePetNames(fIndex))
End Sub
End Module
' The example displays output similar to the following:
'       Suggested pet name of the day:
'          For a male:     Koani
'          For a female:   Maggie
``````

## Remarques

Les nombres pseudo-aléatoires sont choisis avec la même probabilité à partir d’un ensemble fini de nombres.Pseudo-random numbers are chosen with equal probability from a finite set of numbers. Les nombres choisis ne sont pas complètement aléatoires, car un algorithme mathématique est utilisé pour les sélectionner, mais ils sont suffisamment aléatoires pour des raisons pratiques.The chosen numbers are not completely random because a mathematical algorithm is used to select them, but they are sufficiently random for practical purposes. L’implémentation actuelle de la Random classe est basée sur une version modifiée de l’algorithme de génération de nombres aléatoires Donald E. Knuth.The current implementation of the Random class is based on a modified version of Donald E. Knuth's subtractive random number generator algorithm. Pour plus d’informations, consultez la rubrique D. E.For more information, see D. E. Knuth.Knuth. L’art de la programmation informatique, volume 2 : algorithmes Seminumerical.The Art of Computer Programming, Volume 2: Seminumerical Algorithms. Addison-Wesley, Reading, MA, troisième édition, 1997.Addison-Wesley, Reading, MA, third edition, 1997.

Pour générer un nombre aléatoire sécurisé par chiffrement, tel qu’un nombre adapté à la création d’un mot de passe aléatoire, utilisez la RNGCryptoServiceProvider classe ou dérivez une classe de System.Security.Cryptography.RandomNumberGenerator .To generate a cryptographically secure random number, such as one that's suitable for creating a random password, use the RNGCryptoServiceProvider class or derive a class from System.Security.Cryptography.RandomNumberGenerator.

Dans cette rubrique :In this topic:

### Instanciation du générateur de nombres aléatoiresInstantiating the random number generator

Vous instanciez le générateur de nombres aléatoires en fournissant une valeur de départ (une valeur de départ pour l’algorithme de génération de nombres pseudo-aléatoires) à un Random constructeur de classe.You instantiate the random number generator by providing a seed value (a starting value for the pseudo-random number generation algorithm) to a Random class constructor. Vous pouvez fournir la valeur de départ de manière explicite ou implicite :You can supply the seed value either explicitly or implicitly:

• Le Random(Int32) constructeur utilise une valeur de départ explicite que vous fournissez.The Random(Int32) constructor uses an explicit seed value that you supply.

• Le Random() constructeur utilise la valeur de départ par défaut.The Random() constructor uses the default seed value. Il s’agit de la méthode la plus courante pour instancier le générateur de nombres aléatoires.This is the most common way of instantiating the random number generator.

Dans .NET Framework, la valeur initiale par défaut est dépendante du temps.In .NET Framework, the default seed value is time-dependent. Dans .NET Core, la valeur initiale par défaut est produite par le générateur de nombres pseudo-aléatoires statiques de thread.In .NET Core, the default seed value is produced by the thread-static, pseudo-random number generator.

Si la même valeur de départ est utilisée pour des Random objets distincts, ceux-ci génèrent la même série de nombres aléatoires.If the same seed is used for separate Random objects, they will generate the same series of random numbers. Cela peut être utile pour créer une suite de tests qui traite des valeurs aléatoires ou pour relire des jeux qui dérivent leurs données de nombres aléatoires.This can be useful for creating a test suite that processes random values, or for replaying games that derive their data from random numbers. Toutefois, Notez que Random les objets dans les processus s’exécutant sous différentes versions du .NET Framework peuvent retourner des séries de nombres aléatoires différents même s’ils sont instanciés avec des valeurs de départ identiques.However, note that Random objects in processes running under different versions of the .NET Framework may return different series of random numbers even if they're instantiated with identical seed values.

Pour produire différentes séquences de nombres aléatoires, vous pouvez rendre la valeur de départ dépendante du temps, ce qui produit une série différente avec chaque nouvelle instance de Random .To produce different sequences of random numbers, you can make the seed value time-dependent, thereby producing a different series with each new instance of Random. Le constructeur paramétré Random(Int32) peut prendre une Int32 valeur en fonction du nombre de graduations dans l’heure actuelle, tandis que le constructeur sans paramètre Random() utilise l’horloge système pour générer sa valeur de départ.The parameterized Random(Int32) constructor can take an Int32 value based on the number of ticks in the current time, whereas the parameterless Random() constructor uses the system clock to generate its seed value. Toutefois, sur la .NET Framework uniquement, étant donné que l’horloge a une résolution finie, l’utilisation du constructeur sans paramètre pour créer des objets différents à la Random suite crée des générateurs de nombres aléatoires qui produisent des séquences identiques de nombres aléatoires.However, on the .NET Framework only, because the clock has finite resolution, using the parameterless constructor to create different Random objects in close succession creates random number generators that produce identical sequences of random numbers. L’exemple suivant illustre la façon dont deux Random objets instanciés de manière rapprochée dans une application .NET Framework génèrent une série de nombres aléatoires identique.The following example illustrates how two Random objects that are instantiated in close succession in a .NET Framework application generate an identical series of random numbers. Sur la plupart des systèmes Windows, Random les objets créés dans les 15 millisecondes l’un de l’autre sont susceptibles d’avoir des valeurs initiales identiques.On most Windows systems, Random objects created within 15 milliseconds of one another are likely to have identical seed values.

``````using namespace System;

void main()
{
array<Byte>^ bytes1 = gcnew array<Byte>(100);
array<Byte>^ bytes2 = gcnew array<Byte>(100);
Random^ rnd1 = gcnew Random();
Random^ rnd2 = gcnew Random();

rnd1->NextBytes(bytes1);
rnd2->NextBytes(bytes2);

Console::WriteLine("First Series:");
for (int ctr = bytes1->GetLowerBound(0);
ctr <= bytes1->GetUpperBound(0);
ctr++) {
Console::Write("{0, 5}", bytes1[ctr]);
if ((ctr + 1) % 10 == 0) Console::WriteLine();
}
Console::WriteLine();
Console::WriteLine("Second Series:");
for (int ctr = bytes2->GetLowerBound(0);
ctr <= bytes2->GetUpperBound(0);
ctr++) {
Console::Write("{0, 5}", bytes2[ctr]);
if ((ctr + 1) % 10 == 0) Console::WriteLine();
}
}
// The example displays output like the following:
//       First Series:
//          97  129  149   54   22  208  120  105   68  177
//         113  214   30  172   74  218  116  230   89   18
//          12  112  130  105  116  180  190  200  187  120
//           7  198  233  158   58   51   50  170   98   23
//          21    1  113   74  146  245   34  255   96   24
//         232  255   23    9  167  240  255   44  194   98
//          18  175  173  204  169  171  236  127  114   23
//         167  202  132   65  253   11  254   56  214  127
//         145  191  104  163  143    7  174  224  247   73
//          52    6  231  255    5  101   83  165  160  231
//
//       Second Series:
//          97  129  149   54   22  208  120  105   68  177
//         113  214   30  172   74  218  116  230   89   18
//          12  112  130  105  116  180  190  200  187  120
//           7  198  233  158   58   51   50  170   98   23
//          21    1  113   74  146  245   34  255   96   24
//         232  255   23    9  167  240  255   44  194   98
//          18  175  173  204  169  171  236  127  114   23
//         167  202  132   65  253   11  254   56  214  127
//         145  191  104  163  143    7  174  224  247   73
//          52    6  231  255    5  101   83  165  160  231
``````
``````byte[] bytes1 = new byte[100];
byte[] bytes2 = new byte[100];
Random rnd1 = new Random();
Random rnd2 = new Random();

rnd1.NextBytes(bytes1);
rnd2.NextBytes(bytes2);

Console.WriteLine("First Series:");
for (int ctr = bytes1.GetLowerBound(0);
ctr <= bytes1.GetUpperBound(0);
ctr++) {
Console.Write("{0, 5}", bytes1[ctr]);
if ((ctr + 1) % 10 == 0) Console.WriteLine();
}

Console.WriteLine();

Console.WriteLine("Second Series:");
for (int ctr = bytes2.GetLowerBound(0);
ctr <= bytes2.GetUpperBound(0);
ctr++) {
Console.Write("{0, 5}", bytes2[ctr]);
if ((ctr + 1) % 10 == 0) Console.WriteLine();
}

// The example displays output like the following:
//       First Series:
//          97  129  149   54   22  208  120  105   68  177
//         113  214   30  172   74  218  116  230   89   18
//          12  112  130  105  116  180  190  200  187  120
//           7  198  233  158   58   51   50  170   98   23
//          21    1  113   74  146  245   34  255   96   24
//         232  255   23    9  167  240  255   44  194   98
//          18  175  173  204  169  171  236  127  114   23
//         167  202  132   65  253   11  254   56  214  127
//         145  191  104  163  143    7  174  224  247   73
//          52    6  231  255    5  101   83  165  160  231
//
//       Second Series:
//          97  129  149   54   22  208  120  105   68  177
//         113  214   30  172   74  218  116  230   89   18
//          12  112  130  105  116  180  190  200  187  120
//           7  198  233  158   58   51   50  170   98   23
//          21    1  113   74  146  245   34  255   96   24
//         232  255   23    9  167  240  255   44  194   98
//          18  175  173  204  169  171  236  127  114   23
//         167  202  132   65  253   11  254   56  214  127
//         145  191  104  163  143    7  174  224  247   73
//          52    6  231  255    5  101   83  165  160  231
``````
``````Module modMain

Public Sub Main()
Dim bytes1(99), bytes2(99) As Byte
Dim rnd1 As New Random()
Dim rnd2 As New Random()

rnd1.NextBytes(bytes1)
rnd2.NextBytes(bytes2)

Console.WriteLine("First Series:")
For ctr As Integer = bytes1.GetLowerBound(0) to bytes1.GetUpperBound(0)
Console.Write("{0, 5}", bytes1(ctr))
If (ctr + 1) Mod 10 = 0 Then Console.WriteLine()
Next
Console.WriteLine()
Console.WriteLine("Second Series:")
For ctr As Integer = bytes2.GetLowerBound(0) to bytes2.GetUpperBound(0)
Console.Write("{0, 5}", bytes2(ctr))
If (ctr + 1) Mod 10 = 0 Then Console.WriteLine()
Next
End Sub
End Module
' The example displays output like the following:
'       First Series:
'          97  129  149   54   22  208  120  105   68  177
'         113  214   30  172   74  218  116  230   89   18
'          12  112  130  105  116  180  190  200  187  120
'           7  198  233  158   58   51   50  170   98   23
'          21    1  113   74  146  245   34  255   96   24
'         232  255   23    9  167  240  255   44  194   98
'          18  175  173  204  169  171  236  127  114   23
'         167  202  132   65  253   11  254   56  214  127
'         145  191  104  163  143    7  174  224  247   73
'          52    6  231  255    5  101   83  165  160  231
'
'       Second Series:
'          97  129  149   54   22  208  120  105   68  177
'         113  214   30  172   74  218  116  230   89   18
'          12  112  130  105  116  180  190  200  187  120
'           7  198  233  158   58   51   50  170   98   23
'          21    1  113   74  146  245   34  255   96   24
'         232  255   23    9  167  240  255   44  194   98
'          18  175  173  204  169  171  236  127  114   23
'         167  202  132   65  253   11  254   56  214  127
'         145  191  104  163  143    7  174  224  247   73
'          52    6  231  255    5  101   83  165  160  231
``````

Pour éviter ce problème, créez un Random objet unique au lieu de plusieurs objets.To avoid this problem, create a single Random object instead of multiple objects. Notez que la `Random` classe dans .net Core n’a pas cette limitation.Note that the `Random` class in .NET Core does not have this limitation.

### Éviter les instanciations multiplesAvoiding multiple instantiations

Sur la .NET Framework, l’initialisation de deux générateurs de nombres aléatoires dans une boucle serrée ou à la suite rapide crée deux générateurs de nombres aléatoires qui peuvent produire des séquences identiques de nombres aléatoires.On the .NET Framework, initializing two random number generators in a tight loop or in rapid succession creates two random number generators that can produce identical sequences of random numbers. Dans la plupart des cas, il ne s’agit pas de l’intention du développeur et peut entraîner des problèmes de performances, car l’instanciation et l’initialisation d’un générateur de nombres aléatoires est un processus relativement onéreux.In most cases, this is not the developer's intent and can lead to performance issues, because instantiating and initializing a random number generator is a relatively expensive process.

Pour améliorer les performances et pour éviter de créer par inadvertance des générateurs de nombres aléatoires distincts qui génèrent des séquences numériques identiques, nous vous recommandons de créer un Random objet pour générer plusieurs nombres aléatoires dans le temps, au lieu de créer des Random objets pour générer un nombre aléatoire.Both to improve performance and to avoid inadvertently creating separate random number generators that generate identical numeric sequences, we recommend that you create one Random object to generate many random numbers over time, instead of creating new Random objects to generate one random number.

Toutefois, la Random classe n’est pas thread-safe.However, the Random class isn't thread safe. Si vous appelez Random des méthodes à partir de plusieurs threads, suivez les instructions présentées dans la section suivante.If you call Random methods from multiple threads, follow the guidelines discussed in the next section.

### La classe System. Random et la sécurité des threadsThe System.Random class and thread safety

L’exemple suivant utilise l' instruction lock C# et l' instruction Visual Basic SyncLock pour s’assurer qu’un seul générateur de nombres aléatoires est accessible par 11 threads de manière thread-safe.The following example uses the C# lock Statement and the Visual Basic SyncLock statement to ensure that a single random number generator is accessed by 11 threads in a thread-safe manner. Chaque thread génère des nombres aléatoires 2 millions, compte le nombre de nombres aléatoires générés et calcule leur somme, puis met à jour les totaux pour tous les threads une fois l’exécution terminée.Each thread generates 2 million random numbers, counts the number of random numbers generated and calculates their sum, and then updates the totals for all threads when it finishes executing.

``````using namespace System;

ref class Example
{
private:
[ThreadStatic] static double previous = 0.0;
static CancellationTokenSource^ source;
static CountdownEvent^ countdown;
static Object^ randLock;
static Object^ numericLock;
static Random^ rand;
double totalValue = 0.0;
int totalCount = 0;

public:
Example()
{
rand = gcnew Random();
randLock = gcnew Object();
numericLock = gcnew Object();
countdown = gcnew CountdownEvent(1);
source = gcnew CancellationTokenSource();
}

void Execute()
{
CancellationToken^ token = source->Token;

{
}
this->GetRandomNumbers(token);

countdown->Signal();
// Make sure all threads have finished.
countdown->Wait();

Console::WriteLine("\nTotal random numbers generated: {0:N0}", totalCount);
Console::WriteLine("Total sum of all random numbers: {0:N2}", totalValue);
Console::WriteLine("Random number mean: {0:N4}", totalValue/totalCount);
}

private:
void GetRandomNumbers(Object^ o)
{
CancellationToken^ token = (CancellationToken) o;
double result = 0.0;

try {
for (int ctr = 0; ctr < 2000000; ctr++)
{
// Make sure there's no corruption of Random.
token->ThrowIfCancellationRequested();

Monitor::Enter(randLock);
result = rand->NextDouble();
Monitor::Exit(randLock);
// Check for corruption of Random instance.
if ((result == previous) && result == 0) {
source->Cancel();
}
else {
previous = result;
}
}

Console::WriteLine("Sum of random numbers: {0:N2}", perThreadTotal);

// Update overall totals.
Monitor::Enter(numericLock);
Monitor::Exit(numericLock);
}
catch (OperationCanceledException^ e) {
}
finally {
countdown->Signal();
}
}
};

void main()
{
Example^ ex = gcnew Example();
ex->Execute();
}
// The example displays output like the following:
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 1,000,491.05
//       Random number mean: 0.5002
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,329.64
//       Random number mean: 0.4997
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 1,000,166.89
//       Random number mean: 0.5001
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,628.37
//       Random number mean: 0.4998
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,920.89
//       Random number mean: 0.5000
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,370.45
//       Random number mean: 0.4997
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,330.92
//       Random number mean: 0.4997
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 1,000,172.79
//       Random number mean: 0.5001
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 1,000,079.43
//       Random number mean: 0.5000
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,817.91
//       Random number mean: 0.4999
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,930.63
//       Random number mean: 0.5000
//
//
//       Total random numbers generated: 22,000,000
//       Total sum of all random numbers: 10,998,238.98
//       Random number mean: 0.4999
``````
``````using System;

public class Example
{
[ThreadStatic] static double previous = 0.0;
static CancellationTokenSource source;
static CountdownEvent countdown;
static Object randLock, numericLock;
static Random rand;
double totalValue = 0.0;
int totalCount = 0;

public Example()
{
rand = new Random();
randLock = new Object();
numericLock = new Object();
countdown = new CountdownEvent(1);
source = new CancellationTokenSource();
}

public static void Main()
{
Example ex = new Example();
ex.Execute();
}

private void Execute()
{
CancellationToken token = source.Token;

{
}
this.GetRandomNumbers(token);

countdown.Signal();
// Make sure all threads have finished.
countdown.Wait();
source.Dispose();

Console.WriteLine("\nTotal random numbers generated: {0:N0}", totalCount);
Console.WriteLine("Total sum of all random numbers: {0:N2}", totalValue);
Console.WriteLine("Random number mean: {0:N4}", totalValue/totalCount);
}

private void GetRandomNumbers(Object o)
{
CancellationToken token = (CancellationToken) o;
double result = 0.0;

try {
for (int ctr = 0; ctr < 2000000; ctr++)
{
// Make sure there's no corruption of Random.
token.ThrowIfCancellationRequested();

lock (randLock) {
result = rand.NextDouble();
}
// Check for corruption of Random instance.
if ((result == previous) && result == 0) {
source.Cancel();
}
else {
previous = result;
}
}

Console.WriteLine("Sum of random numbers: {0:N2}", perThreadTotal);

// Update overall totals.
lock (numericLock) {
}
}
catch (OperationCanceledException e) {
}
finally {
countdown.Signal();
}
}
}
// The example displays output like the following:
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 1,000,491.05
//       Random number mean: 0.5002
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,329.64
//       Random number mean: 0.4997
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 1,000,166.89
//       Random number mean: 0.5001
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,628.37
//       Random number mean: 0.4998
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,920.89
//       Random number mean: 0.5000
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,370.45
//       Random number mean: 0.4997
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,330.92
//       Random number mean: 0.4997
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 1,000,172.79
//       Random number mean: 0.5001
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 1,000,079.43
//       Random number mean: 0.5000
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,817.91
//       Random number mean: 0.4999
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,930.63
//       Random number mean: 0.5000
//
//
//       Total random numbers generated: 22,000,000
//       Total sum of all random numbers: 10,998,238.98
//       Random number mean: 0.4999
``````
``````Imports System.Threading

Module Example
<ThreadStatic> Dim previous As Double = 0.0
Dim source As New CancellationTokenSource()
Dim countdown As New CountdownEvent(1)
Dim randLock As New Object()
Dim numericLock As New Object()
Dim rand As New Random()
Dim totalValue As Double = 0.0
Dim totalCount As Integer = 0

Public Sub Main()

Dim token As CancellationToken = source.Token
For threads As Integer = 1 To 10
Next
GetRandomNumbers(token)

countdown.Signal()
' Make sure all threads have finished.
countdown.Wait()

Console.WriteLine()
Console.WriteLine("Total random numbers generated: {0:N0}", totalCount)
Console.WriteLine("Total sum of all random numbers: {0:N2}", totalValue)
Console.WriteLine("Random number mean: {0:N4}", totalValue/totalCount)
End Sub

Private Sub GetRandomNumbers(o As Object)
Dim token As CancellationToken = CType(o, CancellationToken)
Dim result As Double = 0.0

Try
For ctr As Integer = 1 To 2000000
' Make sure there's no corruption of Random.
token.ThrowIfCancellationRequested()

SyncLock randLock
result = rand.NextDouble()
End SyncLock
' Check for corruption of Random instance.
If result = previous AndAlso result = 0 Then
source.Cancel()
Else
previous = result
End If
Next

Console.WriteLine("Sum of random numbers: {0:N2}", perThreadTotal)
Console.WriteLine()

' Update overall totals.
SyncLock numericLock
End SyncLock
Catch e As OperationCanceledException
Finally
countdown.Signal()
source.Dispose()
End Try
End Sub
End Module
' The example displays output like the following:
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 1,000,491.05
'       Random number mean: 0.5002
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 999,329.64
'       Random number mean: 0.4997
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 1,000,166.89
'       Random number mean: 0.5001
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 999,628.37
'       Random number mean: 0.4998
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 999,920.89
'       Random number mean: 0.5000
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 999,370.45
'       Random number mean: 0.4997
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 999,330.92
'       Random number mean: 0.4997
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 1,000,172.79
'       Random number mean: 0.5001
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 1,000,079.43
'       Random number mean: 0.5000
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 999,817.91
'       Random number mean: 0.4999
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 999,930.63
'       Random number mean: 0.5000
'
'
'       Total random numbers generated: 22,000,000
'       Total sum of all random numbers: 10,998,238.98
'       Random number mean: 0.4999
``````

L’exemple garantit la sécurité des threads des manières suivantes :The example ensures thread-safety in the following ways:

• L' ThreadStaticAttribute attribut est utilisé pour définir des variables de thread local qui effectuent le suivi du nombre total de nombres aléatoires générés et de leur somme pour chaque thread.The ThreadStaticAttribute attribute is used to define thread-local variables that track the total number of random numbers generated and their sum for each thread.

• Un verrou (l' `lock` instruction en C# et l' `SyncLock` instruction dans Visual Basic) protège l’accès aux variables pour le nombre total et la somme de tous les nombres aléatoires générés sur tous les threads.A lock (the `lock` statement in C# and the `SyncLock` statement in Visual Basic) protects access to the variables for the total count and sum of all random numbers generated on all threads.

• Un sémaphore (l' CountdownEvent objet) est utilisé pour garantir que le thread principal se bloque jusqu’à ce que tous les autres threads terminent l’exécution.A semaphore (the CountdownEvent object) is used to ensure that the main thread blocks until all other threads complete execution.

• L’exemple vérifie si le générateur de nombres aléatoires a été endommagé en déterminant si deux appels consécutifs à des méthodes de génération de nombres aléatoires retournent 0.The example checks whether the random number generator has become corrupted by determining whether two consecutive calls to random number generation methods return 0. Si une altération est détectée, l’exemple utilise l' CancellationTokenSource objet pour signaler que tous les threads doivent être annulés.If corruption is detected, the example uses the CancellationTokenSource object to signal that all threads should be canceled.

• Avant de générer chaque nombre aléatoire, chaque thread vérifie l’état de l' CancellationToken objet.Before generating each random number, each thread checks the state of the CancellationToken object. Si l’annulation est demandée, l’exemple appelle la CancellationToken.ThrowIfCancellationRequested méthode pour annuler le thread.If cancellation is requested, the example calls the CancellationToken.ThrowIfCancellationRequested method to cancel the thread.

L’exemple suivant est identique au premier, à ceci près qu’il utilise un Task objet et une expression lambda au lieu d' Thread objets.The following example is identical to the first, except that it uses a Task object and a lambda expression instead of Thread objects.

``````using System;
using System.Collections.Generic;

public class Example
{
static Object randLock, numericLock;
static Random rand;
static CancellationTokenSource source;
double totalValue = 0.0;
int totalCount = 0;

public Example()
{
rand = new Random();
randLock = new Object();
numericLock = new Object();
source = new CancellationTokenSource();
}

{
Example ex = new Example();
await ex.Execute();
}

{

for (int ctr = 0; ctr <= 10; ctr++)
{
CancellationToken token = source.Token;
{
double previous = 0.0;
double result = 0.0;

for (int n = 0; n < 2000000; n++)
{
// Make sure there's no corruption of Random.
token.ThrowIfCancellationRequested();

lock (randLock) {
result = rand.NextDouble();
}
// Check for corruption of Random instance.
if ((result == previous) && result == 0) {
source.Cancel();
}
else {
previous = result;
}
}

// Show result.
Console.WriteLine("Sum of random numbers: {0:N2}", taskTotal);

// Update overall totals.
lock (numericLock) {
}
},
token));
}
try {
Console.WriteLine("\nTotal random numbers generated: {0:N0}", totalCount);
Console.WriteLine("Total sum of all random numbers: {0:N2}", totalValue);
Console.WriteLine("Random number mean: {0:N4}", totalValue/totalCount);
}
catch (AggregateException e) {
foreach (Exception inner in e.InnerExceptions) {
if (canc != null)
else
Console.WriteLine("Exception: {0}", inner.GetType().Name);
}
}
finally {
source.Dispose();
}
}
}
// The example displays output like the following:
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 1,000,502.47
//       Random number mean: 0.5003
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 1,000,445.63
//       Random number mean: 0.5002
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 1,000,556.04
//       Random number mean: 0.5003
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 1,000,178.87
//       Random number mean: 0.5001
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,819.17
//       Random number mean: 0.4999
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 1,000,190.58
//       Random number mean: 0.5001
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,720.21
//       Random number mean: 0.4999
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,000.96
//       Random number mean: 0.4995
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,499.33
//       Random number mean: 0.4997
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 1,000,193.25
//       Random number mean: 0.5001
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,960.82
//       Random number mean: 0.5000
//
//
//       Total random numbers generated: 22,000,000
//       Total sum of all random numbers: 11,000,067.33
//       Random number mean: 0.5000
``````
``````Imports System.Collections.Generic

Module Example
Dim source As New CancellationTokenSource()
Dim randLock As New Object()
Dim numericLock As New Object()
Dim rand As New Random()
Dim totalValue As Double = 0.0
Dim totalCount As Integer = 0

Public Sub Main()

For ctr As Integer = 1 To 10
Dim token As CancellationToken = source.Token
Dim taskNo As Integer = ctr
Sub()
Dim previous As Double = 0.0
Dim taskCtr As Integer = 0
Dim taskTotal As Double = 0.0
Dim result As Double = 0.0

For n As Integer = 1 To 2000000
' Make sure there's no corruption of Random.
token.ThrowIfCancellationRequested()

SyncLock randLock
result = rand.NextDouble()
End SyncLock
' Check for corruption of Random instance.
If result = previous AndAlso result = 0 Then
source.Cancel()
Else
previous = result
End If
Next

' Show result.
Console.WriteLine("Sum of random numbers: {0:N2}", taskTotal)
Console.WriteLine()

' Update overall totals.
SyncLock numericLock
End SyncLock
End Sub, token))
Next

Try
Console.WriteLine()
Console.WriteLine("Total random numbers generated: {0:N0}", totalCount)
Console.WriteLine("Total sum of all random numbers: {0:N2}", totalValue)
Console.WriteLine("Random number mean: {0:N4}", totalValue/totalCount)
Catch e As AggregateException
For Each inner As Exception In e.InnerExceptions
If canc IsNot Nothing Then
Else
Console.WriteLine("Exception: {0}", inner.GetType().Name)
End If
Next
Finally
source.Dispose()
End Try
End Sub
End Module
' The example displays output like the following:
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 1,000,502.47
'       Random number mean: 0.5003
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 1,000,445.63
'       Random number mean: 0.5002
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 1,000,556.04
'       Random number mean: 0.5003
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 1,000,178.87
'       Random number mean: 0.5001
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 999,819.17
'       Random number mean: 0.4999
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 1,000,190.58
'       Random number mean: 0.5001
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 999,720.21
'       Random number mean: 0.4999
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 999,000.96
'       Random number mean: 0.4995
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 999,499.33
'       Random number mean: 0.4997
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 1,000,193.25
'       Random number mean: 0.5001
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 999,960.82
'       Random number mean: 0.5000
'
'
'       Total random numbers generated: 22,000,000
'       Total sum of all random numbers: 11,000,067.33
'       Random number mean: 0.5000
``````

Il diffère du premier exemple des manières suivantes :It differs from the first example in the following ways:

• Les variables permettant d’effectuer le suivi du nombre de nombres aléatoires générés et de leur somme dans chaque tâche sont locales à la tâche. il n’est donc pas nécessaire d’utiliser l' ThreadStaticAttribute attribut.The variables to keep track of the number of random numbers generated and their sum in each task are local to the task, so there is no need to use the ThreadStaticAttribute attribute.

• La Task.WaitAll méthode statique est utilisée pour garantir que le thread principal ne se termine pas avant que toutes les tâches soient terminées.The static Task.WaitAll method is used to ensure that the main thread doesn't complete before all tasks have finished. L’objet n’est pas nécessaire CountdownEvent .There is no need for the CountdownEvent object.

• L’exception qui résulte de l’annulation de tâche est exposée dans la Task.WaitAll méthode.The exception that results from task cancellation is surfaced in the Task.WaitAll method. Dans l’exemple précédent, il est géré par chaque thread.In the previous example, it is handled by each thread.

### Génération de différents types de nombres aléatoiresGenerating different types of random numbers

Le générateur de nombres aléatoires fournit des méthodes qui vous permettent de générer les genres de nombres aléatoires suivants :The random number generator provides methods that let you generate the following kinds of random numbers:

• Série de Byte valeurs.A series of Byte values. Vous déterminez le nombre de valeurs d’octets en passant un tableau initialisé au nombre d’éléments que vous souhaitez que la méthode retourne à la NextBytes méthode.You determine the number of byte values by passing an array initialized to the number of elements you want the method to return to the NextBytes method. L’exemple suivant génère 20 octets.The following example generates 20 bytes.

``````using namespace System;

void main()
{
Random^ rnd = gcnew Random();
array<Byte>^ bytes = gcnew array<Byte>(20);
rnd->NextBytes(bytes);
for (int ctr = 1; ctr <= bytes->Length; ctr++) {
Console::Write("{0,3}   ", bytes[ctr - 1]);
if (ctr % 10 == 0) Console::WriteLine();
}
}
// The example displays output like the following:
//       141    48   189    66   134   212   211    71   161    56
//       181   166   220   133     9   252   222    57    62    62
``````
``````Random rnd = new Random();
Byte[] bytes = new Byte[20];
rnd.NextBytes(bytes);
for (int ctr = 1; ctr <= bytes.Length; ctr++) {
Console.Write("{0,3}   ", bytes[ctr - 1]);
if (ctr % 10 == 0) Console.WriteLine();
}

// The example displays output like the following:
//       141    48   189    66   134   212   211    71   161    56
//       181   166   220   133     9   252   222    57    62    62
``````
``````Module Example
Public Sub Main()
Dim rnd As New Random()
Dim bytes(19) As Byte
rnd.NextBytes(bytes)
For ctr As Integer = 1 To bytes.Length
Console.Write("{0,3}   ", bytes(ctr - 1))
If ctr Mod 10 = 0 Then Console.WriteLine()
Next
End Sub
End Module
' The example displays output like the following:
'       141    48   189    66   134   212   211    71   161    56
'       181   166   220   133     9   252   222    57    62    62
``````
• Entier unique.A single integer. Vous pouvez choisir si vous souhaitez qu’un entier soit compris entre 0 et une valeur maximale ( Int32.MaxValue -1) en appelant la Next() méthode, un entier compris entre 0 et une valeur spécifique en appelant la Next(Int32) méthode, ou un entier dans une plage de valeurs en appelant la Next(Int32, Int32) méthode.You can choose whether you want an integer from 0 to a maximum value (Int32.MaxValue - 1) by calling the Next() method, an integer between 0 and a specific value by calling the Next(Int32) method, or an integer within a range of values by calling the Next(Int32, Int32) method. Dans les surcharges paramétrables, la valeur maximale spécifiée est exclusive ; autrement dit, le nombre maximal réel généré est inférieur ou égal à la valeur spécifiée.In the parameterized overloads, the specified maximum value is exclusive; that is, the actual maximum number generated is one less than the specified value.

L’exemple suivant appelle la Next(Int32, Int32) méthode pour générer 10 nombres aléatoires compris entre-10 et 10.The following example calls the Next(Int32, Int32) method to generate 10 random numbers between -10 and 10. Notez que le deuxième argument de la méthode spécifie la limite supérieure exclusive de la plage de valeurs aléatoires retournées par la méthode.Note that the second argument to the method specifies the exclusive upper bound of the range of random values returned by the method. En d’autres termes, le plus grand entier que la méthode peut retourner est inférieur à cette valeur.In other words, the largest integer that the method can return is one less than this value.

``````using namespace System;

void main()
{
Random^ rnd = gcnew Random();
for (int ctr = 0; ctr < 10; ctr++) {
Console::Write("{0,3}   ", rnd->Next(-10, 11));
}
}
// The example displays output like the following:
//    2     9    -3     2     4    -7    -3    -8    -8     5
``````
``````Random rnd = new Random();
for (int ctr = 0; ctr < 10; ctr++) {
Console.Write("{0,3}   ", rnd.Next(-10, 11));
}

// The example displays output like the following:
//    2     9    -3     2     4    -7    -3    -8    -8     5
``````
``````Module Example
Public Sub Main()
Dim rnd As New Random()
For ctr As Integer = 0 To 9
Console.Write("{0,3}   ", rnd.Next(-10, 11))
Next
End Sub
End Module
' The example displays output like the following:
'    2     9    -3     2     4    -7    -3    -8    -8     5
``````
• Valeur à virgule flottante unique comprise entre 0,0 et 1,0 en appelant la NextDouble méthode.A single floating-point value from 0.0 to less than 1.0 by calling the NextDouble method. La limite supérieure exclusive du nombre aléatoire retourné par la méthode est 1, donc sa limite supérieure réelle est 0.99999999999999978.The exclusive upper bound of the random number returned by the method is 1, so its actual upper bound is 0.99999999999999978. L’exemple suivant génère 10 nombres à virgule flottante aléatoires.The following example generates 10 random floating-point numbers.

``````using namespace System;

void main()
{
Random^ rnd = gcnew Random();
for (int ctr = 0; ctr < 10; ctr++) {
Console::Write("{0,-19:R}   ", rnd->NextDouble());
if ((ctr + 1) % 3 == 0) Console::WriteLine();
}
}
// The example displays output like the following:
//    0.7911680553998649    0.0903414949264105    0.79776258291572455
//    0.615568345233597     0.652644504165577     0.84023809378977776
//    0.099662564741290441   0.91341467383942321  0.96018602045261581
//    0.74772306473354022
``````
``````Random rnd = new Random();
for (int ctr = 0; ctr < 10; ctr++) {
Console.Write("{0,-19:R}   ", rnd.NextDouble());
if ((ctr + 1) % 3 == 0) Console.WriteLine();
}

// The example displays output like the following:
//    0.7911680553998649    0.0903414949264105    0.79776258291572455
//    0.615568345233597     0.652644504165577     0.84023809378977776
//    0.099662564741290441   0.91341467383942321  0.96018602045261581
//    0.74772306473354022
``````
``````Module Example
Public Sub Main()
Dim rnd As New Random()
For ctr As Integer = 0 To 9
Console.Write("{0,-19:R}   ", rnd.NextDouble())
If (ctr + 1) Mod 3 = 0 Then Console.WriteLine()
Next
End Sub
End Module
' The example displays output like the following:
'    0.7911680553998649    0.0903414949264105    0.79776258291572455
'    0.615568345233597     0.652644504165577     0.84023809378977776
'    0.099662564741290441  0.91341467383942321   0.96018602045261581
'    0.74772306473354022
``````

Important

La Next(Int32, Int32) méthode vous permet de spécifier la plage du nombre aléatoire retourné.The Next(Int32, Int32) method allows you to specify the range of the returned random number. Toutefois, le `maxValue` paramètre, qui spécifie le nombre retourné de la plage supérieure, est une valeur exclusive, pas une valeur inclusive.However, the `maxValue` parameter, which specifies the upper range returned number, is an exclusive, not an inclusive, value. Cela signifie que l’appel de la méthode `Next(0, 100)` retourne une valeur comprise entre 0 et 99, et non entre 0 et 100.This means that the method call `Next(0, 100)` returns a value between 0 and 99, and not between 0 and 100.

Vous pouvez également utiliser la Random classe pour des tâches telles que la génération de valeursde type T :System.Boolean aléatoires, la génération de valeurs à virgule flottante aléatoires avec une plage différente de 0 à 1, lagénération d' entiers aléatoires 64 bitset la récupération aléatoire d’un élément unique à partir d’un tableau ou d’une collection.You can also use the Random class for such tasks as generating random T:System.Boolean values, generating random floating point values with a range other than 0 to 1, generating random 64-bit integers, and randomly retrieving a unique element from an array or collection. Pour ces tâches courantes et d’autres, consultez la page comment utiliser System. Random to...For these and other common tasks, see the How do you use System.Random to… un peu plus loin dans cet article, aborde l’actualisation de chaque type de source de données.section.

### Substitution de votre propre algorithmeSubstituting your own algorithm

Vous pouvez implémenter votre propre générateur de nombres aléatoires en héritant de la Random classe et en fournissant votre algorithme de génération de nombres aléatoires.You can implement your own random number generator by inheriting from the Random class and supplying your random number generation algorithm. Pour fournir votre propre algorithme, vous devez substituer la Sample méthode, qui implémente l’algorithme de génération de nombres aléatoires.To supply your own algorithm, you must override the Sample method, which implements the random number generation algorithm. Vous devez également substituer les Next() Next(Int32, Int32) méthodes, et NextBytes pour vous assurer qu’elles appellent votre méthode substituée Sample .You should also override the Next(), Next(Int32, Int32), and NextBytes methods to ensure that they call your overridden Sample method. Vous n’avez pas besoin de substituer les Next(Int32) NextDouble méthodes et.You don't have to override the Next(Int32) and NextDouble methods.

Pour obtenir un exemple qui dérive de la Random classe et modifie son générateur de nombres pseudo-aléatoires par défaut, consultez la Sample page de référence.For an example that derives from the Random class and modifies its default pseudo-random number generator, see the Sample reference page.

### Comment utiliser System. Random pour...How do you use System.Random to…

Les sections suivantes décrivent et fournissent des exemples de code pour certaines des manières dont vous pouvez utiliser des nombres aléatoires dans votre application.The following sections discuss and provide sample code for some of the ways you might want to use random numbers in your app.

#### Récupérer la même séquence de valeurs aléatoiresRetrieve the same sequence of random values

Parfois, vous souhaitez générer la même séquence de nombres aléatoires dans les scénarios de test de logiciel et de jeux.Sometimes you want to generate the same sequence of random numbers in software test scenarios and in game playing. Le test avec la même séquence de nombres aléatoires vous permet de détecter les régressions et de confirmer les correctifs de bogues.Testing with the same sequence of random numbers allows you to detect regressions and confirm bug fixes. L’utilisation de la même séquence de nombres aléatoires dans les jeux vous permet de relire les jeux précédents.Using the same sequence of random number in games allows you to replay previous games.

Vous pouvez générer la même séquence de nombres aléatoires en fournissant la même valeur de départ au Random(Int32) constructeur.You can generate the same sequence of random numbers by providing the same seed value to the Random(Int32) constructor. La valeur de départ fournit une valeur de départ pour l’algorithme de génération de nombres pseudo-aléatoires.The seed value provides a starting value for the pseudo-random number generation algorithm. L’exemple suivant utilise 100100 comme valeur initiale arbitraire pour instancier l' Random objet, affiche 20 valeurs à virgule flottante aléatoires et conserve la valeur de départ.The following example uses 100100 as an arbitrary seed value to instantiate the Random object, displays 20 random floating-point values, and persists the seed value. Il restaure ensuite la valeur de départ, instancie un nouveau générateur de nombres aléatoires et affiche les mêmes 20 valeurs à virgule flottante aléatoires.It then restores the seed value, instantiates a new random number generator, and displays the same 20 random floating-point values. Notez que l’exemple peut produire des séquences de nombres aléatoires différentes si elles sont exécutées sur des versions différentes du .NET Framework.Note that the example may produce different sequences of random numbers if run on different versions of the .NET Framework.

``````using System;
using System.IO;

public class Example
{
public static void Main()
{
int seed = 100100;
ShowRandomNumbers(seed);
Console.WriteLine();

PersistSeed(seed);

DisplayNewRandomNumbers();
}

private static void ShowRandomNumbers(int seed)
{
Random rnd = new Random(seed);
for (int ctr = 0; ctr <= 20; ctr++)
Console.WriteLine(rnd.NextDouble());
}

private static void PersistSeed(int seed)
{
FileStream fs = new FileStream(@".\seed.dat", FileMode.Create);
BinaryWriter bin = new BinaryWriter(fs);
bin.Write(seed);
bin.Close();
}

private static void DisplayNewRandomNumbers()
{
FileStream fs = new FileStream(@".\seed.dat", FileMode.Open);
bin.Close();

Random rnd = new Random(seed);
for (int ctr = 0; ctr <= 20; ctr++)
Console.WriteLine(rnd.NextDouble());
}
}
// The example displays output like the following:
//       0.500193602172748
//       0.0209461245783354
//       0.465869495396442
//       0.195512794514891
//       0.928583675496552
//       0.729333720509584
//       0.381455668891527
//       0.0508996467343064
//       0.019261200921266
//       0.258578445417145
//       0.0177532266908107
//       0.983277184415272
//       0.483650274334313
//       0.0219647376900375
//       0.165910115077118
//       0.572085966622497
//       0.805291457942357
//       0.927985211335116
//       0.4228545699375
//       0.523320379910674
//       0.157783938645285
//
//       0.500193602172748
//       0.0209461245783354
//       0.465869495396442
//       0.195512794514891
//       0.928583675496552
//       0.729333720509584
//       0.381455668891527
//       0.0508996467343064
//       0.019261200921266
//       0.258578445417145
//       0.0177532266908107
//       0.983277184415272
//       0.483650274334313
//       0.0219647376900375
//       0.165910115077118
//       0.572085966622497
//       0.805291457942357
//       0.927985211335116
//       0.4228545699375
//       0.523320379910674
//       0.157783938645285
``````
``````using namespace System;
using namespace System::IO;

ref class RandomMethods
{
internal:
static void ShowRandomNumbers(int seed)
{
Random^ rnd = gcnew Random(seed);
for (int ctr = 0; ctr <= 20; ctr++)
Console::WriteLine(rnd->NextDouble());
}

static void PersistSeed(int seed)
{
FileStream^ fs = gcnew FileStream(".\\seed.dat", FileMode::Create);
BinaryWriter^ bin = gcnew BinaryWriter(fs);
bin->Write(seed);
bin->Close();
}

static void DisplayNewRandomNumbers()
{
FileStream^ fs = gcnew FileStream(".\\seed.dat", FileMode::Open);
bin->Close();

Random^ rnd = gcnew Random(seed);
for (int ctr = 0; ctr <= 20; ctr++)
Console::WriteLine(rnd->NextDouble());
}
};

void main()
{
int seed = 100100;
RandomMethods::ShowRandomNumbers(seed);
Console::WriteLine();

RandomMethods::PersistSeed(seed);

RandomMethods::DisplayNewRandomNumbers();
}
// The example displays output like the following:
//       0.500193602172748
//       0.0209461245783354
//       0.465869495396442
//       0.195512794514891
//       0.928583675496552
//       0.729333720509584
//       0.381455668891527
//       0.0508996467343064
//       0.019261200921266
//       0.258578445417145
//       0.0177532266908107
//       0.983277184415272
//       0.483650274334313
//       0.0219647376900375
//       0.165910115077118
//       0.572085966622497
//       0.805291457942357
//       0.927985211335116
//       0.4228545699375
//       0.523320379910674
//       0.157783938645285
//
//       0.500193602172748
//       0.0209461245783354
//       0.465869495396442
//       0.195512794514891
//       0.928583675496552
//       0.729333720509584
//       0.381455668891527
//       0.0508996467343064
//       0.019261200921266
//       0.258578445417145
//       0.0177532266908107
//       0.983277184415272
//       0.483650274334313
//       0.0219647376900375
//       0.165910115077118
//       0.572085966622497
//       0.805291457942357
//       0.927985211335116
//       0.4228545699375
//       0.523320379910674
//       0.157783938645285
``````
``````Imports System.IO

Module Example
Public Sub Main()
Dim seed As Integer = 100100
ShowRandomNumbers(seed)
Console.WriteLine()

PersistSeed(seed)

DisplayNewRandomNumbers()
End Sub

Private Sub ShowRandomNumbers(seed As Integer)
Dim rnd As New Random(seed)
For ctr As Integer = 0 To 20
Console.WriteLine(rnd.NextDouble())
Next
End Sub

Private Sub PersistSeed(seed As Integer)
Dim fs As New FileStream(".\seed.dat", FileMode.Create)
Dim bin As New BinaryWriter(fs)
bin.Write(seed)
bin.Close()
End Sub

Private Sub DisplayNewRandomNumbers()
Dim fs As New FileStream(".\seed.dat", FileMode.Open)
Dim seed As Integer = bin.ReadInt32()
bin.Close()

Dim rnd As New Random(seed)
For ctr As Integer = 0 To 20
Console.WriteLine(rnd.NextDouble())
Next
End Sub
End Module
' The example displays output like the following:
'       0.500193602172748
'       0.0209461245783354
'       0.465869495396442
'       0.195512794514891
'       0.928583675496552
'       0.729333720509584
'       0.381455668891527
'       0.0508996467343064
'       0.019261200921266
'       0.258578445417145
'       0.0177532266908107
'       0.983277184415272
'       0.483650274334313
'       0.0219647376900375
'       0.165910115077118
'       0.572085966622497
'       0.805291457942357
'       0.927985211335116
'       0.4228545699375
'       0.523320379910674
'       0.157783938645285
'
'       0.500193602172748
'       0.0209461245783354
'       0.465869495396442
'       0.195512794514891
'       0.928583675496552
'       0.729333720509584
'       0.381455668891527
'       0.0508996467343064
'       0.019261200921266
'       0.258578445417145
'       0.0177532266908107
'       0.983277184415272
'       0.483650274334313
'       0.0219647376900375
'       0.165910115077118
'       0.572085966622497
'       0.805291457942357
'       0.927985211335116
'       0.4228545699375
'       0.523320379910674
'       0.157783938645285
``````

#### Récupérer des séquences uniques de nombres aléatoiresRetrieve unique sequences of random numbers

En fournissant différentes valeurs de départ aux instances de la Random classe, chaque générateur de nombres aléatoires produit une séquence de valeurs différente.Providing different seed values to instances of the Random class causes each random number generator to produce a different sequence of values. Vous pouvez fournir une valeur de départ soit explicitement en appelant le Random(Int32) constructeur, soit implicitement en appelant le Random() constructeur.You can provide a seed value either explicitly by calling the Random(Int32) constructor, or implicitly by calling the Random() constructor. La plupart des développeurs appellent le constructeur sans paramètre, qui utilise l’horloge système.Most developers call the parameterless constructor, which uses the system clock. L’exemple suivant utilise cette approche pour instancier deux Random instances.The following example uses this approach to instantiate two Random instances. Chaque instance affiche une série de 10 entiers aléatoires.Each instance displays a series of 10 random integers.

``````using namespace System;

void main()
{
Console::WriteLine("Instantiating two random number generators...");
Random^ rnd1 = gcnew Random();
Random^ rnd2 = gcnew Random();

Console::WriteLine("\nThe first random number generator:");
for (int ctr = 1; ctr <= 10; ctr++)
Console::WriteLine("   {0}", rnd1->Next());

Console::WriteLine("\nThe second random number generator:");
for (int ctr = 1; ctr <= 10; ctr++)
Console::WriteLine("   {0}", rnd2->Next());
}
// The example displays output like the following:
//       Instantiating two random number generators...
//
//       The first random number generator:
//          643164361
//          1606571630
//          1725607587
//          2138048432
//          496874898
//          1969147632
//          2034533749
//          1840964542
//          412380298
//          47518930
//
//       The second random number generator:
//          1251659083
//          1514185439
//          1465798544
//          517841554
//          1821920222
//          195154223
//          1538948391
//          1548375095
//          546062716
//          897797880
``````
``````using System;

public class Example
{
public static void Main()
{
Console.WriteLine("Instantiating two random number generators...");
Random rnd1 = new Random();
Random rnd2 = new Random();

Console.WriteLine("\nThe first random number generator:");
for (int ctr = 1; ctr <= 10; ctr++)
Console.WriteLine("   {0}", rnd1.Next());

Console.WriteLine("\nThe second random number generator:");
for (int ctr = 1; ctr <= 10; ctr++)
Console.WriteLine("   {0}", rnd2.Next());
}
}
// The example displays output like the following:
//       Instantiating two random number generators...
//
//       The first random number generator:
//          643164361
//          1606571630
//          1725607587
//          2138048432
//          496874898
//          1969147632
//          2034533749
//          1840964542
//          412380298
//          47518930
//
//       The second random number generator:
//          1251659083
//          1514185439
//          1465798544
//          517841554
//          1821920222
//          195154223
//          1538948391
//          1548375095
//          546062716
//          897797880
``````
``````Imports System.Threading

Module Example
Public Sub Main()
Console.WriteLine("Instantiating two random number generators...")
Dim rnd1 As New Random()
Dim rnd2 As New Random()
Console.WriteLine()

Console.WriteLine("The first random number generator:")
For ctr As Integer = 1 To 10
Console.WriteLine("   {0}", rnd1.Next())
Next
Console.WriteLine()

Console.WriteLine("The second random number generator:")
For ctr As Integer = 1 To 10
Console.WriteLine("   {0}", rnd2.Next())
Next
End Sub
End Module
' The example displays output like the following:
'       Instantiating two random number generators...
'
'       The first random number generator:
'          643164361
'          1606571630
'          1725607587
'          2138048432
'          496874898
'          1969147632
'          2034533749
'          1840964542
'          412380298
'          47518930
'
'       The second random number generator:
'          1251659083
'          1514185439
'          1465798544
'          517841554
'          1821920222
'          195154223
'          1538948391
'          1548375095
'          546062716
'          897797880
``````

Toutefois, en raison de sa résolution finie, l’horloge système ne détecte pas les différences de temps qui sont inférieures à environ 15 millisecondes.However, because of its finite resolution, the system clock doesn't detect time differences that are less than approximately 15 milliseconds. Par conséquent, si votre code appelle la Random() surcharge sur la .NET Framework pour instancier deux Random objets successivement, vous pouvez fournir par inadvertance les objets avec des valeurs de départ identiques.Therefore, if your code calls the Random() overload on the .NET Framework to instantiate two Random objects in succession, you might inadvertently be providing the objects with identical seed values. (La Random classe dans .net Core n’a pas cette limitation.) Pour voir cela dans l’exemple précédent, commentez l' Thread.Sleep appel de méthode, puis compilez et exécutez à nouveau l’exemple.(The Random class in .NET Core does not have this limitation.) To see this in the previous example, comment out the Thread.Sleep method call, and compile and run the example again.

Pour éviter ce problème, nous vous recommandons d’instancier un Random objet unique plutôt que plusieurs.To prevent this from happening, we recommend that you instantiate a single Random object rather than multiple ones. Toutefois, étant donné que Random n’est pas thread-safe, vous devez utiliser un périphérique de synchronisation si vous accédez Random à une instance à partir de plusieurs threads. pour plus d’informations, consultez la classe Random et sécurité des threads plus haut dans cette rubrique.However, since Random isn't thread safe, you must use some synchronization device if you access a Random instance from multiple threads; for more information, see The Random class and thread safety earlier in this topic. Vous pouvez également utiliser un mécanisme de délai, tel que la Sleep méthode utilisée dans l’exemple précédent, pour vous assurer que les instanciations s’éloignent de plus de 15 millisecondes.Alternately, you can use a delay mechanism, such as the Sleep method used in the previous example, to ensure that the instantiations occur more than 15 millisecond apart.

#### Récupérer des entiers dans une plage spécifiéeRetrieve integers in a specified range

Vous pouvez récupérer des entiers dans une plage spécifiée en appelant la Next(Int32, Int32) méthode, qui vous permet de spécifier à la fois les limites inférieure et supérieure des nombres que le générateur de nombres aléatoires doit retourner.You can retrieve integers in a specified range by calling the Next(Int32, Int32) method, which lets you specify both the lower and the upper bound of the numbers you'd like the random number generator to return. La limite supérieure est une valeur exclusive, pas une valeur inclusive.The upper bound is an exclusive, not an inclusive, value. Autrement dit, il n’est pas inclus dans la plage de valeurs retournée par la méthode.That is, it isn't included in the range of values returned by the method. L’exemple suivant utilise cette méthode pour générer des entiers aléatoires compris entre-10 et 10.The following example uses this method to generate random integers between -10 and 10. Notez qu’il spécifie 11, qui est supérieur à la valeur souhaitée, comme valeur de l' `maxValue` argument dans l’appel de la méthode.Note that it specifies 11, which is one greater than the desired value, as the value of the `maxValue` argument in the method call.

``````using namespace System;

void main()
{
Random^ rnd = gcnew Random();
for (int ctr = 1; ctr <= 15; ctr++) {
Console::Write("{0,3}    ", rnd->Next(-10, 11));
if(ctr % 5 == 0) Console::WriteLine();
}
}
// The example displays output like the following:
//        -2     -5     -1     -2     10
//        -3      6     -4     -8      3
//        -7     10      5     -2      4
``````
``````Random rnd = new Random();
for (int ctr = 1; ctr <= 15; ctr++) {
Console.Write("{0,3}    ", rnd.Next(-10, 11));
if(ctr % 5 == 0) Console.WriteLine();
}

// The example displays output like the following:
//        -2     -5     -1     -2     10
//        -3      6     -4     -8      3
//        -7     10      5     -2      4
``````
``````Module Example
Public Sub Main()
Dim rnd As New Random()
For ctr As Integer = 1 To 15
Console.Write("{0,3}    ", rnd.Next(-10, 11))
If ctr Mod 5 = 0 Then Console.WriteLine()
Next
End Sub
End Module
' The example displays output like the following:
'        -2     -5     -1     -2     10
'        -3      6     -4     -8      3
'        -7     10      5     -2      4
``````

#### Récupérer des entiers avec un nombre spécifié de chiffresRetrieve integers with a specified number of digits

Vous pouvez appeler la Next(Int32, Int32) méthode pour récupérer des nombres avec un nombre spécifié de chiffres.You can call the Next(Int32, Int32) method to retrieve numbers with a specified number of digits. Par exemple, pour récupérer des nombres à quatre chiffres (autrement dit, des nombres compris entre 1000 et 9999), vous appelez la Next(Int32, Int32) méthode avec la `minValue` valeur 1000 et la `maxValue` valeur 10000, comme le montre l’exemple suivant.For example, to retrieve numbers with four digits (that is, numbers that range from 1000 to 9999), you call the Next(Int32, Int32) method with a `minValue` value of 1000 and a `maxValue` value of 10000, as the following example shows.

``````using namespace System;

void main()
{
Random^ rnd = gcnew Random();
for (int ctr = 1; ctr <= 50; ctr++) {
Console::Write("{0,3}   ", rnd->Next(1000, 10000));
if(ctr % 10 == 0) Console::WriteLine();
}
}
// The example displays output like the following:
//    9570    8979    5770    1606    3818    4735    8495    7196    7070    2313
//    5279    6577    5104    5734    4227    3373    7376    6007    8193    5540
//    7558    3934    3819    7392    1113    7191    6947    4963    9179    7907
//    3391    6667    7269    1838    7317    1981    5154    7377    3297    5320
//    9869    8694    2684    4949    2999    3019    2357    5211    9604    2593
``````
``````Random rnd = new Random();
for (int ctr = 1; ctr <= 50; ctr++) {
Console.Write("{0,3}    ", rnd.Next(1000, 10000));
if(ctr % 10 == 0) Console.WriteLine();
}

// The example displays output like the following:
//    9570    8979    5770    1606    3818    4735    8495    7196    7070    2313
//    5279    6577    5104    5734    4227    3373    7376    6007    8193    5540
//    7558    3934    3819    7392    1113    7191    6947    4963    9179    7907
//    3391    6667    7269    1838    7317    1981    5154    7377    3297    5320
//    9869    8694    2684    4949    2999    3019    2357    5211    9604    2593
``````
``````Module Example
Public Sub Main()
Dim rnd As New Random()
For ctr As Integer = 1 To 50
Console.Write("{0,3}    ", rnd.Next(1000, 10000))
If ctr Mod 10 = 0 Then Console.WriteLine()
Next
End Sub
End Module
' The example displays output like the following:
'    9570    8979    5770    1606    3818    4735    8495    7196    7070    2313
'    5279    6577    5104    5734    4227    3373    7376    6007    8193    5540
'    7558    3934    3819    7392    1113    7191    6947    4963    9179    7907
'    3391    6667    7269    1838    7317    1981    5154    7377    3297    5320
'    9869    8694    2684    4949    2999    3019    2357    5211    9604    2593
``````

#### Récupérer des valeurs à virgule flottante dans une plage spécifiéeRetrieve floating-point values in a specified range

La NextDouble méthode retourne des valeurs à virgule flottante aléatoires comprises entre 0 et moins de 1.The NextDouble method returns random floating-point values that range from 0 to less than 1. Toutefois, vous souhaiterez souvent générer des valeurs aléatoires dans une autre plage.However, you'll often want to generate random values in some other range.

Si l’intervalle entre les valeurs minimale et maximale souhaitée est 1, vous pouvez ajouter la différence entre l’intervalle de départ souhaité et 0 au nombre retourné par la NextDouble méthode.If the interval between the minimum and maximum desired values is 1, you can add the difference between the desired starting interval and 0 to the number returned by the NextDouble method. L’exemple suivant effectue cette commande pour générer 10 nombres aléatoires compris entre-1 et 0.The following example does this to generate 10 random numbers between -1 and 0.

``````using namespace System;

void main()
{
Random^ rnd = gcnew Random();
for (int ctr = 1; ctr <= 10; ctr++)
Console::WriteLine(rnd->NextDouble() - 1);
}
// The example displays output like the following:
//       -0.930412760437658
//       -0.164699016215605
//       -0.9851692803135
//       -0.43468508843085
//       -0.177202483255976
//       -0.776813320245972
//       -0.0713201854710096
//       -0.0912875561468711
//       -0.540621722368813
//       -0.232211863730201
``````
``````Random rnd = new Random();
for (int ctr = 1; ctr <= 10; ctr++)
Console.WriteLine(rnd.NextDouble() - 1);

// The example displays output like the following:
//       -0.930412760437658
//       -0.164699016215605
//       -0.9851692803135
//       -0.43468508843085
//       -0.177202483255976
//       -0.776813320245972
//       -0.0713201854710096
//       -0.0912875561468711
//       -0.540621722368813
//       -0.232211863730201
``````
``````Module Example
Public Sub Main()
Dim rnd As New Random()
For ctr As Integer = 1 To 10
Console.WriteLine(rnd.NextDouble() - 1)
Next
End Sub
End Module
' The example displays output like the following:
'       -0.930412760437658
'       -0.164699016215605
'       -0.9851692803135
'       -0.43468508843085
'       -0.177202483255976
'       -0.776813320245972
'       -0.0713201854710096
'       -0.0912875561468711
'       -0.540621722368813
'       -0.232211863730201
``````

Pour générer des nombres à virgule flottante aléatoires dont la limite inférieure est 0 alors que la limite supérieure est supérieure à 1 (ou, dans le cas de nombres négatifs, dont la limite inférieure est inférieure à-1 et la limite supérieure est 0), multipliez le nombre aléatoire par la limite non nulle.To generate random floating-point numbers whose lower bound is 0 but upper bound is greater than 1 (or, in the case of negative numbers, whose lower bound is less than -1 and upper bound is 0), multiply the random number by the non-zero bound. L’exemple suivant effectue cette opération pour générer des nombres à virgule flottante 20 millions aléatoires compris entre 0 et Int64.MaxValue .The following example does this to generate 20 million random floating-point numbers that range from 0 to Int64.MaxValue. Dans affiche également la distribution des valeurs aléatoires générées par la méthode.In also displays the distribution of the random values generated by the method.

``````using namespace System;

void main()
{
const Int64 ONE_TENTH = 922337203685477581;
Random^ rnd = gcnew Random();
double number;
array<int>^ count = gcnew array<int>(10);

// Generate 20 million integer values between.
for (int ctr = 1; ctr <= 20000000; ctr++) {
number = rnd->NextDouble() * Int64::MaxValue;
// Categorize random numbers into 10 groups.
int value = (int) (number / ONE_TENTH);
count[value]++;
}

// Display breakdown by range.
Console::WriteLine("{0,28} {1,32}   {2,7}\n", "Range", "Count", "Pct.");
for (int ctr = 0; ctr <= 9; ctr++)
Console::WriteLine("{0,25:N0}-{1,25:N0}  {2,8:N0}   {3,7:P2}", ctr * ONE_TENTH,
ctr < 9 ? ctr * ONE_TENTH + ONE_TENTH - 1 : Int64::MaxValue,
count[ctr], count[ctr]/20000000.0);
}
// The example displays output like the following:
//                           Range                            Count      Pct.
//
//                            0-  922,337,203,685,477,580  1,996,148    9.98 %
//      922,337,203,685,477,581-1,844,674,407,370,955,161  2,000,293   10.00 %
//    1,844,674,407,370,955,162-2,767,011,611,056,432,742  2,000,094   10.00 %
//    2,767,011,611,056,432,743-3,689,348,814,741,910,323  2,000,159   10.00 %
//    3,689,348,814,741,910,324-4,611,686,018,427,387,904  1,999,552   10.00 %
//    4,611,686,018,427,387,905-5,534,023,222,112,865,485  1,998,248    9.99 %
//    5,534,023,222,112,865,486-6,456,360,425,798,343,066  2,000,696   10.00 %
//    6,456,360,425,798,343,067-7,378,697,629,483,820,647  2,001,637   10.01 %
//    7,378,697,629,483,820,648-8,301,034,833,169,298,228  2,002,870   10.01 %
//    8,301,034,833,169,298,229-9,223,372,036,854,775,807  2,000,303   10.00 %
``````
``````const long ONE_TENTH = 922337203685477581;

Random rnd = new Random();
double number;
int[] count = new int[10];

// Generate 20 million integer values between.
for (int ctr = 1; ctr <= 20000000; ctr++) {
number = rnd.NextDouble() * Int64.MaxValue;
// Categorize random numbers into 10 groups.
count[(int) (number / ONE_TENTH)]++;
}
// Display breakdown by range.
Console.WriteLine("{0,28} {1,32}   {2,7}\n", "Range", "Count", "Pct.");
for (int ctr = 0; ctr <= 9; ctr++)
Console.WriteLine("{0,25:N0}-{1,25:N0}  {2,8:N0}   {3,7:P2}", ctr * ONE_TENTH,
ctr < 9 ? ctr * ONE_TENTH + ONE_TENTH - 1 : Int64.MaxValue,
count[ctr], count[ctr]/20000000.0);

// The example displays output like the following:
//                           Range                            Count      Pct.
//
//                            0-  922,337,203,685,477,580  1,996,148    9.98 %
//      922,337,203,685,477,581-1,844,674,407,370,955,161  2,000,293   10.00 %
//    1,844,674,407,370,955,162-2,767,011,611,056,432,742  2,000,094   10.00 %
//    2,767,011,611,056,432,743-3,689,348,814,741,910,323  2,000,159   10.00 %
//    3,689,348,814,741,910,324-4,611,686,018,427,387,904  1,999,552   10.00 %
//    4,611,686,018,427,387,905-5,534,023,222,112,865,485  1,998,248    9.99 %
//    5,534,023,222,112,865,486-6,456,360,425,798,343,066  2,000,696   10.00 %
//    6,456,360,425,798,343,067-7,378,697,629,483,820,647  2,001,637   10.01 %
//    7,378,697,629,483,820,648-8,301,034,833,169,298,228  2,002,870   10.01 %
//    8,301,034,833,169,298,229-9,223,372,036,854,775,807  2,000,303   10.00 %
``````
``````Module Example
Public Sub Main()
Const ONE_TENTH As Long = 922337203685477581

Dim rnd As New Random()
Dim number As Long
Dim count(9) As Integer

' Generate 20 million integer values.
For ctr As Integer = 1 To 20000000
number = CLng(rnd.NextDouble() * Int64.MaxValue)
' Categorize random numbers.
count(CInt(number \ ONE_TENTH)) += 1
Next
' Display breakdown by range.
Console.WriteLine("{0,28} {1,32}   {2,7}", "Range", "Count", "Pct.")
Console.WriteLine()
For ctr As Integer = 0 To 9
Console.WriteLine("{0,25:N0}-{1,25:N0}  {2,8:N0}   {3,7:P2}", ctr * ONE_TENTH,
If(ctr < 9, ctr * ONE_TENTH + ONE_TENTH - 1, Int64.MaxValue),
count(ctr), count(ctr)/20000000)
Next
End Sub
End Module
' The example displays output like the following:
'                           Range                            Count      Pct.
'
'                            0-  922,337,203,685,477,580  1,996,148    9.98 %
'      922,337,203,685,477,581-1,844,674,407,370,955,161  2,000,293   10.00 %
'    1,844,674,407,370,955,162-2,767,011,611,056,432,742  2,000,094   10.00 %
'    2,767,011,611,056,432,743-3,689,348,814,741,910,323  2,000,159   10.00 %
'    3,689,348,814,741,910,324-4,611,686,018,427,387,904  1,999,552   10.00 %
'    4,611,686,018,427,387,905-5,534,023,222,112,865,485  1,998,248    9.99 %
'    5,534,023,222,112,865,486-6,456,360,425,798,343,066  2,000,696   10.00 %
'    6,456,360,425,798,343,067-7,378,697,629,483,820,647  2,001,637   10.01 %
'    7,378,697,629,483,820,648-8,301,034,833,169,298,228  2,002,870   10.01 %
'    8,301,034,833,169,298,229-9,223,372,036,854,775,807  2,000,303   10.00 %
``````

Pour générer des nombres à virgule flottante aléatoires entre deux valeurs arbitraires, comme la Next(Int32, Int32) méthode pour les entiers, utilisez la formule suivante :To generate random floating-point numbers between two arbitrary values, like the Next(Int32, Int32) method does for integers, use the following formula:

``````Random.NextDouble() * (maxValue - minValue) + minValue
``````

L’exemple suivant génère des nombres aléatoires de 1 million qui vont de 10,0 à 11,0 et affiche leur distribution.The following example generates 1 million random numbers that range from 10.0 to 11.0, and displays their distribution.

``````using namespace System;

void main()
{
Random^ rnd = gcnew Random();
int lowerBound = 10;
int upperBound = 11;
array<int>^ range = gcnew array<int>(10);
for (int ctr = 1; ctr <= 1000000; ctr++) {
Double value = rnd->NextDouble() * (upperBound - lowerBound) + lowerBound;
range[(int) Math::Truncate((value - lowerBound) * 10)]++;
}

for (int ctr = 0; ctr <= 9; ctr++) {
Double lowerRange = 10 + ctr * .1;
Console::WriteLine("{0:N1} to {1:N1}: {2,8:N0}  ({3,7:P2})",
lowerRange, lowerRange + .1, range[ctr],
range[ctr] / 1000000.0);
}
}
// The example displays output like the following:
//       10.0 to 10.1:   99,929  ( 9.99 %)
//       10.1 to 10.2:  100,189  (10.02 %)
//       10.2 to 10.3:   99,384  ( 9.94 %)
//       10.3 to 10.4:  100,240  (10.02 %)
//       10.4 to 10.5:   99,397  ( 9.94 %)
//       10.5 to 10.6:  100,580  (10.06 %)
//       10.6 to 10.7:  100,293  (10.03 %)
//       10.7 to 10.8:  100,135  (10.01 %)
//       10.8 to 10.9:   99,905  ( 9.99 %)
//       10.9 to 11.0:   99,948  ( 9.99 %)
``````
``````Random rnd = new Random();
int lowerBound = 10;
int upperBound = 11;
int[] range = new int[10];
for (int ctr = 1; ctr <= 1000000; ctr++) {
Double value = rnd.NextDouble() * (upperBound - lowerBound) + lowerBound;
range[(int) Math.Truncate((value - lowerBound) * 10)]++;
}

for (int ctr = 0; ctr <= 9; ctr++) {
Double lowerRange = 10 + ctr * .1;
Console.WriteLine("{0:N1} to {1:N1}: {2,8:N0}  ({3,7:P2})",
lowerRange, lowerRange + .1, range[ctr],
range[ctr] / 1000000.0);
}

// The example displays output like the following:
//       10.0 to 10.1:   99,929  ( 9.99 %)
//       10.1 to 10.2:  100,189  (10.02 %)
//       10.2 to 10.3:   99,384  ( 9.94 %)
//       10.3 to 10.4:  100,240  (10.02 %)
//       10.4 to 10.5:   99,397  ( 9.94 %)
//       10.5 to 10.6:  100,580  (10.06 %)
//       10.6 to 10.7:  100,293  (10.03 %)
//       10.7 to 10.8:  100,135  (10.01 %)
//       10.8 to 10.9:   99,905  ( 9.99 %)
//       10.9 to 11.0:   99,948  ( 9.99 %)
``````
``````Module Example
Public Sub Main()
Dim rnd As New Random()
Dim lowerBound As Integer = 10
Dim upperBound As Integer = 11
Dim range(9) As Integer
For ctr As Integer = 1 To 1000000
Dim value As Double = rnd.NextDouble() * (upperBound - lowerBound) + lowerBound
range(CInt(Math.Truncate((value - lowerBound) * 10))) += 1
Next

For ctr As Integer = 0 To 9
Dim lowerRange As Double = 10 + ctr * .1
Console.WriteLine("{0:N1} to {1:N1}: {2,8:N0}  ({3,7:P2})",
lowerRange, lowerRange + .1, range(ctr),
range(ctr) / 1000000.0)
Next
End Sub
End Module
' The example displays output like the following:
'       10.0 to 10.1:   99,929  ( 9.99 %)
'       10.1 to 10.2:  100,189  (10.02 %)
'       10.2 to 10.3:   99,384  ( 9.94 %)
'       10.3 to 10.4:  100,240  (10.02 %)
'       10.4 to 10.5:   99,397  ( 9.94 %)
'       10.5 to 10.6:  100,580  (10.06 %)
'       10.6 to 10.7:  100,293  (10.03 %)
'       10.7 to 10.8:  100,135  (10.01 %)
'       10.8 to 10.9:   99,905  ( 9.99 %)
'       10.9 to 11.0:   99,948  ( 9.99 %)
``````

#### Générer des valeurs booléennes aléatoiresGenerate random Boolean values

La Random classe ne fournit pas de méthodes qui génèrent des Boolean valeurs.The Random class doesn't provide methods that generate Boolean values. Toutefois, vous pouvez définir votre propre classe ou méthode pour effectuer cette opération.However, you can define your own class or method to do that. L’exemple suivant définit une classe, `BooleanGenerator` , avec une méthode unique, `NextBoolean` .The following example defines a class, `BooleanGenerator`, with a single method, `NextBoolean`. La `BooleanGenerator` classe stocke un Random objet en tant que variable privée.The `BooleanGenerator` class stores a Random object as a private variable. La `NextBoolean` méthode appelle la Random.Next(Int32, Int32) méthode et passe le résultat à la Convert.ToBoolean(Int32) méthode.The `NextBoolean` method calls the Random.Next(Int32, Int32) method and passes the result to the Convert.ToBoolean(Int32) method. Notez que 2 est utilisé comme argument pour spécifier la limite supérieure du nombre aléatoire.Note that 2 is used as the argument to specify the upper bound of the random number. Étant donné qu’il s’agit d’une valeur exclusive, l’appel de méthode retourne 0 ou 1.Since this is an exclusive value, the method call returns either 0 or 1.

``````using namespace System;

public ref class BooleanGenerator
{
private:
Random^ rnd;

public:
BooleanGenerator()
{
rnd = gcnew Random();
}

bool NextBoolean()
{
return Convert::ToBoolean(rnd->Next(0, 2));
}
};

void main()
{
// Instantiate the Boolean generator.
BooleanGenerator^ boolGen = gcnew BooleanGenerator();
int totalTrue = 0, totalFalse = 0;

// Generate 1,0000 random Booleans, and keep a running total.
for (int ctr = 0; ctr < 1000000; ctr++) {
bool value = boolGen->NextBoolean();
if (value)
totalTrue++;
else
totalFalse++;
}
Console::WriteLine("Number of true values:  {0,7:N0} ({1:P3})",
totalTrue,
((double) totalTrue)/(totalTrue + totalFalse));
Console::WriteLine("Number of false values: {0,7:N0} ({1:P3})",
totalFalse,
((double) totalFalse)/(totalTrue + totalFalse));
}

// The example displays output like the following:
//       Number of true values:  500,004 (50.000 %)
//       Number of false values: 499,996 (50.000 %)
``````
``````using System;

public class Example
{
public static void Main()
{
// Instantiate the Boolean generator.
BooleanGenerator boolGen = new BooleanGenerator();
int totalTrue = 0, totalFalse = 0;

// Generate 1,0000 random Booleans, and keep a running total.
for (int ctr = 0; ctr < 1000000; ctr++) {
bool value = boolGen.NextBoolean();
if (value)
totalTrue++;
else
totalFalse++;
}
Console.WriteLine("Number of true values:  {0,7:N0} ({1:P3})",
totalTrue,
((double) totalTrue)/(totalTrue + totalFalse));
Console.WriteLine("Number of false values: {0,7:N0} ({1:P3})",
totalFalse,
((double) totalFalse)/(totalTrue + totalFalse));
}
}

public class BooleanGenerator
{
Random rnd;

public BooleanGenerator()
{
rnd = new Random();
}

public bool NextBoolean()
{
return Convert.ToBoolean(rnd.Next(0, 2));
}
}
// The example displays output like the following:
//       Number of true values:  500,004 (50.000 %)
//       Number of false values: 499,996 (50.000 %)
``````
``````Module Example
Public Sub Main()
' Instantiate the Boolean generator.
Dim boolGen As New BooleanGenerator()
Dim totalTrue, totalFalse As Integer

' Generate 1,0000 random Booleans, and keep a running total.
For ctr As Integer = 0 To 9999999
Dim value As Boolean = boolGen.NextBoolean()
If value Then
totalTrue += 1
Else
totalFalse += 1
End If
Next
Console.WriteLine("Number of true values:  {0,7:N0} ({1:P3})",
totalTrue,
totalTrue/(totalTrue + totalFalse))
Console.WriteLine("Number of false values: {0,7:N0} ({1:P3})",
totalFalse,
totalFalse/(totalTrue + totalFalse))
End Sub
End Module

Public Class BooleanGenerator
Dim rnd As Random

Public Sub New()
rnd = New Random()
End Sub

Public Function NextBoolean() As Boolean
Return Convert.ToBoolean(rnd.Next(0, 2))
End Function
End Class
' The example displays the following output:
'       Number of true values:  500,004 (50.000 %)
'       Number of false values: 499,996 (50.000 %)
``````

Au lieu de créer une classe distincte pour générer Boolean des valeurs aléatoires, l’exemple peut simplement avoir défini une méthode unique.Instead of creating a separate class to generate random Boolean values, the example could simply have defined a single method. Dans ce cas, toutefois, l' Random objet doit avoir été défini en tant que variable au niveau de la classe pour éviter d’instancier une nouvelle Random instance dans chaque appel de méthode.In that case, however, the Random object should have been defined as a class-level variable to avoid instantiating a new Random instance in each method call. Dans Visual Basic, l’instance aléatoire peut être définie en tant que variable statique dans la `NextBoolean` méthode.In Visual Basic, the Random instance can be defined as a Static variable in the `NextBoolean` method. L’exemple suivant fournit une implémentation.The following example provides an implementation.

``````using namespace System;

ref class Example
{
private:
static Random^ rnd = gcnew Random();

public:
static void Execute()
{
int totalTrue = 0, totalFalse = 0;

// Generate 1,0000 random Booleans, and keep a running total.
for (int ctr = 0; ctr < 1000000; ctr++) {
bool value = NextBoolean();
if (value)
totalTrue++;
else
totalFalse++;
}
Console::WriteLine("Number of true values:  {0,7:N0} ({1:P3})",
totalTrue,
((double) totalTrue)/(totalTrue + totalFalse));
Console::WriteLine("Number of false values: {0,7:N0} ({1:P3})",
totalFalse,
((double) totalFalse)/(totalTrue + totalFalse));
}

static bool NextBoolean()
{
return Convert::ToBoolean(rnd->Next(0, 2));
}
};

void main()
{
Example::Execute();
}
// The example displays output like the following:
//       Number of true values:  499,777 (49.978 %)
//       Number of false values: 500,223 (50.022 %)
``````
``````Random rnd = new Random();

int totalTrue = 0, totalFalse = 0;

// Generate 1,000,000 random Booleans, and keep a running total.
for (int ctr = 0; ctr < 1000000; ctr++) {
bool value = NextBoolean();
if (value)
totalTrue++;
else
totalFalse++;
}
Console.WriteLine("Number of true values:  {0,7:N0} ({1:P3})",
totalTrue,
((double) totalTrue)/(totalTrue + totalFalse));
Console.WriteLine("Number of false values: {0,7:N0} ({1:P3})",
totalFalse,
((double) totalFalse)/(totalTrue + totalFalse));

bool NextBoolean()
{
return Convert.ToBoolean(rnd.Next(0, 2));
}

// The example displays output like the following:
//       Number of true values:  499,777 (49.978 %)
//       Number of false values: 500,223 (50.022 %)
``````
``````Module Example
Public Sub Main()
Dim totalTrue, totalFalse As Integer

' Generate 1,0000 random Booleans, and keep a running total.
For ctr As Integer = 0 To 9999999
Dim value As Boolean = NextBoolean()
If value Then
totalTrue += 1
Else
totalFalse += 1
End If
Next
Console.WriteLine("Number of true values:  {0,7:N0} ({1:P3})",
totalTrue,
totalTrue/(totalTrue + totalFalse))
Console.WriteLine("Number of false values: {0,7:N0} ({1:P3})",
totalFalse,
totalFalse/(totalTrue + totalFalse))
End Sub

Public Function NextBoolean() As Boolean
Static rnd As New Random()
Return Convert.ToBoolean(rnd.Next(0, 2))
End Function
End Module
' The example displays the following output:
'       Number of true values:  499,777 (49.978 %)
'       Number of false values: 500,223 (50.022 %)
``````

#### Générer des entiers aléatoires 64 bitsGenerate random 64-bit integers

Les surcharges de la Next méthode retournent des entiers 32 bits.The overloads of the Next method return 32-bit integers. Toutefois, dans certains cas, vous souhaiterez peut-être utiliser des entiers 64 bits.However, in some cases, you might want to work with 64-bit integers. Vous pouvez procéder comme suit :You can do this as follows:

1. Appelez la NextDouble méthode pour récupérer une valeur à virgule flottante double précision.Call the NextDouble method to retrieve a double-precision floating point value.

2. Multipliez cette valeur par Int64.MaxValue .Multiply that value by Int64.MaxValue.

L’exemple suivant utilise cette technique pour générer des entiers longs aléatoires 20 millions et les classer dans 10 groupes identiques.The following example uses this technique to generate 20 million random long integers and categorizes them in 10 equal groups. Il évalue ensuite la distribution des nombres aléatoires en comptant le nombre de chaque groupe de 0 à Int64.MaxValue .It then evaluates the distribution of the random numbers by counting the number in each group from 0 to Int64.MaxValue. Comme le montre la sortie de l’exemple, les nombres sont distribués plus ou moins équitablement par le biais de la plage d’un entier long.As the output from the example shows, the numbers are distributed more or less equally through the range of a long integer.

``````using namespace System;

void main()
{
const Int64 ONE_TENTH = 922337203685477581;

Random^ rnd = gcnew Random();
Int64 number;
array<int>^ count = gcnew array<int>(10);

// Generate 20 million long integers.
for (int ctr = 1; ctr <= 20000000; ctr++) {
number = (Int64) (rnd->NextDouble() * Int64::MaxValue);
// Categorize random numbers.
count[(int) (number / ONE_TENTH)]++;
}
// Display breakdown by range.
Console::WriteLine("{0,28} {1,32}   {2,7}\n", "Range", "Count", "Pct.");
for (int ctr = 0; ctr <= 9; ctr++)
Console::WriteLine("{0,25:N0}-{1,25:N0}  {2,8:N0}   {3,7:P2}", ctr * ONE_TENTH,
ctr < 9 ? ctr * ONE_TENTH + ONE_TENTH - 1 : Int64::MaxValue,
count[ctr], count[ctr]/20000000.0);
}
// The example displays output like the following:
//                           Range                            Count      Pct.
//
//                            0-  922,337,203,685,477,580  1,996,148    9.98 %
//      922,337,203,685,477,581-1,844,674,407,370,955,161  2,000,293   10.00 %
//    1,844,674,407,370,955,162-2,767,011,611,056,432,742  2,000,094   10.00 %
//    2,767,011,611,056,432,743-3,689,348,814,741,910,323  2,000,159   10.00 %
//    3,689,348,814,741,910,324-4,611,686,018,427,387,904  1,999,552   10.00 %
//    4,611,686,018,427,387,905-5,534,023,222,112,865,485  1,998,248    9.99 %
//    5,534,023,222,112,865,486-6,456,360,425,798,343,066  2,000,696   10.00 %
//    6,456,360,425,798,343,067-7,378,697,629,483,820,647  2,001,637   10.01 %
//    7,378,697,629,483,820,648-8,301,034,833,169,298,228  2,002,870   10.01 %
//    8,301,034,833,169,298,229-9,223,372,036,854,775,807  2,000,303   10.00 %
``````
``````const long ONE_TENTH = 922337203685477581;

Random rnd = new Random();
long number;
int[] count = new int[10];

// Generate 20 million long integers.
for (int ctr = 1; ctr <= 20000000; ctr++) {
number = (long) (rnd.NextDouble() * Int64.MaxValue);
// Categorize random numbers.
count[(int) (number / ONE_TENTH)]++;
}
// Display breakdown by range.
Console.WriteLine("{0,28} {1,32}   {2,7}\n", "Range", "Count", "Pct.");
for (int ctr = 0; ctr <= 9; ctr++)
Console.WriteLine("{0,25:N0}-{1,25:N0}  {2,8:N0}   {3,7:P2}", ctr * ONE_TENTH,
ctr < 9 ? ctr * ONE_TENTH + ONE_TENTH - 1 : Int64.MaxValue,
count[ctr], count[ctr]/20000000.0);

// The example displays output like the following:
//                           Range                            Count      Pct.
//
//                            0-  922,337,203,685,477,580  1,996,148    9.98 %
//      922,337,203,685,477,581-1,844,674,407,370,955,161  2,000,293   10.00 %
//    1,844,674,407,370,955,162-2,767,011,611,056,432,742  2,000,094   10.00 %
//    2,767,011,611,056,432,743-3,689,348,814,741,910,323  2,000,159   10.00 %
//    3,689,348,814,741,910,324-4,611,686,018,427,387,904  1,999,552   10.00 %
//    4,611,686,018,427,387,905-5,534,023,222,112,865,485  1,998,248    9.99 %
//    5,534,023,222,112,865,486-6,456,360,425,798,343,066  2,000,696   10.00 %
//    6,456,360,425,798,343,067-7,378,697,629,483,820,647  2,001,637   10.01 %
//    7,378,697,629,483,820,648-8,301,034,833,169,298,228  2,002,870   10.01 %
//    8,301,034,833,169,298,229-9,223,372,036,854,775,807  2,000,303   10.00 %
``````
``````Module Example
Public Sub Main()
Const ONE_TENTH As Long = 922337203685477581

Dim rnd As New Random()
Dim number As Long
Dim count(9) As Integer

' Generate 20 million long integers.
For ctr As Integer = 1 To 20000000
number = CLng(rnd.NextDouble() * Int64.MaxValue)
' Categorize random numbers.
count(CInt(number \ ONE_TENTH)) += 1
Next
' Display breakdown by range.
Console.WriteLine("{0,28} {1,32}   {2,7}", "Range", "Count", "Pct.")
Console.WriteLine()
For ctr As Integer = 0 To 9
Console.WriteLine("{0,25:N0}-{1,25:N0}  {2,8:N0}   {3,7:P2}", ctr * ONE_TENTH,
If(ctr < 9, ctr * ONE_TENTH + ONE_TENTH - 1, Int64.MaxValue),
count(ctr), count(ctr)/20000000)
Next
End Sub
End Module
' The example displays output like the following:
'                           Range                            Count      Pct.
'
'                            0-  922,337,203,685,477,580  1,996,148    9.98 %
'      922,337,203,685,477,581-1,844,674,407,370,955,161  2,000,293   10.00 %
'    1,844,674,407,370,955,162-2,767,011,611,056,432,742  2,000,094   10.00 %
'    2,767,011,611,056,432,743-3,689,348,814,741,910,323  2,000,159   10.00 %
'    3,689,348,814,741,910,324-4,611,686,018,427,387,904  1,999,552   10.00 %
'    4,611,686,018,427,387,905-5,534,023,222,112,865,485  1,998,248    9.99 %
'    5,534,023,222,112,865,486-6,456,360,425,798,343,066  2,000,696   10.00 %
'    6,456,360,425,798,343,067-7,378,697,629,483,820,647  2,001,637   10.01 %
'    7,378,697,629,483,820,648-8,301,034,833,169,298,228  2,002,870   10.01 %
'    8,301,034,833,169,298,229-9,223,372,036,854,775,807  2,000,303   10.00 %
``````

Une autre technique qui utilise la manipulation de bits ne génère pas de nombres véritablement aléatoires.An alternative technique that uses bit manipulation does not generate truly random numbers. Cette technique appelle Next() pour générer deux entiers, les décale vers la gauche de 1 à 32 bits et les ORS ensemble.This technique calls Next() to generate two integers, left-shifts one by 32 bits, and ORs them together. Cette technique présente deux limitations :This technique has two limitations:

1. Étant donné que le bit 31 est le bit de signe, la valeur du bit 31 de l’entier long résultant est toujours 0.Because bit 31 is the sign bit, the value in bit 31 of the resulting long integer is always 0. Cela peut être résolu en générant un 0 ou 1 aléatoire, en le décalant à gauche de 31 bits, et en le ORing avec l’entier long aléatoire d’origine.This can be addressed by generating a random 0 or 1, left-shifting it 31 bits, and ORing it with the original random long integer.

2. Plus sérieusement, étant donné que la probabilité que la valeur retournée par Next() soit égale à 0, il n’y aura que peu de nombres aléatoires dans la plage 0x0-0x00000000FFFFFFFF.More seriously, because the probability that the value returned by Next() will be 0, there will be few if any random numbers in the range 0x0-0x00000000FFFFFFFF.

#### Récupérer des octets dans une plage spécifiéeRetrieve bytes in a specified range

Les surcharges de la Next méthode vous permettent de spécifier la plage de nombres aléatoires, mais ce NextBytes n’est pas le cas de la méthode.The overloads of the Next method allow you to specify the range of random numbers, but the NextBytes method does not. L’exemple suivant implémente une `NextBytes` méthode qui vous permet de spécifier la plage des octets retournés.The following example implements a `NextBytes` method that lets you specify the range of the returned bytes. Il définit une `Random2` classe qui dérive de Random et surcharge sa `NextBytes` méthode.It defines a `Random2` class that derives from Random and overloads its `NextBytes` method.

``````using namespace System;

ref class Random2 : Random
{
public:
Random2()
{}

Random2(int seed) : Random(seed)
{}

void NextBytes(array<Byte>^ bytes, Byte minValue, Byte maxValue)
{
for (int ctr = bytes->GetLowerBound(0); ctr <= bytes->GetUpperBound(0); ctr++)
bytes[ctr] = (Byte) Next(minValue, maxValue);
}
};

void main()
{
Random2^ rnd = gcnew Random2();
array<Byte>^ bytes = gcnew array<Byte>(10000);
array<int>^ total = gcnew array<int>(101);
rnd->NextBytes(bytes, 0, 101);

// Calculate how many of each value we have.
for each (Byte value in bytes)
total[value]++;

// Display the results.
for (int ctr = 0; ctr < total->Length; ctr++) {
Console::Write("{0,3}: {1,-3}   ", ctr, total[ctr]);
if ((ctr + 1) % 5 == 0) Console::WriteLine();
}
}
// The example displays output like the following:
//         0: 115     1: 119     2: 92      3: 98      4: 92
//         5: 102     6: 103     7: 84      8: 93      9: 116
//        10: 91     11: 98     12: 106    13: 91     14: 92
//        15: 101    16: 100    17: 96     18: 97     19: 100
//        20: 101    21: 106    22: 112    23: 82     24: 85
//        25: 102    26: 107    27: 98     28: 106    29: 102
//        30: 109    31: 108    32: 94     33: 101    34: 107
//        35: 101    36: 86     37: 100    38: 101    39: 102
//        40: 113    41: 95     42: 96     43: 89     44: 99
//        45: 81     46: 89     47: 105    48: 100    49: 85
//        50: 103    51: 103    52: 93     53: 89     54: 91
//        55: 97     56: 105    57: 97     58: 110    59: 86
//        60: 116    61: 94     62: 117    63: 98     64: 110
//        65: 93     66: 102    67: 100    68: 105    69: 83
//        70: 81     71: 97     72: 85     73: 70     74: 98
//        75: 100    76: 110    77: 114    78: 83     79: 90
//        80: 96     81: 112    82: 102    83: 102    84: 99
//        85: 81     86: 100    87: 93     88: 99     89: 118
//        90: 95     91: 124    92: 108    93: 96     94: 104
//        95: 106    96: 99     97: 99     98: 92     99: 99
//       100: 108
``````
``````using System;

public class Example
{
public static void Main()
{
Random2 rnd = new Random2();
Byte[] bytes = new Byte[10000];
int[] total = new int[101];
rnd.NextBytes(bytes, 0, 101);

// Calculate how many of each value we have.
foreach (var value in bytes)
total[value]++;

// Display the results.
for (int ctr = 0; ctr < total.Length; ctr++) {
Console.Write("{0,3}: {1,-3}   ", ctr, total[ctr]);
if ((ctr + 1) % 5 == 0) Console.WriteLine();
}
}
}

public class Random2 : Random
{
public Random2() : base()
{}

public Random2(int seed) : base(seed)
{}

public void NextBytes(byte[] bytes, byte minValue, byte maxValue)
{
for (int ctr = bytes.GetLowerBound(0); ctr <= bytes.GetUpperBound(0); ctr++)
bytes[ctr] = (byte) Next(minValue, maxValue);
}
}
// The example displays output like the following:
//         0: 115     1: 119     2: 92      3: 98      4: 92
//         5: 102     6: 103     7: 84      8: 93      9: 116
//        10: 91     11: 98     12: 106    13: 91     14: 92
//        15: 101    16: 100    17: 96     18: 97     19: 100
//        20: 101    21: 106    22: 112    23: 82     24: 85
//        25: 102    26: 107    27: 98     28: 106    29: 102
//        30: 109    31: 108    32: 94     33: 101    34: 107
//        35: 101    36: 86     37: 100    38: 101    39: 102
//        40: 113    41: 95     42: 96     43: 89     44: 99
//        45: 81     46: 89     47: 105    48: 100    49: 85
//        50: 103    51: 103    52: 93     53: 89     54: 91
//        55: 97     56: 105    57: 97     58: 110    59: 86
//        60: 116    61: 94     62: 117    63: 98     64: 110
//        65: 93     66: 102    67: 100    68: 105    69: 83
//        70: 81     71: 97     72: 85     73: 70     74: 98
//        75: 100    76: 110    77: 114    78: 83     79: 90
//        80: 96     81: 112    82: 102    83: 102    84: 99
//        85: 81     86: 100    87: 93     88: 99     89: 118
//        90: 95     91: 124    92: 108    93: 96     94: 104
//        95: 106    96: 99     97: 99     98: 92     99: 99
//       100: 108
``````
``````Module Example
Public Sub Main()
Dim rnd As New Random2()
Dim bytes(9999) As Byte
Dim total(100) As Integer
rnd.NextBytes(bytes, 0, 101)

' Calculate how many of each value we have.
For Each value In bytes
total(value) += 1
Next

' Display the results.
For ctr As Integer = 0 To total.Length - 1
Console.Write("{0,3}: {1,-3}   ", ctr, total(ctr))
If (ctr + 1) Mod 5 = 0 Then Console.WriteLine()
Next
End Sub
End Module

Public Class Random2 : Inherits Random
Public Sub New()
MyBase.New()
End Sub

Public Sub New(seed As Integer)
MyBase.New(seed)
End Sub

Public Overloads Sub NextBytes(bytes() As Byte,
minValue As Byte, maxValue As Byte)
For ctr As Integer = bytes.GetLowerbound(0) To bytes.GetUpperBound(0)
bytes(ctr) = CByte(MyBase.Next(minValue, maxValue))
Next
End Sub
End Class
' The example displays output like the following:
'         0: 115     1: 119     2: 92      3: 98      4: 92
'         5: 102     6: 103     7: 84      8: 93      9: 116
'        10: 91     11: 98     12: 106    13: 91     14: 92
'        15: 101    16: 100    17: 96     18: 97     19: 100
'        20: 101    21: 106    22: 112    23: 82     24: 85
'        25: 102    26: 107    27: 98     28: 106    29: 102
'        30: 109    31: 108    32: 94     33: 101    34: 107
'        35: 101    36: 86     37: 100    38: 101    39: 102
'        40: 113    41: 95     42: 96     43: 89     44: 99
'        45: 81     46: 89     47: 105    48: 100    49: 85
'        50: 103    51: 103    52: 93     53: 89     54: 91
'        55: 97     56: 105    57: 97     58: 110    59: 86
'        60: 116    61: 94     62: 117    63: 98     64: 110
'        65: 93     66: 102    67: 100    68: 105    69: 83
'        70: 81     71: 97     72: 85     73: 70     74: 98
'        75: 100    76: 110    77: 114    78: 83     79: 90
'        80: 96     81: 112    82: 102    83: 102    84: 99
'        85: 81     86: 100    87: 93     88: 99     89: 118
'        90: 95     91: 124    92: 108    93: 96     94: 104
'        95: 106    96: 99     97: 99     98: 92     99: 99
'       100: 108
``````

La `NextBytes(Byte[], Byte, Byte)` méthode encapsule un appel à la Next(Int32, Int32) méthode et spécifie la valeur minimale et une valeur supérieure à la valeur maximale (dans ce cas, 0 et 101) que nous souhaitons retourner dans le tableau d’octets.The `NextBytes(Byte[], Byte, Byte)` method wraps a call to the Next(Int32, Int32) method and specifies the minimum value and one greater than the maximum value (in this case, 0 and 101) that we want returned in the byte array. Étant donné que nous sommes sûrs que les valeurs entières retournées par la Next méthode se trouvent dans la plage du Byte type de données, nous pouvons les caster en toute sécurité (en C#) ou les convertir (en Visual Basic) entre des entiers et des octets.Because we are sure that the integer values returned by the Next method are within the range of the Byte data type, we can safely cast them (in C#) or convert them (in Visual Basic) from integers to bytes.

#### Récupérer un élément d’un tableau ou d’une collection au hasardRetrieve an element from an array or collection at random

Les nombres aléatoires servent souvent d’index pour récupérer des valeurs à partir de tableaux ou de collections.Random numbers often serve as indexes to retrieve values from arrays or collections. Pour récupérer une valeur d’index aléatoire, vous pouvez appeler la Next(Int32, Int32) méthode et utiliser la limite inférieure du tableau comme valeur de son `minValue` argument et une valeur supérieure à la limite supérieure du tableau comme valeur de son `maxValue` argument.To retrieve a random index value, you can call the Next(Int32, Int32) method, and use the lower bound of the array as the value of its `minValue` argument and one greater than the upper bound of the array as the value of its `maxValue` argument. Pour un tableau de base zéro, cela équivaut à sa Length propriété, ou une valeur supérieure à la valeur retournée par la Array.GetUpperBound méthode.For a zero-based array, this is equivalent to its Length property, or one greater than the value returned by the Array.GetUpperBound method. L’exemple suivant récupère de façon aléatoire le nom d’une ville dans le États-Unis à partir d’un tableau de villes.The following example randomly retrieves the name of a city in the United States from an array of cities.

``````using namespace System;

void main()
{
array<String^>^ cities = { "Atlanta", "Boston", "Chicago", "Detroit",
"Fort Wayne", "Greensboro", "Honolulu", "Indianapolis",
"Jersey City", "Kansas City", "Los Angeles",
"Raleigh", "San Francisco", "Tulsa", "Washington" };
Random^ rnd = gcnew Random();
int index = rnd->Next(0, cities->Length);
Console::WriteLine("Today's city of the day: {0}",
cities[index]);
}
// The example displays output like the following:
//   Today's city of the day: Honolulu
``````
``````String[] cities = { "Atlanta", "Boston", "Chicago", "Detroit",
"Fort Wayne", "Greensboro", "Honolulu", "Indianapolis",
"Jersey City", "Kansas City", "Los Angeles",
"Raleigh", "San Francisco", "Tulsa", "Washington" };
Random rnd = new Random();
int index = rnd.Next(0, cities.Length);
Console.WriteLine("Today's city of the day: {0}",
cities[index]);

// The example displays output like the following:
//   Today's city of the day: Honolulu
``````
``````Module Example
Public Sub Main()
Dim cities() As String = { "Atlanta", "Boston", "Chicago", "Detroit",
"Fort Wayne", "Greensboro", "Honolulu", "Indianapolis",
"Jersey City", "Kansas City", "Los Angeles",
"Raleigh", "San Francisco", "Tulsa", "Washington" }
Dim rnd As New Random()
Dim index As Integer = rnd.Next(0, cities.Length)
Console.WriteLine("Today's city of the day: {0}",
cities(index))
End Sub
End Module
' The example displays output like the following:
'   Today's city of the day: Honolulu
``````

#### Récupérer un élément unique d’un tableau ou d’une collectionRetrieve a unique element from an array or collection

Un générateur de nombres aléatoires peut toujours retourner des valeurs dupliquées.A random number generator can always return duplicate values. À mesure que la plage de nombres devient plus petite ou que le nombre de valeurs générées augmente, la probabilité de doublons augmente.As the range of numbers becomes smaller or the number of values generated becomes larger, the probability of duplicates grows. Si des valeurs aléatoires doivent être uniques, davantage de nombres sont générés pour compenser les doublons, ce qui entraîne des performances de plus en plus médiocres.If random values must be unique, more numbers are generated to compensate for duplicates, resulting in increasingly poor performance.

Il existe plusieurs techniques pour gérer ce scénario.There are a number of techniques to handle this scenario. Une solution courante consiste à créer un tableau ou une collection qui contient les valeurs à récupérer et un tableau parallèle qui contient des nombres à virgule flottante aléatoires.One common solution is to create an array or collection that contains the values to be retrieved, and a parallel array that contains random floating-point numbers. Le deuxième tableau est rempli avec des nombres aléatoires au moment de la création du premier tableau, et la Array.Sort(Array, Array) méthode est utilisée pour trier le premier tableau à l’aide des valeurs du tableau parallèle.The second array is populated with random numbers at the time the first array is created, and the Array.Sort(Array, Array) method is used to sort the first array by using the values in the parallel array.

Par exemple, si vous développez un jeu solitaire, vous souhaitez vous assurer que chaque carte n’est utilisée qu’une seule fois.For example, if you're developing a Solitaire game, you want to ensure that each card is used only once. Au lieu de générer des nombres aléatoires pour récupérer une carte et de suivre si cette carte a déjà été traitée, vous pouvez créer un tableau parallèle de nombres aléatoires qui peuvent être utilisés pour trier le jeu.Instead of generating random numbers to retrieve a card and tracking whether that card has already been dealt, you can create a parallel array of random numbers that can be used to sort the deck. Une fois le pont trié, votre application peut maintenir un pointeur pour indiquer l’index de la carte suivante sur le jeu.Once the deck is sorted, your app can maintain a pointer to indicate the index of the next card on the deck.

L'exemple suivant illustre cette approche.The following example illustrates this approach. Il définit une `Card` classe qui représente une carte de jeu et une `Dealer` classe qui traite un jeu de cartes aléatoires.It defines a `Card` class that represents a playing card and a `Dealer` class that deals a deck of shuffled cards. Le `Dealer` constructeur de classe remplit deux tableaux : un `deck` tableau qui a la portée de la classe et qui représente toutes les cartes du jeu, et un `order` tableau local qui a le même nombre d’éléments que le `deck` tableau et est rempli avec des valeurs générées de manière aléatoire Double .The `Dealer` class constructor populates two arrays: a `deck` array that has class scope and that represents all the cards in the deck; and a local `order` array that has the same number of elements as the `deck` array and is populated with randomly generated Double values. La Array.Sort(Array, Array) méthode est ensuite appelée pour trier le `deck` tableau en fonction des valeurs du `order` tableau.The Array.Sort(Array, Array) method is then called to sort the `deck` array based on the values in the `order` array.

``````using namespace System;

public enum class Suit { Hearts, Diamonds, Spades, Clubs };

public enum class FaceValue  { Ace = 1, Two, Three, Four, Five, Six,
Seven, Eight, Nine, Ten, Jack, Queen,
King };

// A class that represents an individual card in a playing deck.
ref class Card
{
public:
Suit Suit;
FaceValue FaceValue;

String^ ToString() override
{
return String::Format("{0:F} of {1:F}", this->FaceValue, this->Suit);
}
};

ref class Dealer
{
private:
Random^ rnd;
// A deck of cards, without Jokers.
array<Card^>^ deck = gcnew array<Card^>(52);
// Parallel array for sorting cards.
array<Double>^ order = gcnew array<Double>(52);
// A pointer to the next card to deal.
int ptr = 0;
// A flag to indicate the deck is used.
bool mustReshuffle = false;

public:
Dealer()
{
rnd = gcnew Random();
// Initialize the deck.
int deckCtr = 0;
for each (auto suit in Enum::GetValues(Suit::typeid)) {
for each (FaceValue faceValue in Enum::GetValues(FaceValue::typeid)) {
Card^ card = gcnew Card();
card->Suit = (Suit) suit;
card->FaceValue = (FaceValue) faceValue;
deck[deckCtr] = card;
deckCtr++;
}
}

for (int ctr = 0; ctr < order->Length; ctr++)
order[ctr] = rnd->NextDouble();

Array::Sort(order, deck);
}

array<Card^>^ Deal(int numberToDeal)
{
if (mustReshuffle) {
Console::WriteLine("There are no cards left in the deck");
return nullptr;
}

array<Card^>^ cardsDealt = gcnew array<Card^>(numberToDeal);
for (int ctr = 0; ctr < numberToDeal; ctr++) {
cardsDealt[ctr] = deck[ptr];
ptr++;
if (ptr == deck->Length)
mustReshuffle = true;

if (mustReshuffle & ctr < numberToDeal - 1) {
Console::WriteLine("Can only deal the {0} cards remaining on the deck.",
ctr + 1);
return cardsDealt;
}
}
return cardsDealt;
}
};

void ShowCards(array<Card^>^ cards)
{
for each (Card^ card in cards)
if (card != nullptr)
Console::WriteLine("{0} of {1}", card->FaceValue, card->Suit);
};

void main()
{
Dealer^ dealer = gcnew Dealer();
ShowCards(dealer->Deal(20));
}

// The example displays output like the following:
//       Six of Diamonds
//       King of Clubs
//       Eight of Clubs
//       Seven of Clubs
//       Queen of Clubs
//       King of Hearts
//       Ace of Clubs
//       Four of Hearts
//       Three of Diamonds
//       Nine of Diamonds
//       Two of Hearts
//       Ace of Hearts
//       Three of Hearts
//       Eight of Hearts
//       Queen of Diamonds
//       Two of Clubs
//       Four of Diamonds
//       Jack of Hearts
``````
``````using System;

// A class that represents an individual card in a playing deck.
public class Card
{
public Suit Suit;
public FaceValue FaceValue;

public override String ToString()
{
return String.Format("{0:F} of {1:F}", this.FaceValue, this.Suit);
}
}

public enum Suit { Hearts, Diamonds, Spades, Clubs };

public enum FaceValue  { Ace = 1, Two, Three, Four, Five, Six,
Seven, Eight, Nine, Ten, Jack, Queen,
King };

public class Dealer
{
Random rnd;
// A deck of cards, without Jokers.
Card[] deck = new Card[52];
// Parallel array for sorting cards.
Double[] order = new Double[52];
// A pointer to the next card to deal.
int ptr = 0;
// A flag to indicate the deck is used.
bool mustReshuffle = false;

public Dealer()
{
rnd = new Random();
// Initialize the deck.
int deckCtr = 0;
foreach (var suit in Enum.GetValues(typeof(Suit))) {
foreach (var faceValue in Enum.GetValues(typeof(FaceValue))) {
Card card = new Card();
card.Suit = (Suit) suit;
card.FaceValue = (FaceValue) faceValue;
deck[deckCtr] = card;
deckCtr++;
}
}

for (int ctr = 0; ctr < order.Length; ctr++)
order[ctr] = rnd.NextDouble();

Array.Sort(order, deck);
}

public Card[] Deal(int numberToDeal)
{
if (mustReshuffle) {
Console.WriteLine("There are no cards left in the deck");
return null;
}

Card[] cardsDealt = new Card[numberToDeal];
for (int ctr = 0; ctr < numberToDeal; ctr++) {
cardsDealt[ctr] = deck[ptr];
ptr++;
if (ptr == deck.Length)
mustReshuffle = true;

if (mustReshuffle & ctr < numberToDeal - 1) {
Console.WriteLine("Can only deal the {0} cards remaining on the deck.",
ctr + 1);
return cardsDealt;
}
}
return cardsDealt;
}
}

public class Example
{
public static void Main()
{
Dealer dealer = new Dealer();
ShowCards(dealer.Deal(20));
}

private static void ShowCards(Card[] cards)
{
foreach (var card in cards)
if (card != null)
Console.WriteLine("{0} of {1}", card.FaceValue, card.Suit);
}
}
// The example displays output like the following:
//       Six of Diamonds
//       King of Clubs
//       Eight of Clubs
//       Seven of Clubs
//       Queen of Clubs
//       King of Hearts
//       Ace of Clubs
//       Four of Hearts
//       Three of Diamonds
//       Nine of Diamonds
//       Two of Hearts
//       Ace of Hearts
//       Three of Hearts
//       Eight of Hearts
//       Queen of Diamonds
//       Two of Clubs
//       Four of Diamonds
//       Jack of Hearts
``````
``````' A class that represents an individual card in a playing deck.
Public Class Card
Public Suit As Suit
Public FaceValue As FaceValue

Public Overrides Function ToString() As String
Return String.Format("{0:F} of {1:F}", Me.FaceValue, Me.Suit)
End Function
End Class

Public Enum Suit As Integer
Hearts = 0
Diamonds = 1
Clubs = 3
End Enum

Public Enum FaceValue As Integer
Ace = 1
Two = 2
Three = 3
Four = 4
Five = 5
Six = 6
Seven = 7
Eight = 8
Nine = 9
Ten = 10
Jack = 11
Queen = 12
King = 13
End Enum

Public Class Dealer
Dim rnd As Random
' A deck of cards, without Jokers.
Dim deck(51) As Card
' Parallel array for sorting cards.
Dim order(51) As Double
' A pointer to the next card to deal.
Dim ptr As Integer = 0
' A flag to indicate the deck is used.
Dim mustReshuffle As Boolean

Public Sub New()
rnd = New Random()
' Initialize the deck.
Dim deckCtr As Integer = 0
For Each Suit In [Enum].GetValues(GetType(Suit))
For Each faceValue In [Enum].GetValues(GetType(FaceValue))
Dim card As New Card()
card.Suit = CType(Suit, Suit)
card.FaceValue = CType(faceValue, FaceValue)
deck(deckCtr) = card
deckCtr += 1
Next
Next
For ctr As Integer = 0 To order.Length - 1
order(ctr) = rnd.NextDouble()
Next
Array.Sort(order, deck)
End Sub

Public Function Deal(numberToDeal As Integer) As Card()
If mustReshuffle Then
Console.WriteLine("There are no cards left in the deck")
Return Nothing
End If

Dim cardsDealt(numberToDeal - 1) As Card
For ctr As Integer = 0 To numberToDeal - 1
cardsDealt(ctr) = deck(ptr)
ptr += 1
If ptr = deck.Length Then
mustReshuffle = True
End If
If mustReshuffle And ctr < numberToDeal - 1
Console.WriteLine("Can only deal the {0} cards remaining on the deck.",
ctr + 1)
Return cardsDealt
End If
Next
Return cardsDealt
End Function
End Class

Public Module Example
Public Sub Main()
Dim dealer As New Dealer()
ShowCards(dealer.Deal(20))
End Sub

Private Sub ShowCards(cards() As Card)
For Each card In cards
If card IsNot Nothing Then _
Console.WriteLine("{0} of {1}", card.FaceValue, card.Suit)
Next
End Sub
End Module
' The example displays output like the following:
'       Six of Diamonds
'       King of Clubs
'       Eight of Clubs
'       Seven of Clubs
'       Queen of Clubs
'       King of Hearts
'       Ace of Clubs
'       Four of Hearts
'       Three of Diamonds
'       Nine of Diamonds
'       Two of Hearts
'       Ace of Hearts
'       Three of Hearts
'       Eight of Hearts
'       Queen of Diamonds
'       Two of Clubs
'       Four of Diamonds
'       Jack of Hearts
``````

## Notes pour les héritiers

Dans les .NET Framework 1,0 et 1,1, une implémentation minimale d’une classe dérivée de Random nécessitait la substitution de la Sample() méthode pour définir un algorithme nouveau ou modifié pour la génération de nombres aléatoires.In the .NET Framework 1.0 and 1.1, a minimum implementation of a class derived from Random required overriding the Sample() method to define a new or modified algorithm for generating random numbers. La classe dérivée peut ensuite reposer sur l’implémentation de la classe de base des Next() méthodes,,, Next(Int32) Next(Int32, Int32) NextBytes(Byte[]) et NextDouble() pour appeler l’implémentation de la classe dérivée de la Sample() méthode.The derived class could then rely on the base class implementation of the Next(), Next(Int32), Next(Int32, Int32), NextBytes(Byte[]), and NextDouble() methods to call the derived class implementation of the Sample() method.

Dans le .NET Framework 2,0 et versions ultérieures, le comportement Next() des Next(Int32, Int32) méthodes, et NextBytes(Byte[]) a changé, de sorte que ces méthodes n’appellent pas nécessairement l’implémentation de la classe dérivée de la Sample() méthode.In the .NET Framework 2.0 and later, the behavior of the Next(), Next(Int32, Int32), and NextBytes(Byte[]) methods have changed so that these methods do not necessarily call the derived class implementation of the Sample() method. Par conséquent, les classes dérivées de Random qui ciblent le .NET Framework 2,0 et versions ultérieures doivent également remplacer ces trois méthodes.As a result, classes derived from Random that target the .NET Framework 2.0 and later should also override these three methods.

## Notes pour les appelants

Il n’est pas garanti que l’implémentation du générateur de nombres aléatoires dans la Random classe reste la même dans les versions principales du .NET Framework.The implementation of the random number generator in the Random class isn't guaranteed to remain the same across major versions of the .NET Framework. Par conséquent, vous ne devez pas supposer que la même valeur de départ entraînera la même séquence Pseudo-aléatoire dans différentes versions du .NET Framework.As a result, you shouldn't assume that the same seed will result in the same pseudo-random sequence in different versions of the .NET Framework.

## Constructeurs

 Initialise une nouvelle instance de la classe Random en utilisant une valeur de départ par défaut.Initializes a new instance of the Random class using a default seed value. Initialise une nouvelle instance de la classe Random à l'aide de la valeur initiale spécifiée.Initializes a new instance of the Random class, using the specified seed value.

## Méthodes

 Détermine si l'objet spécifié est égal à l'objet actuel.Determines whether the specified object is equal to the current object. (Hérité de Object) Fait office de fonction de hachage par défaut.Serves as the default hash function. (Hérité de Object) Obtient le Type de l'instance actuelle.Gets the Type of the current instance. (Hérité de Object) Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object. (Hérité de Object) Retourne un nombre aléatoire entier non négatif.Returns a non-negative random integer. Retourne un nombre aléatoire entier non négatif, inférieur au nombre maximal spécifié.Returns a non-negative random integer that is less than the specified maximum. Retourne un entier aléatoire qui se trouve dans une plage spécifiée.Returns a random integer that is within a specified range. Remplit les éléments d'un tableau d'octets spécifié à l'aide de nombres aléatoires.Fills the elements of a specified array of bytes with random numbers. Remplit les éléments d’une plage d’octets spécifiée avec des nombres aléatoires.Fills the elements of a specified span of bytes with random numbers. Retourne un nombre aléatoire à virgule flottante supérieur ou égal à 0,0 et inférieur à 1,0.Returns a random floating-point number that is greater than or equal to 0.0, and less than 1.0. Retourne un nombre aléatoire à virgule flottante compris entre 0,0 et 1,0.Returns a random floating-point number between 0.0 and 1.0. Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object. (Hérité de Object)