Generator liczb losowych generujący tylko jedną liczbę losową

Mam następującą funkcję:

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

Jak to nazywam:

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

Jeśli uruchomię tę pętlę za pomocą debugera podczas uruchamiania, otrzymam różne wartości (to jest to, czego chcę). Jeśli jednak umieszczę punkt przerwania dwie linie poniżej tego kodu, wszyscy członkowie mactablicy mają równą wartość.

Dlaczego tak się dzieje?

Za każdym razem new Random()jest to inicjowane przy użyciu zegara. Oznacza to, że w ciasnej pętli dostajesz tę samą wartość wiele razy. Powinieneś zachować pojedyncze Losowe wystąpienie i dalej używać Dalej w tym samym wystąpieniu.

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

Edytuj (patrz komentarze): dlaczego potrzebujemy locktutaj?

Zasadniczo Nextzamierza zmienić wewnętrzny stan Randominstancji. Jeśli zrobimy to w tym samym czasie z wielu wątków, to mógłby argumentować „my właśnie sprawiło, że jeszcze bardziej przypadkowy wynik”, ale co my właściwie robi potencjalnie zerwania wdrożenie wewnętrznego, a także moglibyśmy zacząć uzyskiwać te same numery z różnych wątków, co może być problemem - a może nie. Większe znaczenie ma jednak gwarancja tego, co dzieje się wewnętrznie; ponieważ Randomnie daje żadnych gwarancji bezpieczeństwa nici. Istnieją zatem dwa ważne podejścia:

• Zsynchronizuj, abyśmy nie mieli do niego dostępu w tym samym czasie z różnych wątków
• Używaj różnych Randominstancji na wątek

Oba mogą być w porządku; ale muteksowanie pojedynczej instancji od wielu rozmówców w tym samym czasie to po prostu prośba o kłopoty.

lockOsiąga pierwszy (i prostsze) tych metod; jednak innym podejściem może być:

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

jest to następnie dla wątku, więc nie trzeba synchronizować.

Aby ułatwić ponowne użycie w całej aplikacji, może pomóc klasa statyczna.

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

Następnie można użyć statycznej losowej instancji z kodem takim jak

StaticRandom.Instance.Next(1, 100);

Rozwiązanie Marka może być dość drogie, ponieważ wymaga synchronizacji za każdym razem.

Możemy ominąć potrzebę synchronizacji, stosując wzorzec przechowywania specyficzny dla wątku:

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

Zmierz obie implementacje i powinieneś zobaczyć znaczącą różnicę.

Moja odpowiedź stąd :

Powtarzam tylko właściwe rozwiązanie :

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

Możesz więc zadzwonić:

var i = Util.GetRandom();

wszystko poprzez.

Jeśli do generowania liczb losowych potrzebujesz bezwzględnej metody statycznej bezstanowej , możesz polegać na Guid.

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

To będzie odrobinę wolniejsze, ale może być znacznie bardziej przypadkowy niż Random.Next, przynajmniej z mojego doświadczenia.

Ale nie :

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

Niepotrzebne tworzenie obiektów spowoduje spowolnienie, szczególnie w pętli.

I nigdy :

new Random().Next();

Nie tylko jest wolniejszy (wewnątrz pętli), ale jego losowość jest ... cóż, według mnie niezbyt dobra ...

Wolę użyć następującej klasy do generowania liczb losowych:

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

1) Jak powiedział Marc Gravell, spróbuj użyć JEDNEGO generatora losowego. Zawsze fajnie jest dodać to do konstruktora: System.Environment.TickCount.

2) Jedna wskazówka. Załóżmy, że chcesz utworzyć 100 obiektów i załóżmy, że każdy z nich powinien mieć własny generator losowy (przydatny, jeśli obliczasz ŁADUNKI liczb losowych w bardzo krótkim czasie). Jeśli zrobiłbyś to w pętli (generowanie 100 obiektów), możesz to zrobić w ten sposób (aby zapewnić pełną losowość):

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

Twoje zdrowie.

Za każdym razem, gdy wykonujesz

Random random = new Random (15);

Nie ma znaczenia, czy wykonasz to miliony razy, zawsze użyjesz tego samego ziarna.

Jeśli użyjesz

Random random = new Random ();

Otrzymujesz inną sekwencję liczb losowych, jeśli haker zgadnie ziarno, a twój algorytm jest związany z bezpieczeństwem twojego systemu - twój algorytm jest zepsuty. Ja wykonujesz mult. W tym konstruktorze ziarno jest określane przez zegar systemowy i jeśli w bardzo krótkim czasie (milisekundach) utworzonych zostanie kilka instancji, możliwe jest, że mogą mieć to samo ziarno.

Jeśli potrzebujesz bezpiecznych liczb losowych, musisz skorzystać z klasy

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

Stosowanie:

int randomNumber = Next(1,100);

po prostu zadeklaruj zmienną klasy Losowej w następujący sposób:

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

jeśli chcesz uzyskać inną liczbę losową za każdym razem z listy, użyj

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

Za każdym razem, deklarując Random r = new Random()raz.

Istnieje wiele rozwiązań, tutaj jedno: jeśli chcesz tylko liczby, usuń litery, a metoda otrzyma losową i wynikową długość.

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