Générateur de nombres aléatoires ne générant qu'un seul nombre aléatoire

J'ai la fonction suivante:

//Function to get random number
public static int RandomNumber(int min, int max)
{
    Random random = new Random();
    return random.Next(min, max);
}

Comment je l'appelle:

byte[] mac = new byte[6];
for (int x = 0; x < 6; ++x)
    mac[x] = (byte)(Misc.RandomNumber((int)0xFFFF, (int)0xFFFFFF) % 256);

Si j'étape cette boucle avec le débogueur pendant l'exécution, j'obtiens des valeurs différentes (ce que je veux). Cependant, si je mets un point d'arrêt deux lignes en dessous de ce code, tous les membres du mactableau ont la même valeur.

Pourquoi cela se produit-il?

Chaque fois que vous le faites, new Random()il est initialisé à l'aide de l'horloge. Cela signifie que dans une boucle serrée, vous obtenez souvent la même valeur. Vous devez conserver une seule instance aléatoire et continuer à utiliser Next sur la même instance.

//Function to get a random number 
private static readonly Random random = new Random(); 
private static readonly object syncLock = new object(); 
public static int RandomNumber(int min, int max)
{
    lock(syncLock) { // synchronize
        return random.Next(min, max);
    }
}

Edit (voir commentaires): pourquoi avons-nous besoin d'un lockici?

Fondamentalement, Nextva changer l'état interne de l' Randominstance. Si nous le faisons en même temps à partir de plusieurs threads, vous pourriez dire "nous venons de rendre le résultat encore plus aléatoire", mais ce que nous faisons en fait est potentiellement de casser l'implémentation interne, et nous pourrions également commencer à obtenir les mêmes chiffres à partir de différents threads, ce qui pourrait être un problème - et peut-être pas. La garantie de ce qui se passe en interne est le plus gros problème, cependant; car Randomne pas faire aucune garantie de fil de sécurité. Il existe donc deux approches valides:

• Synchronisez afin de ne pas y accéder en même temps à partir de différents threads
• Utiliser différentes Randominstances par thread

Soit peut être bien; mais mutexer une seule instance de plusieurs appelants en même temps ne fait que demander des ennuis.

Le lockréalise la première (et la plus simple) de ces approches; cependant, une autre approche pourrait être:

private static readonly ThreadLocal<Random> appRandom
     = new ThreadLocal<Random>(() => new Random());

c'est alors par thread, vous n'avez donc pas besoin de synchroniser.

Pour faciliter la réutilisation dans toute votre application, une classe statique peut vous aider.

public static class StaticRandom
{
    private static int seed;

    private static ThreadLocal<Random> threadLocal = new ThreadLocal<Random>
        (() => new Random(Interlocked.Increment(ref seed)));

    static StaticRandom()
    {
        seed = Environment.TickCount;
    }

    public static Random Instance { get { return threadLocal.Value; } }
}

Vous pouvez utiliser puis utiliser une instance aléatoire statique avec du code tel que

StaticRandom.Instance.Next(1, 100);

La solution de Mark peut être assez coûteuse car elle doit être synchronisée à chaque fois.

Nous pouvons contourner le besoin de synchronisation en utilisant le modèle de stockage spécifique au thread:

public class RandomNumber : IRandomNumber
{
    private static readonly Random Global = new Random();
    [ThreadStatic] private static Random _local;

    public int Next(int max)
    {
        var localBuffer = _local;
        if (localBuffer == null) 
        {
            int seed;
            lock(Global) seed = Global.Next();
            localBuffer = new Random(seed);
            _local = localBuffer;
        }
        return localBuffer.Next(max);
    }
}

Mesurez les deux implémentations et vous devriez voir une différence significative.

Ma réponse d' ici :

Réitérant simplement la bonne solution :

namespace mySpace
{
    public static class Util
    {
        private static rnd = new Random();
        public static int GetRandom()
        {
            return rnd.Next();
        }
    }
}

Vous pouvez donc appeler:

var i = Util.GetRandom();

tout au long de.

Si vous avez strictement besoin d'une véritable méthode statique sans état pour générer des nombres aléatoires, vous pouvez vous fier à a Guid.

public static class Util
{
    public static int GetRandom()
    {
        return Guid.NewGuid().GetHashCode();
    }
}

Ça va être un peu plus lent, mais peut être beaucoup plus aléatoire que Random.Next, du moins d'après mon expérience.

Mais pas :

new Random(Guid.NewGuid().GetHashCode()).Next();

La création inutile d'objets va le ralentir, surtout sous une boucle.

Et jamais :

new Random().Next();

Non seulement c'est plus lent (à l'intérieur d'une boucle), son caractère aléatoire est ... enfin pas vraiment bon selon moi ..

Je préfère utiliser la classe suivante pour générer des nombres aléatoires:

byte[] random;
System.Security.Cryptography.RNGCryptoServiceProvider prov = new System.Security.Cryptography.RNGCryptoServiceProvider();
prov.GetBytes(random);

1) Comme l'a dit Marc Gravell, essayez d'utiliser UN générateur aléatoire. C'est toujours cool d'ajouter cela au constructeur: System.Environment.TickCount.

2) Un conseil. Supposons que vous vouliez créer 100 objets et supposons que chacun d'eux ait son propre générateur aléatoire (pratique si vous calculez les CHARGES de nombres aléatoires en très peu de temps). Si vous le faisiez en boucle (génération de 100 objets), vous pourriez faire ça comme ça (pour assurer un caractère totalement aléatoire):

int inMyRandSeed;

for(int i=0;i<100;i++)
{
   inMyRandSeed = System.Environment.TickCount + i;
   .
   .
   .
   myNewObject = new MyNewObject(inMyRandSeed);  
   .
   .
   .
}

// Usage: Random m_rndGen = new Random(inMyRandSeed);

À votre santé.

Chaque fois que vous exécutez

Random random = new Random (15);

Peu importe que vous l'exécutiez des millions de fois, vous utiliserez toujours la même graine.

Si tu utilises

Random random = new Random ();

Vous obtenez une séquence de nombres aléatoires différente, si un pirate devine la graine et que votre algorithme est lié à la sécurité de votre système - votre algorithme est cassé. Si vous exécutez mult. Dans ce constructeur, la graine est spécifiée par l'horloge système et si plusieurs instances sont créées en très peu de temps (millisecondes), il est possible qu'elles aient la même graine.

Si vous avez besoin de nombres aléatoires sûrs, vous devez utiliser la classe

System.Security.Cryptography.RNGCryptoServiceProvider

public static int Next(int min, int max)
{
    if(min >= max)
    {
        throw new ArgumentException("Min value is greater or equals than Max value.");
    }
    byte[] intBytes = new byte[4];
    using(RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider())
    {
        rng.GetNonZeroBytes(intBytes);
    }
    return  min +  Math.Abs(BitConverter.ToInt32(intBytes, 0)) % (max - min + 1);
}

Usage:

int randomNumber = Next(1,100);

déclarez simplement la variable de classe aléatoire comme ceci:

    Random r = new Random();
    // ... Get three random numbers.
    //     Here you'll get numbers from 5 to 9
    Console.WriteLine(r.Next(5, 10));

si vous voulez obtenir un nombre aléatoire différent à chaque fois dans votre liste, utilisez

r.Next(StartPoint,EndPoint) //Here end point will not be included

Chaque fois en déclarant Random r = new Random()une fois.

Il y a beaucoup de solutions, en voici une: si vous voulez seulement effacer les lettres et que la méthode reçoit un aléatoire et la longueur du résultat.

public String GenerateRandom(Random oRandom, int iLongitudPin)
{
    String sCharacters = "123456789ABCDEFGHIJKLMNPQRSTUVWXYZ123456789";
    int iLength = sCharacters.Length;
    char cCharacter;
    int iLongitudNuevaCadena = iLongitudPin; 
    String sRandomResult = "";
    for (int i = 0; i < iLongitudNuevaCadena; i++)
    {
        cCharacter = sCharacters[oRandom.Next(iLength)];
        sRandomResult += cCharacter.ToString();
    }
    return (sRandomResult);
}