Exporter (0) Imprimer
Développer tout
Cet article a fait l'objet d'une traduction automatique. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte. Informations supplémentaires.
Traduction
Source

Random, classe

Représente un générateur de nombres pseudo-aléatoires. Il s'agit d'un périphérique qui produit une séquence de nombres conformes à certains prérequis statistiques liés à l'aspect aléatoire.

Espace de noms :  System
Assembly :  mscorlib (dans mscorlib.dll)

[SerializableAttribute]
[ComVisibleAttribute(true)]
public class Random

Le type Random expose les membres suivants.

  NomDescription
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreRandom()Initialise une nouvelle instance de la classe Random, à l'aide d'une valeur initiale par défaut qui est fonction du temps.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreRandom(Int32)Initialise une nouvelle instance de la classe Random à l'aide de la valeur initiale spécifiée.
Début

  NomDescription
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreEquals(Object)Détermine si l'objet spécifié est identique à l'objet actuel. (Hérité de Object.)
Méthode protégéePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreFinalize Autorise un objet à tenter de libérer des ressources et d'exécuter d'autres opérations de nettoyage avant qu'il ne soit récupéré par l'opération garbage collection. (Hérité de Object.)
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetHashCodeSert de fonction de hachage par défaut. (Hérité de Object.)
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetTypeObtient le Type de l'instance actuelle. (Hérité de Object.)
Méthode protégéePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMemberwiseCloneCrée une copie superficielle de l'objet Object actuel. (Hérité de Object.)
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreNext()Retourne un nombre aléatoire entier non négatif.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreNext(Int32)Retourne un nombre aléatoire entier non négatif, inférieur au nombre maximal spécifié.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreNext(Int32, Int32)Retourne un entier aléatoire qui se trouve dans une plage spécifiée.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreNextBytesRemplit les éléments d'un tableau d'octets spécifié à l'aide de nombres aléatoires.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreNextDoubleRetourne un nombre aléatoire en virgule flottante compris entre 0,0 et 1,0.
Méthode protégéePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSampleRetourne un nombre aléatoire en virgule flottante compris entre 0,0 et 1,0.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToStringRetourne une chaîne qui représente l'objet actif. (Hérité de Object.)
Début

Les nombres pseudo-aléatoires sont tous sélectionnés avec la même probabilité dans un jeu de nombres fini. Les nombres choisis ne sont pas entièrement aléatoires parce qu'ils sont sélectionnés à l'aide d'un algorithme mathématique précis, mais ils sont néanmoins suffisamment aléatoires pour des fins pratiques. L'implémentation actuelle de la classe Random est basée sur Donald E. Algorithme de générateur de nombres aléatoires soustractif de Knuth. Pour plus d'informations, consultez D. Est, Knuth. « The Art of Computer Programming, volume 2: Seminumerical Algorithms ». Addison-Wesley, Reading, MA, deuxième édition, 1981.

La génération de nombres aléatoires commence à partir d'une valeur initiale. Lorsque la même valeur initiale est utilisée à plusieurs reprises, la même série de nombres est générée. Pour générer des séquences différentes, il est possible de rendre la valeur initiale dépendante du temps. Dans ce cas, une série différente est obtenue pour chaque nouvelle instance de Random. Par défaut, le constructeur sans paramètre de la classe Random utilise l'horloge système pour générer sa valeur initiale, pendant que son constructeur paramétré peut prendre une valeur Int32 selon le nombre de graduations dans l'heure actuelle. Toutefois, l'horloge disposant de la résolution finie, la création successive d'objets Random différents à l'aide du constructeur sans paramètre crée des générateurs de nombres aléatoires qui produisent des séquences identiques de nombres aléatoires. L'exemple suivant montre comment deux objets Random instanciés successivement génèrent une série identique de nombres aléatoires.


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 the following output to the console:
//       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        


Ce problème peut être évité en créant un seul objet Random plutôt que plusieurs.

Pour améliorer les performances, créez un objet Random permettant de générer une grande quantité de nombres aléatoires dans le temps, au lieu de créer un objet Random par nombre aléatoire.

Pour générer un nombre aléatoire sécurisé d'un point de vue du chiffrement, convenant, par exemple, à la création d'un mot de passe aléatoire, utilisez une classe dérivée de System.Security.Cryptography.RandomNumberGenerator telle que System.Security.Cryptography.RNGCryptoServiceProvider.

Remarques à l'attention des appelants

L'implémentation du générateur de nombres aléatoires dans la classe Random n'est pas garantie pour rester inchangée sur les versions principales du .NET Framework. Par conséquent, votre code d'application ne doit pas supposer que la même valeur initiale génèrera la même séquence pseudo-aléatoire dans les différentes versions du .NET Framework.

Remarques à l'attention des héritiers

Dans le .NET Framework versions 1.0 et 1.1, l'implémentation d'une classe dérivée de Random passait, au minimum, par la substitution de la méthode Sample pour définir un nouvel algorithme ou modifier un algorithme en vue de générer des nombres aléatoires. La classe dérivée pouvait alors reposer sur l'implémentation de la classe de base des méthodes Random.Next(), Random.Next(Int32), Random.Next(Int32, Int32), NextBytes et NextDouble pour appeler l'implémentation de la classe dérivée de la méthode Sample.

Dans le .NET Framework versions 2.0 et ultérieures, le comportement des méthodes Random.Next(), Random.Next(Int32, Int32) et NextBytes a changé : ces méthodes n'appellent en effet pas nécessairement l'implémentation de la classe dérivée de la méthode Sample. Les classes dérivée de Random qui ciblent le .NET Framework versions 2.0 et ultérieures doivent de ce fait également substituer ces trois méthodes.

L'exemple suivant crée un générateur de nombres aléatoires unique et appelle les méthodes NextBytes, Next et NextDouble pour générer des séquences de nombres aléatoires dans des plages différentes.


// Instantiate random number generator using system-supplied value as seed.
Random rand = new Random();
// Generate and display 5 random byte (integer) values.
byte[] bytes = new byte[4];
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);
// Sample console output might appear as follows:
//    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 arbitraire qu'il utilise comme index pour récupérer une valeur de chaîne dans un tableau.


using System;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      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:     {0}", malePetNames[mIndex]);
      Console.WriteLine("   For a female:   {0}", femalePetNames[fIndex]);
   }
}
// The example displays the following output:
//       Suggested pet name of the day:
//          For a male:     Koani
//          For a female:   Maggie


.NET Framework

Pris en charge dans : 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Pris en charge dans : 4, 3.5 SP1

Bibliothèque de classes portable

Pris en charge dans : Bibliothèque de classes portable

.NET pour les applications du Windows Store

Pris en charge dans : Windows 8

.NET pour les applications Windows Phone

Pris en charge dans : Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (rôle principal du serveur non pris en charge), Windows Server 2008 R2 (rôle principal du serveur pris en charge avec SP1 ou version ultérieure ; Itanium non pris en charge)

Le .NET Framework ne prend pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.

Tous les membres static (Shared en Visual Basic) publics de ce type sont thread-safe. Il n'est pas garanti que les membres d'instance soient thread-safe.

Ajouts de la communauté

AJOUTER
Afficher:
© 2015 Microsoft