Generatore di numeri casuali che genera solo un numero casuale

Ho la seguente funzione:

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

Come lo chiamo:

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

Se passo quel ciclo con il debugger durante il runtime ottengo valori diversi (che è quello che voglio). Tuttavia, se inserisco un punto di interruzione due righe sotto quel codice, tutti i membri macdell'array hanno lo stesso valore.

Perché succede?

Ogni volta che lo fai new Random()viene inizializzato usando l'orologio. Ciò significa che in un ciclo stretto si ottiene lo stesso valore molte volte. Dovresti conservare una singola istanza casuale e continuare a usare Next nella stessa istanza.

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

Modifica (vedi commenti): perché abbiamo bisogno di un lockqui?

Fondamentalmente, Nextcambierà lo stato interno Randomdell'istanza. Se lo facciamo allo stesso tempo da più thread, si potrebbe obiettare: "Abbiamo appena fatto il risultato ancora più casuale", ma quello che stiamo effettivamente facendo è potenzialmente rompendo l'implementazione interna, e potremmo anche iniziare a ricevere gli stessi numeri da thread diversi, che potrebbe essere un problema - e potrebbe non esserlo. La garanzia di ciò che accade internamente è il problema più grande, però; poiché Randomfa non fornire alcuna garanzia di filo di sicurezza. Quindi ci sono due approcci validi:

• Sincronizza in modo da non accedervi contemporaneamente da thread diversi
• Usa Randomistanze diverse per thread

Entrambi possono andare bene; ma il silenziamento di una singola istanza da più chiamanti contemporaneamente richiede solo problemi.

Il lockraggiunge la prima (e più semplice) di questi approcci; tuttavia, un altro approccio potrebbe essere:

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

questo è quindi per thread, quindi non è necessario sincronizzare.

Per facilitare il riutilizzo in tutta l'applicazione, può essere utile una classe statica.

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

È possibile utilizzare quindi utilizzare un'istanza casuale statica con codice come

StaticRandom.Instance.Next(1, 100);

La soluzione di Mark può essere piuttosto costosa poiché deve essere sincronizzata ogni volta.

Possiamo ovviare alla necessità di sincronizzazione utilizzando il modello di archiviazione specifico del 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);
    }
}

Misura le due implementazioni e dovresti vedere una differenza significativa.

La mia risposta da qui :

Ribadendo la soluzione giusta :

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

Quindi puoi chiamare:

var i = Util.GetRandom();

tutto dappertutto.

Se è strettamente necessario un metodo statico stateless vero per generare numeri casuali, è possibile fare affidamento su a Guid.

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

Sarà un po 'più lento, ma può essere molto più casuale di Random.Next, almeno dalla mia esperienza.

Ma non :

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

La creazione di oggetti non necessari lo renderà più lento, specialmente in un ciclo.

E mai :

new Random().Next();

Non solo è più lento (all'interno di un loop), la sua casualità è ... beh non è davvero buona secondo me ..

Preferirei usare la seguente classe per generare numeri casuali:

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

1) Come diceva Marc Gravell, prova a usare UN generatore casuale. È sempre bello aggiungere questo al costruttore: System.Environment.TickCount.

2) Un consiglio. Supponiamo che tu voglia creare 100 oggetti e supponiamo che ognuno di essi debba avere il proprio generatore casuale (utile se si calcolano CARICHI di numeri casuali in un periodo di tempo molto breve). Se lo facessi in un ciclo (generazione di 100 oggetti), potresti farlo in questo modo (per assicurare la totale casualità):

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

Saluti.

Ogni volta che esegui

Random random = new Random (15);

Non importa se lo esegui milioni di volte, utilizzerai sempre lo stesso seme.

Se usi

Random random = new Random ();

Ottieni una sequenza numerica diversa, se un hacker indovina il seme e il tuo algoritmo è legato alla sicurezza del tuo sistema: l'algoritmo è rotto. Io esegui mult. In questo costruttore il seme viene specificato dall'orologio di sistema e se vengono create più istanze in un periodo di tempo molto breve (millisecondi), è possibile che possano avere lo stesso seme.

Se hai bisogno di numeri casuali sicuri devi usare 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);
}

Uso:

int randomNumber = Next(1,100);

dichiarare la variabile di classe casuale in questo modo:

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

se si desidera ottenere un numero casuale diverso ogni volta dall'elenco, utilizzare

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

Ogni volta dichiarando Random r = new Random()una volta.

Ci sono molte soluzioni, qui una: se vuoi solo un numero cancella le lettere e il metodo riceve una lunghezza casuale e il risultato.

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