Random Classe

Définition

Espace de noms:: System

Assemblys:: mscorlib.dll, System.Runtime.Extensions.dll

Assemblys:: netstandard.dll, System.Runtime.dll

Assembly:: System.Runtime.Extensions.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Source:: Random.cs

Source:: Random.cs

Source:: Random.cs

Source:: Random.cs

Source:: Random.cs

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Représente un générateur de nombres pseudo-aléatoires, qui est un algorithme qui produit une séquence de nombres répondant à certaines exigences statistiques pour la randomité.

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: Object
Random

Attributs: SerializableAttribute ComVisibleAttribute

Exemples

L’exemple suivant crée un générateur de nombres aléatoires unique et appelle ses méthodes Nextet NextDouble ses NextBytesméthodes pour générer des séquences de nombres aléatoires dans différentes plages.

// Instantiate random number generator using system-supplied value as seed.
var rand = new Random();

// Generate and display 5 random byte (integer) values.
byte[] 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

// Instantiate random number generator using system-supplied value as seed.
let rand = Random()

// Generate and display 5 random byte (integer) values.
let bytes = Array.zeroCreate 5
rand.NextBytes bytes
printfn "Five random byte values:"
for byte in bytes do
    printf "%5i" byte
printfn ""

// Generate and display 5 random integers.
printfn "Five random integer values:"
for _ = 0 to 4 do
    printf $"{rand.Next(),15:N0}" 
printfn ""

// Generate and display 5 random integers between 0 and 100.
printfn "Five random integers between 0 and 100:"
for _ = 0 to 4 do
    printf $"{rand.Next 101,8:N0}"
printfn ""

// Generate and display 5 random integers from 50 to 100.
printfn "Five random integers between 50 and 100:"
for _ = 0 to 4 do
    printf $"{rand.Next(50, 101),8:N0}"
printfn ""

// Generate and display 5 random floating point values from 0 to 1.
printfn "Five Doubles."
for _ = 0 to 4 do
    printf $"{rand.NextDouble(),8:N3}"
printfn ""

// Generate and display 5 random floating point values from 0 to 5.
printfn "Five Doubles between 0 and 5."
for _ = 0 to 4 do
    printf $"{rand.NextDouble() * 5.0,8:N3}"

// 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 à partir d’un tableau.

Random rnd = new();
string[] malePetNames = [ "Rufus", "Bear", "Dakota", "Fido",
                        "Vanya", "Samuel", "Koani", "Volodya",
                        "Prince", "Yiska" ];
string[] femalePetNames = [ "Maggie", "Penny", "Saya", "Princess",
                          "Abby", "Laila", "Sadie", "Olivia",
                          "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:     {malePetNames[mIndex]}");
Console.WriteLine($"   For a female:   {femalePetNames[fIndex]}");

// The example displays output similar to the following:
//       Suggested pet name of the day:
//          For a male:     Koani
//          For a female:   Maggie

let rnd = Random()

let malePetNames =
    [| "Rufus"; "Bear"; "Dakota"; "Fido";
        "Vanya"; "Samuel"; "Koani"; "Volodya";
        "Prince"; "Yiska" |]
let femalePetNames = 
    [| "Maggie"; "Penny"; "Saya"; "Princess";
        "Abby"; "Laila"; "Sadie"; "Olivia";
        "Starlight"; "Talla" |]

// Generate random indexes for pet names.
let mIndex = rnd.Next malePetNames.Length
let fIndex = rnd.Next femalePetNames.Length

// Display the result.
printfn "Suggested pet name of the day: "
printfn "   For a male:     %s" malePetNames.[mIndex]
printfn "   For a female:   %s" 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", 
                                         "Abby", "Laila", "Sadie", "Olivia", 
                                         "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

Note

Pour générer un nombre aléatoire sécurisé par chiffrement, tel qu’un numéro adapté à la création d’un mot de passe aléatoire, utilisez l’une des méthodes statiques de la RandomNumberGenerator classe.

Pour plus d’informations sur cette API, consultez les remarques d’API supplémentaires pour Random.

Notes pour les héritiers

Dans .NET Framework 2.0 et versions ultérieures, le comportement du Next(), Next(Int32, Int32)et NextBytes(Byte[]) les méthodes ont changé afin que ces méthodes n’appellent pas nécessairement l’implémentation de classe dérivée de la Sample() méthode. Par conséquent, les classes dérivées de Random ce .NET Framework 2.0 cible et versions ultérieures doivent également remplacer ces trois méthodes.

Notes pour les appelants

L’implémentation du générateur de nombres aléatoires dans la Random classe n’est pas garantie de rester la même dans les versions principales de .NET. Par conséquent, vous ne devez pas supposer que la même valeur initiale entraîne la même séquence pseudo-aléatoire dans différentes versions de .NET.

Constructeurs

Nom	Description
Random()	Initialise une nouvelle instance de la classe à l’aide Random d’une valeur initiale par défaut.
Random(Int32)	Initialise une nouvelle instance de la Random classe à l’aide de la valeur initiale spécifiée.

Propriétés

Nom	Description
Shared	Fournit une instance thread-safe Random qui peut être utilisée simultanément à partir de n’importe quel thread.

Méthodes

Nom	Description
Equals(Object)	Détermine si l’objet spécifié est égal à l’objet actuel. (Hérité de Object)
GetHashCode()	Sert de fonction de hachage par défaut. (Hérité de Object)
GetHexString(Int32, Boolean)	Crée une chaîne remplie de caractères hexadécimaux aléatoires.
GetHexString(Span<Char>, Boolean)	Remplit une mémoire tampon avec des caractères hexadécimaux aléatoires.
GetItems<T>(ReadOnlySpan<T>, Int32)	Crée un tableau rempli avec des éléments choisis au hasard à partir de l’ensemble de choix fourni.
GetItems<T>(ReadOnlySpan<T>, Span<T>)	Remplit les éléments d’une étendue spécifiée avec des éléments choisis au hasard à partir de l’ensemble de choix fourni.
GetItems<T>(T[], Int32)	Crée un tableau rempli avec des éléments choisis au hasard à partir de l’ensemble de choix fourni.
GetString(ReadOnlySpan<Char>, Int32)	Crée une chaîne remplie avec des caractères choisis au hasard à partir de `choices`.
GetType()	Obtient la Type de l’instance actuelle. (Hérité de Object)
MemberwiseClone()	Crée une copie superficielle du Objectactuel. (Hérité de Object)
Next()	Retourne un entier aléatoire non négatif.
Next(Int32, Int32)	Retourne un entier aléatoire qui se trouve dans une plage spécifiée.
Next(Int32)	Retourne un entier aléatoire non négatif inférieur au maximum spécifié.
NextBytes(Byte[])	Remplit les éléments d’un tableau d’octets spécifié avec des nombres aléatoires.
NextBytes(Span<Byte>)	Remplit les éléments d’une étendue d’octets spécifiée avec des nombres aléatoires.
NextDouble()	Retourne un nombre à virgule flottante aléatoire supérieur ou égal à 0,0 et inférieur à 1,0.
NextInt64()	Retourne un entier aléatoire non négatif.
NextInt64(Int64, Int64)	Retourne un entier aléatoire qui se trouve dans une plage spécifiée.
NextInt64(Int64)	Retourne un entier aléatoire non négatif inférieur au maximum spécifié.
NextSingle()	Retourne un nombre à virgule flottante aléatoire supérieur ou égal à 0,0 et inférieur à 1,0.
Sample()	Retourne un nombre à virgule flottante aléatoire compris entre 0,0 et 1,0.
Shuffle<T>(Span<T>)	Effectue une combinaison sur place d’une étendue.
Shuffle<T>(T[])	Effectue une shuffle sur place d’un tableau.
ToString()	Retourne une chaîne qui représente l’objet actuel. (Hérité de Object)

S’applique à

Commentaires

Est-ce que cette page vous a été utile?