Qu'est-ce que le générateur de nombres aléatoires en C #?
Un générateur de nombres aléatoires est une bibliothèque intégrée en C # qui génère des nombres entiers et des nombres à virgule flottante de manière aléatoire. Chaque fois que la méthode pertinente de la bibliothèque est invoquée, elle renvoie un nombre aléatoire. Une série de nombres aléatoires est un ensemble de nombres qui ne suivent aucun modèle. Le générateur de nombres aléatoires en C # a tendance à générer une telle série chaque fois qu'il est invoqué.
Classe aléatoire en C #
- Alors, comment C # génère-t-il une série de nombres aléatoires? La réponse se trouve dans la classe aléatoire de l'espace de noms du système C #.
- La classe aléatoire est une classe génératrice de nombres pseudo-aléatoires. Cela signifie que cette classe est chargée de générer une série de nombres qui ne suivent aucun modèle. Mais, une machine est-elle vraiment capable de générer des nombres aléatoires? Comment la machine pourrait-elle savoir quel numéro générer ensuite? Après tout, la machine est conçue pour suivre des instructions et exécuter des algorithmes.
- Non, la machine ne peut pas générer seule des nombres aléatoires. Il existe un algorithme mathématique défini, basé sur l'horloge actuelle et l'état de la machine, qui la guide pour choisir des nombres dans un ensemble. Tous les numéros de l'ensemble ont une probabilité égale d'être ramassés. Ainsi, ils ne sont pas parfaitement aléatoires. Ils suivent un schéma. C'est juste que le motif est suffisamment aléatoire pour répondre aux besoins humains pratiques.
Pseudo et sécurisé
La prochaine question qui vient à l'esprit est pourquoi l'appelle-t-on classe génératrice de nombres pseudo-aléatoires? Comprenons cela à travers le comportement humain de la vie réelle. Lorsqu'un être humain est invité à sélectionner une couleur aléatoire, il prend une certaine couleur. Disons qu'il a choisi Yellow. Qu'est-ce qui l'a poussé à choisir du jaune? Cela pourrait être sa couleur préférée ou la couleur de son environnement, ou il aurait pu penser à quelque chose de jaune à l'époque. Ce comportement humain qui motive la décision de choisir quelque chose au hasard est appelé la graine dans le monde du hasard. La graine est le déclencheur ou le point de départ de l'aléatoire.
Maintenant, lorsque la graine est prévisible, les nombres aléatoires deviennent moins aléatoires. Ils sont alors appelés nombres pseudo-aléatoires. Lorsqu'ils sont imprévisibles, ils sont appelés nombres aléatoires sécurisés.
La classe aléatoire C # utilise l'horodatage actuel comme graine, ce qui est très prévisible. Et donc, le terme classe de génération de nombres pseudo-aléatoires.
Classe RNGCryptoServiceProvider
La classe RNGCryptoServiceProvider de l'espace de noms System.Security.Cryptography est capable de générer des nombres aléatoires sécurisés, ceux qui peuvent être utilisés comme mots de passe.
Fonctions du générateur de nombres aléatoires en C #
La première chose à générer un nombre aléatoire en C # est d'initialiser la classe Random. Cela peut être fait par l'un des deux constructeurs de la classe:
- Random (): Initialise un objet de la classe Random à l'aide d'une valeur de départ basée sur le temps. La valeur de départ est l'horodatage actuel de la machine. Bien que, dans les versions ultérieures, cela ait été modifié pour être basé sur GUID.
- Random (Int32): Initialise un objet de la classe Random en utilisant la valeur de départ spécifiée. Pour obtenir le prochain nombre aléatoire de la série, nous appelons la méthode Next () de la classe Random.
- Next (): Renvoie un entier Int32 pseudo-aléatoire non négatif.
- Suivant (Int32): Renvoie un entier Int32 pseudo-aléatoire non négatif inférieur à l'entier spécifié.
- Next (Int32, Int32): Renvoie un entier Int32 pseudo-aléatoire non négatif dans la plage spécifiée.
Entiers de générateur de nombres aléatoires en C #
Voyons un exemple de la façon de générer des entiers aléatoires:
Exemple 1
L'exemple ci-dessous génère des nombres Int32 aléatoires.
Code:
using System;
public class Program
(
public static void Main()
(
Random rnd = new Random();
for (int i = 0; i < 10; i++)
Console.WriteLine("Random number (0) : (1)", i + 1, GenerateRandomInt(rnd));
)
public static int GenerateRandomInt(Random rnd)
(
return rnd.Next();
)
)
Production:
Exemple # 2
L'exemple ci-dessous génère des nombres Int32 aléatoires compris entre 0 et 100.
Code:
using System;
public class Program
(
public static void Main()
(
Random rnd = new Random();
for (int i = 0; i < 10; i++)
Console.WriteLine("Random number (0) : (1)", i + 1, GenerateRandomInt(rnd));
)
public static int GenerateRandomInt(Random rnd)
(
return rnd.Next(100);
)
)
Production:
Exemple # 3
L'exemple ci-dessous génère des nombres Int32 aléatoires compris entre 50 et 100.
Code:
using System;
public class Program
(
public static void Main()
(
Random rnd = new Random();
for (int i = 0; i < 10; i++)
Console.WriteLine("Random number (0) : (1)", i + 1, GenerateRandomInt(rnd));
)
public static int GenerateRandomInt(Random rnd)
(
return rnd.Next(50, 100);
)
)
Production:
Génération de nombres à virgule flottante
Voyons un exemple de la façon de générer des nombres à virgule flottante aléatoires:
Exemple 1
L'exemple ci-dessous génère des nombres Int32 aléatoires.
Code:
using System;
public class Program
(
public static void Main()
(
Random rnd = new Random();
for (int i = 0; i < 10; i++)
Console.WriteLine("Random number (0) : (1)", i + 1, GenerateRandomInt(rnd));
)
public static double GenerateRandomInt(Random rnd)
(
return rnd.NextDouble();
)
)
Production:
Une erreur très courante
L'erreur la plus courante que les développeurs commettent lors de la génération de nombres aléatoires est que pour chaque nombre aléatoire, ils créent un nouvel objet de classe aléatoire. Comme illustré dans l'exemple ci-dessous:
Exemple 1
Code:
using System;
public class Program
(
public static void Main()
(
for (int i = 0; i < 10; i++)
Console.WriteLine("Random number (0) : (1)", i + 1, GenerateRandomInt());
)
public static int GenerateRandomInt()
(
Random rnd = new Random(); //a very common mistake
return rnd.Next();
)
)
Production:
Comment les nombres aléatoires sont-ils tous identiques et pourquoi est-ce arrivé?
Comme expliqué dans le fonctionnement de Random Class, les nombres générés sont basés sur la valeur de départ et l'état actuel de la machine. Toute instance de la classe Random commence par la valeur de départ, enregistre l'état actuel et l'utilise pour générer le nombre aléatoire suivant. Dans le code ci-dessus, l'erreur a été de créer une nouvelle instance de la classe Random à chaque itération de la boucle. Ainsi, avant que l'heure de l'horloge interne ne change, le code est entièrement exécuté et chaque instance de la classe Random est instanciée avec la même valeur de départ. Il en résulte le même ensemble de nombres générés à chaque fois.
Conclusion - Générateur de nombres aléatoires en C #
Dans cet article, nous avons découvert le générateur de nombres aléatoires en C # et son fonctionnement interne pour générer des nombres aléatoires. Nous avons également brièvement appris le concept des nombres pseudo-aléatoires et sécurisés-aléatoires. Ces informations sont suffisantes pour que les développeurs utilisent la classe Random dans leurs applications. Plongée profonde, si vous êtes intéressé à explorer davantage les nombres aléatoires pour les mots de passe et les mots de passe à usage unique
Articles recommandés
Ceci est un guide du générateur de nombres aléatoires en C #. Ici, nous discutons du fonctionnement de Random Number Generator, du concept de nombres pseudo-aléatoires et sécurisés-aléatoires et de l'utilisation de Random Number. Vous pouvez également consulter nos autres articles connexes pour en savoir plus -
- Fonctions mathématiques en C #
- Destructeur en C #
- Nombre inversé en Python
- Variables en C #
- Variables en JavaScript
- Générateur de nombres aléatoires dans Matlab
- Versions de Tableau
- Générateur de nombres aléatoires en JavaScript
- Générateur de nombres aléatoires en PHP