[c#] Comment générer un nombre entier aléatoire en C #?


Answers

Chaque fois que vous faites un nouveau Random (), il est initialisé. Cela signifie que dans une boucle serrée vous obtenez la même valeur beaucoup de fois. Vous devriez garder une seule instance aléatoire et continuer à utiliser Next sur la même instance.

//Function to get random number
private static readonly Random getrandom = new Random();

public static int GetRandomNumber(int min, int max)
{
    lock(getrandom) // synchronize
    {
        return getrandom.Next(min, max);
    }
}
Question

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




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



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



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



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

créer une fonction

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

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

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

0 est min et 999 est max. Vous pouvez changer les valeurs à tout ce que vous voulez.

Vérifiez également la réponse sur cette page .

( http://solutions.musanitech.com/c-how-to-create-random-numbers/ )




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>");



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



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



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.




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



Je voulais ajouter une version cryptographiquement sécurisée:

Classe RNGCryptoServiceProvider ( MSDN ou dotnetperls )

Il implémente IDisposable.

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



Related



Tags

c# c#   random