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





tirage tableau (19)


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)

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




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



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



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




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



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



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.




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.




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



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.




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




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




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



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)




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



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



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



Si vous voulez utiliser numpy, utilisez ce qui suit:

import numpy as np
print(np.random.randint(0,10))






c# random