Zufallszahlengenerator, der nur eine Zufallszahl generiert

Ich habe folgende Funktion:

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

Wie ich es nenne:

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

Wenn ich diese Schleife zur Laufzeit mit dem Debugger mache, erhalte ich unterschiedliche Werte (was ich will). Wenn ich jedoch einen Haltepunkt zwei Zeilen unter diesen Code setze, haben alle Mitglieder des macArrays den gleichen Wert.

Warum passiert das?

Jedes Mal, wenn Sie dies tun, wird new Random()es mit der Uhr initialisiert. Dies bedeutet, dass Sie in einer engen Schleife oft den gleichen Wert erhalten. Sie sollten eine einzelne Zufallsinstanz beibehalten und Next auf derselben Instanz verwenden.

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

Bearbeiten (siehe Kommentare): Warum brauchen wir lockhier ein?

Grundsätzlich Nextwird sich der interne Status der RandomInstanz ändern . Wenn wir dies gleichzeitig aus mehreren Threads heraus tun, könnten Sie argumentieren, "wir haben das Ergebnis nur noch zufälliger gemacht", aber was wir tatsächlich tun, ist möglicherweise, die interne Implementierung zu brechen, und wir könnten auch anfangen, die gleichen Zahlen zu erhalten von verschiedenen Threads, die möglicherweise ein Problem sein - und vielleicht nicht. Die Garantie dafür, was intern passiert, ist jedoch das größere Problem. da Randomsich nicht machen keine Garantien für Thread-Sicherheit. Somit gibt es zwei gültige Ansätze:

• Synchronisieren Sie, damit wir nicht gleichzeitig von verschiedenen Threads darauf zugreifen
• Verwenden Sie unterschiedliche RandomInstanzen pro Thread

Beides kann in Ordnung sein; Das Stummschalten einer einzelnen Instanz von mehreren Anrufern gleichzeitig ist jedoch nur ein Problem .

Das lockerreicht den ersten (und einfacheren) dieser Ansätze; Ein anderer Ansatz könnte jedoch sein:

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

Dies ist dann pro Thread, sodass Sie nicht synchronisieren müssen.

Zur Erleichterung der Wiederverwendung in Ihrer gesamten Anwendung kann eine statische Klasse hilfreich sein.

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

Sie können dann eine statische Zufallsinstanz mit Code wie verwenden

StaticRandom.Instance.Next(1, 100);

Marks Lösung kann sehr teuer sein, da sie jedes Mal synchronisiert werden muss.

Mithilfe des threadspezifischen Speichermusters können wir die Notwendigkeit einer Synchronisierung umgehen:

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

Messen Sie die beiden Implementierungen und Sie sollten einen signifikanten Unterschied sehen.

Meine Antwort von hier :

Wiederholen Sie einfach die richtige Lösung :

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

So können Sie anrufen:

var i = Util.GetRandom();

alle den ganzen.

Wenn Sie unbedingt eine echte zustandslose statische Methode benötigen , um Zufallszahlen zu generieren, können Sie sich auf a verlassen Guid.

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

Es wird ein bisschen langsamer sein, kann aber viel zufälliger sein als Random.Next, zumindest aus meiner Erfahrung.

Aber nicht :

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

Die unnötige Objekterstellung wird es insbesondere unter einer Schleife langsamer machen.

Und niemals :

new Random().Next();

Es ist nicht nur langsamer (innerhalb einer Schleife), seine Zufälligkeit ist ... nun, meiner Meinung nach nicht wirklich gut.

Ich würde lieber die folgende Klasse verwenden, um Zufallszahlen zu generieren:

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

1) Versuchen Sie, wie Marc Gravell sagte, EINEN Zufallsgenerator zu verwenden. Es ist immer cool, dies dem Konstruktor hinzuzufügen: System.Environment.TickCount.

2) Ein Tipp. Angenommen, Sie möchten 100 Objekte erstellen und annehmen, dass jedes einen eigenen Zufallsgenerator haben sollte (praktisch, wenn Sie in sehr kurzer Zeit LADUNGEN von Zufallszahlen berechnen). Wenn Sie dies in einer Schleife tun würden (Generierung von 100 Objekten), könnten Sie dies folgendermaßen tun (um die vollständige Zufälligkeit sicherzustellen):

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

Prost.

Jedes Mal, wenn Sie ausführen

Random random = new Random (15);

Es spielt keine Rolle, ob Sie es millionenfach ausführen, Sie werden immer den gleichen Startwert verwenden.

Wenn du benutzt

Random random = new Random ();

Sie erhalten eine andere Zufallszahlenfolge, wenn ein Hacker den Startwert errät und Ihr Algorithmus mit der Sicherheit Ihres Systems zusammenhängt - Ihr Algorithmus ist fehlerhaft. Ich Sie führen mult. In diesem Konstruktor wird der Startwert von der Systemuhr angegeben. Wenn mehrere Instanzen in einem sehr kurzen Zeitraum (Millisekunden) erstellt werden, ist es möglich, dass sie denselben Startwert haben.

Wenn Sie sichere Zufallszahlen benötigen, müssen Sie die Klasse verwenden

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

Verwendungszweck:

int randomNumber = Next(1,100);

Deklarieren Sie einfach die Random-Klassenvariable wie folgt:

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

Wenn Sie jedes Mal eine andere Zufallszahl aus Ihrer Liste erhalten möchten, verwenden Sie

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

Jedes Mal durch Random r = new Random()einmalige Deklaration .

Es gibt viele Lösungen, hier eine: Wenn Sie nur Zahlen möchten, löschen Sie die Buchstaben und die Methode erhält eine zufällige und die Ergebnislänge.

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