random valeur - Comment générer un nombre entier aléatoire en C#?




tirage tableau (19)

Les nombres générés par la classe Random intégrée (System.Random) génèrent des nombres pseudo-aléatoires.

Si vous voulez de vrais nombres aléatoires, le plus proche que nous pouvons obtenir est "générateur pseudo-aléatoire sécurisé" qui peut être généré en utilisant les classes cryptographiques en C # telles que RNGCryptoServiceProvider .

Même ainsi, si vous avez toujours besoin de vrais nombres aléatoires, vous devrez utiliser une source externe telle que les dispositifs qui prennent en compte la désintégration radioactive comme une graine pour un générateur de nombres aléatoires. Puisque, par définition, tout nombre généré par des moyens purement algorithmiques ne peut pas être réellement aléatoire.

Comment générer un entier aléatoire en C #?


Méfiez-vous du fait que new Random() est placé sur l'horodatage actuel.

Si vous voulez générer un seul numéro, vous pouvez utiliser:

new Random().Next( int.MinValue, int.MaxValue )

Pour plus d'informations, regardez la classe Random , mais veuillez noter:

Cependant, comme l'horloge a une résolution finie, l'utilisation du constructeur sans paramètre pour créer différents objets aléatoires en succession rapprochée crée des générateurs de nombres aléatoires qui produisent des séquences identiques de nombres aléatoires.

N'utilisez donc pas ce code pour générer une série de nombres aléatoires.


Random r = new Random();
int n = r.Next();

 int n = new Random().Next();

vous pouvez également donner une valeur minimum et maximum à la fonction Next() . Comme

 int n = new Random().Next(5,10);

C'est la classe que j'utilise. Fonctionne comme RandomNumber.GenerateRandom(1, 666)

internal static class RandomNumber
{
    private static Random r = new Random();
    private static object l = new object();
    private static Random globalRandom = new Random();
    [ThreadStatic]
    private static Random localRandom;
    public static int GenerateNewRandom(int min, int max)
    {
        return new Random().Next(min, max);
    }
    public static int GenerateLockedRandom(int min, int max)
    {
        int result;
        lock (RandomNumber.l)
        {
            result = RandomNumber.r.Next(min, max);
        }
        return result;
    }
    public static int GenerateRandom(int min, int max)
    {
        Random random = RandomNumber.localRandom;
        if (random == null)
        {
            int seed;
            lock (RandomNumber.globalRandom)
            {
                seed = RandomNumber.globalRandom.Next();
            }
            random = (RandomNumber.localRandom = new Random(seed));
        }
        return random.Next(min, max);
    }
}

Random rand = new Random();
int name = rand.Next()

Mettez toutes les valeurs que vous voulez dans les secondes parenthèses assurez-vous que vous avez défini un nom en écrivant prop et double onglet pour générer le code


Random randomNumberGenerator = new Random ();
int randomNumber = randomNumberGenerator.Next (lowerBound,upperBound);

La classe Random est utilisée pour créer des nombres aléatoires. (Pseudo-aléatoire c'est bien sûr.).

Exemple:

Random rnd = new Random();
int month = rnd.Next(1, 13); // creates a number between 1 and 12
int dice = rnd.Next(1, 7);   // creates a number between 1 and 6
int card = rnd.Next(52);     // creates a number between 0 and 51

Si vous voulez créer plus d'un nombre aléatoire, vous devez conserver l'instance Random et la réutiliser. Si vous créez de nouvelles instances trop proches dans le temps, elles produiront la même série de nombres aléatoires que le générateur aléatoire est ensemencé à partir de l'horloge système.


Bien que ce soit correct:

Random random = new Random();
int randomNumber = random.Next()

Vous voudriez contrôler la limite (min et max mumbers) la plupart du temps. Vous devez donc spécifier où le nombre aléatoire commence et se termine.

La méthode Next() accepte deux paramètres, min et max.

Donc, si je veux que mon nombre aléatoire soit entre 5 et 15, je ferais juste

int randomNumber = random.Next(5, 16)

Les nombres calculés par un ordinateur par un processus déterministe ne peuvent, par définition, être aléatoires.

Si vous voulez un nombre aléatoire réel, le hasard provient du bruit atmosphérique ou de la désintégration radioactive.

Vous pouvez essayer par exemple RANDOM.ORG (cela réduit les performances)


Je voulais montrer ce qui se passe quand un nouveau générateur aléatoire est utilisé à chaque fois. Supposons que vous ayez deux méthodes ou deux classes nécessitant chacune un nombre aléatoire. Et naïvement vous les codez comme:

public class A
{
    public A()
    {
        var rnd=new Random();
        ID=rnd.Next();
    }
    public int ID { get; private set; }
}
public class B
{
    public B()
    {
        var rnd=new Random();
        ID=rnd.Next();
    }
    public int ID { get; private set; }
}

Pensez-vous que vous obtiendrez deux ID différents? NAN

class Program
{
    static void Main(string[] args)
    {
        A a=new A();
        B b=new B();

        int ida=a.ID, idb=b.ID;
        // ida = 1452879101
        // idb = 1452879101
    }
}

La solution consiste à toujours utiliser un seul générateur aléatoire statique. Comme ça:

public static class Utils
{
    public static readonly Random random=new Random();
}

public class A
{
    public A()
    {
        ID=Utils.random.Next();
    }
    public int ID { get; private set; }
}
public class B
{
    public B()
    {
        ID=Utils.random.Next();
    }
    public int ID { get; private set; }
}

J'utilise le code ci-dessous pour avoir un nombre aléatoire:

var random = new Random((int)DateTime.Now.Ticks);
var randomValue = random.Next(startValue, endValue + 1);

Vous pouvez essayer avec la valeur de la graine aléatoire en utilisant ci-dessous:

var rnd = new Random(11111111); //note: seed value is 11111111

string randomDigits = rnd.Next().ToString().Substring(0, 8);

var requestNumber = $"SD-{randomDigits}";

Pourquoi ne pas utiliser int randomNumber = Random.Range(start_range, end_range) ?


J'ai essayé toutes ces solutions à l'exclusion de la réponse COBOL ... lol

Aucune de ces solutions n'était assez bonne. J'avais besoin de randoms dans un rapide pour int boucle et je recevais des tonnes de valeurs en double, même dans de très larges gammes. Après s'être fixé trop longtemps pour des résultats aléatoires, j'ai finalement décidé de résoudre ce problème une fois pour toutes.

Tout tourne autour de la graine.

Je crée un entier aléatoire en analysant les non-chiffres de Guid, puis je l'utilise pour instancier ma classe Random.

public int GenerateRandom(int min, int max)
{
    var seed = Convert.ToInt32(Regex.Match(Guid.NewGuid().ToString(), @"\d+").Value);
    return new Random(seed).Next(min, max);
}

Mise à jour : l'amorçage n'est pas nécessaire si vous instanciez une fois la classe Random. Il serait donc préférable de créer une classe statique et d'appeler une méthode.

public static class IntUtil
{
   private static Random random;

   private static void Init()
   {
      if (random == null) random = new Random();
   }

   public static int Random(int min, int max)
   {
      Init();
      return random.Next(min, max);
   }
}

Ensuite, vous pouvez utiliser la classe statique comme si ..

for(var i = 0; i < 1000; i++)
{
   int randomNumber = IntUtil.Random(1,100);
   Console.WriteLine(randomNumber); 
}

J'avoue que j'aime mieux cette approche.


La question semble très simple mais la réponse est un peu compliquée. Si vous voyez presque tout le monde a suggéré d'utiliser la classe Random et certains ont suggéré d'utiliser la classe RNG crypto. Mais alors quand choisir quoi.

Pour cela, nous devons d'abord comprendre le terme RANDOMNESS et la philosophie qui le sous-tend.

Je vous encourage à regarder cette vidéo qui va en profondeur dans la philosophie de RANDOMNESS en utilisant C # https://www.youtube.com/watch?v=tCYxc-2-3fY

Première chose laissez-nous comprendre la philosophie de RANDOMNESS. Quand on dit à une personne de choisir entre ROUGE, VERT et JAUNE ce qui se passe en interne. Qu'est-ce qui fait qu'une personne choisit ROUGE ou JAUNE ou VERT?

Une première pensée va dans l'esprit des personnes qui décide de son choix, il peut être la couleur préférée, la couleur chanceuse et ainsi de suite. En d'autres termes, un déclencheur initial que nous appelons SEED dans RANDOM. Ce SEED est le point de départ, le déclencheur qui l'incite à sélectionner la valeur RANDOM.

Maintenant, si une SEED est facile à deviner, alors ces types de nombres aléatoires sont appelés PSEUDO et quand une graine est difficile à deviner, ces nombres aléatoires sont appelés des nombres aléatoires SECURED .

Par exemple, une personne choisit la couleur en fonction de la météo et de la combinaison sonore, alors il serait difficile de deviner la graine initiale.

Maintenant laissez-moi faire une déclaration importante: -

* La classe "Random" génère uniquement un nombre aléatoire PSEUDO et pour générer un nombre aléatoire SECURE, nous devons utiliser la classe "RNGCryptoServiceProvider".

La classe aléatoire prend des valeurs de départ de votre horloge CPU qui est très prévisible. Donc, en d'autres termes, la classe RANDOM de C # génère des nombres pseudo-aléatoires, ci-dessous est le code pour le même.

Random rnd= new Random();
int rndnumber = rnd.Next()

Alors que la classe RNGCryptoServiceProvider utilise l'entropie du système d'exploitation pour générer des graines. OS entropie est une valeur aléatoire qui est générée en utilisant le son, le clic de la souris et les timings du clavier, la température thermique, etc. Ci-dessous le code pour le même.

using (RNGCryptoServiceProvider rg = new RNGCryptoServiceProvider()) 
{ 
  byte[] rno = new byte[5];    
  rg.GetBytes(rno);    
  int randomvalue = BitConverter.ToInt32(rno, 0); 
}

Pour comprendre l'entropie du système d'exploitation, consultez cette vidéo https://www.youtube.com/watch?v=tCYxc-2-3fY partir de 11:20 où la logique de l'entropie du système d'exploitation est expliquée. Donc, en mettant des mots simples, RNG Crypto génère des nombres aléatoires SECURE.


Réponse modifiée d' here .

Si vous avez accès à un processeur compatible Intel Secure Key, vous pouvez générer des nombres aléatoires et des chaînes à l'aide de ces bibliothèques: https://github.com/JebteK/RdRand et https://www.rdrand.com/

Il suffit de télécharger la dernière version à partir d' here , d'inclure Jebtek.RdRand et d'ajouter une instruction using pour cela. Ensuite, tout ce que vous devez faire est ceci:

bool isAvailable = RdRandom.GeneratorAvailable(); //Check to see if this is a compatible CPU
string key = RdRandom.GenerateKey(10); //Generate 10 random characters
string apiKey = RdRandom.GenerateAPIKey(); //Generate 64 random characters, useful for API keys
byte[] b = RdRandom.GenerateBytes(10); //Generate an array of 10 random bytes
uint i = RdRandom.GenerateUnsignedInt() //Generate a random unsigned int

Si vous n'avez pas de CPU compatible pour exécuter le code, utilisez simplement les services RESTful sur rdrand.com. Avec la bibliothèque de wrappers RdRandom incluse dans votre projet, il vous suffit de le faire (vous recevez 1000 appels gratuits lors de votre inscription):

string ret = Randomizer.GenerateKey(<length>, "<key>");
uint ret = Randomizer.GenerateUInt("<key>");
byte[] ret = Randomizer.GenerateBytes(<length>, "<key>");

Vous pouvez utiliser la méthode StaticRandom Jon Skeet dans la bibliothèque de classes MiscUtil qu'il a créée pour un nombre pseudo-aléatoire.

using System;
using MiscUtil;

class Program
{
    static void Main(string[] args)
    {
        for (int i = 0; i < 100; i++)
        {
            Console.WriteLine(StaticRandom.Next());
        }
    }
}

Now in one-liner flavour.

private string RandomName
    {
        get
        {
            return new string(
                Enumerable.Repeat("ABCDEFGHIJKLMNOPQRSTUVWXYZ", 13)
                    .Select(s =>
                    {
                        var cryptoResult = new byte[4];
                        new RNGCryptoServiceProvider().GetBytes(cryptoResult);
                        return s[new Random(BitConverter.ToInt32(cryptoResult, 0)).Next(s.Length)];
                    })
                    .ToArray());
        }
    }




c# random