Comment puis-je générer un random int nombre?

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

Pour cela nous avons besoin de comprendre d'abord le terme de l'ALÉATOIRE et de la philosophie qui est derrière.

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

Première chose que nous devons comprendre la philosophie de l'ALÉATOIRE. Quand nous disons d'une personne à choisir entre le ROUGE, le VERT et le JAUNE ce qui se passe en interne. Ce qui rend une personne de choisir le ROUGE ou le JAUNE ou le VERT?

Une première pensée va dans le personnes d'esprit qui décide de son choix, il peut être de couleur préférée , la chance couleur et ainsi de suite. En d'autres mots, certains de déclenchement initial qui nous terme ALÉATOIRE en tant que SEMENCES.Cette GRAINE est le point de départ, l'élément déclencheur qui lui provoque pour sélectionner la valeur ALÉATOIRE.

Maintenant, si une GRAINE est facile de deviner alors ce genre de nombres aléatoires sont désignées comme des PSEUDO et quand une graine est difficile à deviner ces nombres aléatoires sont appelés SÉCURISÉ nombres aléatoires.

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

Maintenant, permettez-moi de faire une déclaration importante:-

*“Aléatoire” de la classe ne génère que de nombre PSEUDO-aléatoire, et pour générer des nombres aléatoires avec sécurité, nous devons utiliser “RNGCryptoServiceProvider” de la classe.

Aléatoire de la classe prend les valeurs de départ de votre horloge du CPU qui est très prévisible. Donc, en d'autres mots ALÉATOIRES classe de C# génère pseudo-aléatoire de nombres , ci-dessous est le code pour le même.

**Note: ** .NET Core 2.0.0+ utilise une autre semence sur le constructeur sans paramètre: la place de l'horloge du PROCESSEUR, il utilise Guid.NewGuid().GetHashCode().

var random = new Random();
int randomnumber = random.Next()

Tandis que le RNGCryptoServiceProvider classe utilise l'OS de l'entropie à générer des graines. OS entropie est une valeur aléatoire qui est généré en utilisant le son, clic de souris, de clavier et de timings, thermique temp etc. Ci-dessous est 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); 
}

À comprendre OS entropie voir cette vidéo à partir de 14:30 https://www.youtube.com/watch?v=tCYxc-2-3fY où la logique de l'OS de l'entropie est expliqué. Afin de mettre en mots simples RNG Crypto génère SÉCURISÉ nombres aléatoires.

Attention, new Random() est ensemencée sur le timestamp actuel.

Si vous voulez générer des juste un numéro vous pouvez utiliser:

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

Pour plus d'informations, regardez la Aléatoire classe, mais s'il vous plaît note:

Cependant, parce que le temps a fini de résolution, en utilisant le constructeur sans paramètre de créer différents objets au Hasard dans la succession à proximité crée des générateurs de nombres aléatoires que de réaliser des séquences de nombres aléatoires

Afin de ne pas utiliser ce code pour générer une série de nombre aléatoire.

Je voulais ajouter un cryptographique sécurisé version:

RNGCryptoServiceProvider Classe (MSDN ou dotnetperls)

Il met en œuvre IDisposable.

using (RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider())
{
   byte[] randomNumber = new byte[4];//4 for int32
   rng.GetBytes(randomNumber);
   int value = BitConverter.ToInt32(randomNumber, 0);
}

il est préférable de semer l'objet d'Aléatoire avec courant millisecondes, afin de garantir le véritable nombre aléatoire, et vous êtes presque sur de ne pas rechercher les doublons utiliser à de nombreuses reprises

Random rand = new Random(DateTime.Now.Millisecond);

Mise à jour

Je sais que new Random() utilise le courant tiques comme les semences, mais les semis avec courant millisecondes est encore assez bon comme c'est un bon début aléatoire

Le dernier point est que vous n'avez pas à initialiser new Random() chaque fois que vous avez besoin d'un nombre aléatoire, lancer un objet au Hasard, puis l'utiliser autant de fois que vous avez besoin à l'intérieur d'une boucle ou quoi que

Modifié réponse de ici.

Si vous avez accès à un processeur Intel Secure Key PROCESSEUR compatible, vous pouvez générer de vrais nombres aléatoires et les chaînes de caractères à 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 de ici, comprennent Jebtek.RdRand et les ajouter à l'aide d'instruction pour elle. Ensuite, tout ce que vous devez faire est ceci:

//Check to see if this is a compatible CPU
bool isAvailable = RdRandom.GeneratorAvailable();

//Generate 10 random characters
string key       = RdRandom.GenerateKey(10);

 //Generate 64 random characters, useful for API keys 
string apiKey    = RdRandom.GenerateAPIKey();

//Generate an array of 10 random bytes
byte[] b         = RdRandom.GenerateBytes(10);

//Generate a random unsigned int
uint i           = RdRandom.GenerateUnsignedInt();

Si vous n'avez pas un CPU compatible pour exécuter le code, il suffit d'utiliser les services RESTful à rdrand.com. Avec le RdRandom bibliothèque d'encapsulation inclus dans votre projet, vous n'avez qu'à le faire (vous obtenez 1000 appels gratuits lorsque vous vous inscrivez):

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

Je utiliser 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);

Alors que ce n'est pas grave:

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

Vous voulez le contrôle de la limite (min et max mumbers) la plupart du temps. Donc, vous devez spécifier où le nombre aléatoire commence et se termine.

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

Donc, si je veux que mon nombre aléatoire entre 5 et 15 ans, je venais de faire

int randomNumber = random.Next(5, 16)

Pour fort aléatoire, j'ai toujours utiliser CryptoRNG et pas de Temps.

using System;
using System.Security.Cryptography;

public class Program
{
    public static void Main()
    {
        var random = new Random(GetSeed());
        Console.WriteLine(random.Next());
    }

    public static int GetSeed() 
    {
        using (var rng = new RNGCryptoServiceProvider())
        {
            var intBytes = new byte[4];
            rng.GetBytes(intBytes);
            return BitConverter.ToInt32(intBytes, 0);
        }
    }
}

Je voulais montrer ce qui se passe quand un nouveau générateur aléatoire est utilisé à chaque fois. Supposons que vous avez deux méthodes ou deux classes, chacun nécessitant un nombre aléatoire. Et naïvement, vous code 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, vous obtiendrez deux Identifiants 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 est de toujours utiliser un seul statique générateur aléatoire. Comme ceci:

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; }
}

Le code suivant renvoie un nombre aléatoire. 

int num = random.Next(); 

Le code suivant renvoie un nombre aléatoire inférieur à 1000. 

int num = random.Next(1000);

Le code suivant renvoie un nombre aléatoire entre le min et le max de la gamme.

Générer  random la entre les deux chiffres:

public int RandomNumber(int min, int max)  

 { 

     

Random random = new Random(); 

return random.Next(min, max);  

}

  

Je suppose que vous souhaitez distribuées uniformément générateur de nombre aléatoire comme ci-dessous. Nombre aléatoire dans la plupart des langages de programmation, notamment en C# et C++ n'est pas bien mélangé avant de les utiliser. Cela signifie que vous obtiendrez le même nombre, ce qui n'est pas vraiment aléatoire. Pour éviter de dessiner le même nombre, vous avez besoin d'une graine. Généralement, les tiques dans le temps est ok pour cette tâche. N'oubliez pas que vous obtiendrez le même nombre si vous utilisez le même semences à chaque fois. Donc, essayez d'utiliser les diverses graines de toujours. Le temps est une bonne source pour les semences parce qu'ils chage toujours.

int GetRandomNumber(int min, int max)
{
    Random rand = new Random((int)DateTime.Now.Ticks);
    return rand.Next(min, max);
}

si vous êtes à la recherche pour le générateur de nombres aléatoires de distribution normale, vous pouvez utiliser un de Box-Muller transformation. Vérifiez la réponse par yoyoyoyosef Aléatoire Gaussienne de la Variable Concernée. Puisque vous voulez entier, vous avez à jeter le double de la valeur de nombre entier à la fin.

Random rand = new Random(); //reuse this if you are generating many
double u1 = 1.0-rand.NextDouble(); //uniform(0,1] random doubles
double u2 = 1.0-rand.NextDouble();
double randStdNormal = Math.Sqrt(-2.0 * Math.Log(u1)) *
         Math.Sin(2.0 * Math.PI * u2); //random normal(0,1)
double randNormal =
         mean + stdDev * randStdNormal; //random normal(mean,stdDev^2)

Aléatoire Gaussien Variables

Vous pouvez essayer avec la valeur de départ aléatoire à l'aide ci-dessous:

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

string randomDigits = rnd.Next();

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

Si vous voulez un CSRNG pour générer des nombres aléatoires entre un min et max, c'est pour vous. Il va initialiser Random classes sécurisé des germes aléatoires.

    class SecureRandom : Random
{
public static byte[] GetBytes(ulong length)
{
RNGCryptoServiceProvider RNG = new RNGCryptoServiceProvider();
byte[] bytes = new byte[length];
RNG.GetBytes(bytes);
RNG.Dispose();
return bytes;
}
public SecureRandom() : base(BitConverter.ToInt32(GetBytes(4), 0))
{
}
public int GetRandomInt(int min, int max)
{
int treashold = max - min;
if(treashold != Math.Abs(treashold))
{
throw new ArithmeticException("The minimum value can't exceed the maximum value!");
}
if (treashold == 0)
{
throw new ArithmeticException("The minimum value can't be the same as the maximum value!");
}
return min + (Next() % treashold);
}
public static int GetRandomIntStatic(int min, int max)
{
int treashold = max - min;
if (treashold != Math.Abs(treashold))
{
throw new ArithmeticException("The minimum value can't exceed the maximum value!");
}
if(treashold == 0)
{
throw new ArithmeticException("The minimum value can't be the same as the maximum value!");
}
return min + (BitConverter.ToInt32(GetBytes(4), 0) % treashold);
}
}

Essayez ces étapes simples pour créer des nombres aléatoires:

Créer de la fonction:

private int randomnumber(int min, int max)
{
Random rnum = new Random();
return rnum.Next(min, max);
}

Utiliser la fonction ci-dessus dans un emplacement où vous souhaitez utiliser des nombres aléatoires. Supposons que vous voulez l'utiliser dans une zone de texte.

textBox1.Text = randomnumber(0, 999).ToString();

0 min et 999 est de max. Vous pouvez modifier les valeurs de ce que vous voulez.

Utiliser une instance de manière Aléatoire à plusieurs reprises

//Somewhat better code...
Random rng = new Random();
for (int i = 0; i < 100; i++)
{
Console.WriteLine(GenerateDigit(rng));
}
...
static int GenerateDigit(Random rng)
{
//Assume there'd be more logic here really
return rng.Next(10);
}

Cet article jette un coup d'oeil à pourquoi aléatoire provoque beaucoup de problèmes, et la façon de les aborder.
http://csharpindepth.com/Articles/Chapter12/Random.aspx

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

Vous pouvez aussi donner de la valeur minimale et maximale pour Next() fonction. Comme:

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