Come posso generare un numero int casuale?


1922

Come posso generare un numero intero casuale in C #?

Risposte:


2503

La Randomclasse viene utilizzata per creare numeri casuali. (Pseudo-casuale che è ovviamente.).

Esempio:

Random rnd = new Random();
int month  = rnd.Next(1, 13);  // creates a number between 1 and 12
int dice   = rnd.Next(1, 7);   // creates a number between 1 and 6
int card   = rnd.Next(52);     // creates a number between 0 and 51

Se hai intenzione di creare più di un numero casuale, dovresti conservare l' Randomistanza e riutilizzarla. Se si creano nuove istanze troppo vicine nel tempo, produrranno la stessa serie di numeri casuali del generatore casuale generato dall'orologio di sistema.


184
Solo una nota per gli utenti di Unity C #, è necessario specificare "System.Random ()" poiché Unity ha un "UnityEngine.Random ()" che si scontra (si noti che "UnityEngine.Random ()" non ha la possibilità di generare casuali numeri). Poiché l'unità non importa sempre il Sistema per impostazione predefinita, ciò può causare confusione.
Joehot200

2
Per riutilizzarlo, è possibile dichiararlo rndcome statice / o impostarlo una sola volta durante l'inizializzazione del codice.
Junior Mayhé,

4
@JuniorM: Sì, puoi renderlo statico per riutilizzarlo, ma devi fare attenzione in modo da non accedervi da più thread in quanto non è thread-safe (come al solito per qualsiasi classe che non è specificatamente resa thread-safe ).
Guffa,

9
Penso che sarebbe utile aggiungere un disclaimer sul fatto che questo non è crittograficamente sicuro, poiché questa è una domanda popolare, nel caso in cui qualcuno cerchi ciecamente di fare la crittografia con Random...
Daniel García Rubio,

1
Risposta eccellente. Ci sono alcuni "miglioramenti" utili per Randomrendere la tua casualità più solida: ericlippert.com/2019/02/04/fixing-random-part-2 e codeblog.jonskeet.uk/2009/11/04/revisiting casualità .
Jesse C. Slicer,

280

La domanda sembra molto semplice ma la risposta è un po 'complicata. Se vedi quasi tutti hanno suggerito di usare la classe Random e alcuni hanno suggerito di usare la classe crypto RNG. Ma poi quando scegliere cosa.

Per questo dobbiamo prima capire il termine RANDOMNESS e la filosofia che sta dietro.

Ti incoraggio a guardare questo video che approfondisce la filosofia di RANDOMNESS usando C # https://www.youtube.com/watch?v=tCYxc-2-3fY

Per prima cosa cerchiamo di capire la filosofia della RANDOMNESS. Quando diciamo a una persona di scegliere tra ROSSO, VERDE e GIALLO cosa succede internamente. Cosa fa scegliere una persona ROSSO, GIALLO o VERDE?

c # Casuale

Qualche pensiero iniziale va nella mente delle persone che decide la sua scelta, può essere il colore preferito, il colore fortunato e così via. In altre parole, un trigger iniziale che definiamo RANDOM come SEED. Questo SEED è il punto di partenza, il trigger che lo spinge a selezionare il valore RANDOM.

Ora, se un SEME è facile da indovinare, allora quel tipo di numeri casuali è definito come PSEUDO e quando un seme è difficile da indovinare quei numeri casuali sono chiamati numeri casuali SICURI .

Ad esempio, una persona sceglie il colore in base al tempo e alla combinazione di suoni, quindi sarebbe difficile indovinare il seme iniziale.

c # Casuale

Ora lasciami fare una dichiarazione importante: -

* La classe "Random" genera solo numeri casuali PSEUDO e per generare un numero casuale SICURO è necessario utilizzare la classe "RNGCryptoServiceProvider".

c # Casuale

La classe casuale prende i valori di seed dal clock della CPU che è molto prevedibile. Quindi in altre parole la classe RANDOM di C # genera numeri pseudo casuali, di seguito è riportato il codice per lo stesso.

** Nota: ** .NET Core 2.0.0+utilizza un seme diverso sul costruttore senza parametri: al posto del clock della CPU utilizza Guid.NewGuid().GetHashCode().

var random = new Random();
int randomnumber = random.Next()

Mentre la RNGCryptoServiceProviderclasse utilizza l'entropia del sistema operativo per generare seed. L'entropia del sistema operativo è un valore casuale che viene generato utilizzando il suono, il clic del mouse, i tempi della tastiera, la temperatura termica, ecc. Di seguito viene riportato il codice per lo stesso.

using (RNGCryptoServiceProvider rg = new RNGCryptoServiceProvider()) 
{ 
    byte[] rno = new byte[5];    
    rg.GetBytes(rno);    
    int randomvalue = BitConverter.ToInt32(rno, 0); 
}

Per comprendere l'entropia del sistema operativo vedere questo video dalle 14:30 https://www.youtube.com/watch?v=tCYxc-2-3fY in cui viene spiegata la logica dell'entropia del sistema operativo. Quindi, mettendo in parole semplici RNG Crypto genera numeri casuali SICURI.


9
non dovrebbe essere il tuo byte [5] solo [4] poiché ToInt32 analizza solo 4 byte?
Bernhard,

6
È sempre utile sapere dove vivono queste lezioni. System.Security.Cryptography
Elton,

1
Si consiglia di utilizzare RandomNumberGenerator.Create()invece di chiamare il costruttore di RNGCryptoServiceProviderpoiché non è disponibile su tutte le piattaforme.
dzitkowskik,

Voglio solo precisare che la generazione pseudo casuale di SecureRandom IS.
Nùménor

A causa della maggiore casualità del seme, è OK creare nuovi oggetti RNGCryptoServiceProvider ogni volta che devo generare un numero casuale, oppure è ancora meglio creare un oggetto RNGCryptoServiceProvider e riutilizzarlo ogni volta che devo generare un numero casuale, come dovrebbe essere fatto con la classe casuale?
user2150989

231

Ogni volta che fai nuovo Random () viene inizializzato. 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 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);
    }
}

3
Non è quello che ha detto @Guffa nella sua risposta 6 mesi fa? "Se crei nuove istanze troppo vicine nel tempo, produrranno la stessa serie di numeri casuali"
Chris

3
@ Chris- È proprio quello che hai detto. In questo ho fornito la realizzazione di quello. Penso che sia un buon modo di farlo. Funziona meglio
Pankaj Mishra,

22
Questa è un'implementazione che sincronizza il codice per l'uso dai thread seval. Questo è utile per un'applicazione multi-thread, ma è una perdita di tempo per una singola applicazione thread.
Guffa,

@SeanWorle: in primo luogo, l'ho provato con l'approccio di Guffa. Quindi ho provato a memorizzare lo stesso Randomoggetto. In entrambi i casi ho ottenuto lo stesso numero casuale. Con l'approccio di Pankaj non è successo. Forse è casuale , ma ora ne dubito. Sto chiedendo il numero casuale nello stesso secondo da thread diversi.
test del

1
@test: sono d'accordo che il metodo di Pankaj è quello corretto da usare. Quello che sto dicendo è che può essere semplificato a questo: // Funzione per ottenere un numero casuale privato statico in sola lettura Random getrandom = new Random (); public static int GetRandomNumber (int min, int max) {lock (getrandom) {// sincronizza return getrandom.Next (min, max); }}
Sean Worle,

92

Attenzione che new Random()viene trasmesso sul timestamp corrente.

Se vuoi generare un solo numero puoi usare:

new Random().Next( int.MinValue, int.MaxValue )

Per ulteriori informazioni, guarda la classe Casuale , tuttavia tieni presente che:

Tuttavia, poiché l'orologio ha una risoluzione limitata, l'utilizzo del costruttore senza parametri per creare diversi oggetti casuali in successione ravvicinata crea generatori di numeri casuali che producono sequenze identiche di numeri casuali

Quindi non utilizzare questo codice per generare una serie di numeri casuali.


41
-1: il seed predefinito si basa sul tempo; fallo in un ciclo e otterrai risultati molto non casuali. Dovresti creare un generatore e usarlo per tutti i tuoi numeri, non un generatore separato ogni volta.
Bevan,

21
Ehi, è ingiusto. La domanda era come generare un numero int casuale. Non sono stati menzionati loop o serie.
Fyodor Soikin,

26
Ok, punto giusto. Annullato. Tuttavia, penso ancora che non utilizzare new Random()in un ciclo sia un punto importante.
Bevan,

Per coloro che si imbatteranno in questo in futuro, dovrebbe essere ovvio ora, ma lo sottolineerò; la risposta è stata aggiornata con questo punto, per non usarla in un ciclo per più valori.
vapcguy,

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

30

Volevo aggiungere una versione crittograficamente sicura:

Classe RNGCryptoServiceProvider ( MSDN o dotnetperls )

Implementa IDisposable.

using (RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider())
{
   byte[] randomNumber = new byte[4];//4 for int32
   rng.GetBytes(randomNumber);
   int value = BitConverter.ToInt32(randomNumber, 0);
}

15

Puoi usare il metodo StaticRandom di Jon Skeet all'interno della libreria di classi MiscUtil che ha creato per un numero pseudo-casuale.

using MiscUtil;
...

for (int i = 0; i < 100; 
    Console.WriteLine(StaticRandom.Next());

31
Ho appena dato un'occhiata al codice sorgente e questa funzione utilizza esattamente lo stesso motore di numeri casuali, quello "incluso" in C #, ma mi assicura che lo stesso "seme" / "oggetto madre" sia usato per tutte le chiamate. (Mi dispiace di non conoscere la terminologia C #. Ma il mio punto è che questa funzione non crea numeri casuali migliori della funzione standard.)
Andreas Rejbrand

5
È impossibile che qualsiasi cosa sia "veramente casuale" poiché c'è sempre qualche fattore limitante o pregiudizio incluso che è inerente alla sua stessa esistenza. Non hai ascoltato l'insegnante durante le lezioni di scienze? ;-)
Phill Healey,

Diciamo che secondo lui questo è "davvero casuale" come si arriva
The Mitra Boy

Link interrotto ora. Ecco perché includi le informazioni che trovi nella tua risposta.
vapcguy,

13

Ho provato tutte queste soluzioni esclusa la risposta COBOL ... lol

Nessuna di queste soluzioni era abbastanza buona. Avevo bisogno di randoms in un ciclo veloce per int e stavo ottenendo tonnellate di valori duplicati anche in intervalli molto ampi. Dopo essermi accontentato di risultati casuali per troppo tempo, ho deciso di affrontare finalmente questo problema una volta per tutte.

Riguarda il seme.

Creo un numero intero casuale analizzando le non cifre da Guid, quindi lo utilizzo per creare un'istanza della mia 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);
}

Aggiornamento : il seeding non è necessario se si crea un'istanza della classe Random una volta. Quindi sarebbe meglio creare una classe statica e annullare un metodo.

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

Quindi puoi usare la classe statica in questo modo ..

for(var i = 0; i < 1000; i++)
{
   int randomNumber = IntUtil.Random(1,100);
   Console.WriteLine(randomNumber); 
}

Ammetto che mi piace meglio questo approccio.


6
Guid non è casuale, non è un buon seme. Un GUID non fornisce garanzie sulla casualità, offre garanzie sull'unicità. stackoverflow.com/questions/2621563/…
Magu,

2
Guid è un buon seme. Sto solo usando i numeri nella Guida. Prova il metodo per te stesso. Mettilo in un lungo ciclo e guarda i risultati per te stesso.
Proximo,

1
Hmm, ripensandoci .. il seme non è affatto necessario. Risposta di aggiornamento
Proximo,

1
Ottimo punto sull'aggiornamento. Non pensavo nemmeno di renderlo un campo statico, in questo modo funziona molto meglio ed è più pulito.
JCisar,

1
Ci sono alcuni problemi con questa risposta. Innanzitutto il GUID non è una grande fonte di seed - solo perché sembra casuale non significa che lo sia. Si può essere abbastanza buono per le vostre esigenze personali. In secondo luogo, la classe Random non è thread-safe. Devi istanziarlo una volta per thread.
Ettore,

11

I numeri generati dalla Randomclasse incorporata (System.Random) generano numeri pseudo casuali.

Se vuoi veri numeri casuali, il più vicino che possiamo ottenere è "generatore pseudo-casuale sicuro" che può essere generato usando le classi crittografiche in C # come RNGCryptoServiceProvider.

Tuttavia, se hai ancora bisogno di veri numeri casuali, dovrai utilizzare una fonte esterna come dispositivi che tengono conto del decadimento radioattivo come seme per un generatore di numeri casuali. Poiché, per definizione, qualsiasi numero generato con mezzi puramente algoritmici non può essere veramente casuale.


11

creare un oggetto casuale

Random rand = new Random();

e usalo

int randomNumber = rand.Next(min, max);

non è necessario inizializzare new Random()ogni volta che è necessario un numero casuale, avviare un numero casuale quindi utilizzarlo tutte le volte che è necessario all'interno di un ciclo o qualsiasi altra cosa


5
new Random()usa i tick correnti come seed. Quando si istanziano più istanze nello stesso millisecondo (invece che spuntare), si otterrà lo stesso valore restituito.
Hans Ke il

10
Questo è attivamente negativo. DateTime.Now.Millisecond (a differenza di DateTime.Now.Ticks) è un numero compreso tra 0 e 999. Se ne stai creando uno nuovo per ciascun numero casuale, avrai solo 1000 possibilità.
Oren Melzer,

Cosa stavano pensando 24 persone a votare questa risposta ...?
Enigmatività

10

Risposta modificata da qui .

Se hai accesso a una CPU compatibile con Intel Secure Key, puoi generare numeri e stringhe casuali reali utilizzando queste librerie: https://github.com/JebteK/RdRand e https://www.rdrand.com/

Basta scaricare l'ultima versione da qui , includere Jebtek.RdRand e aggiungere un'istruzione using per esso. Quindi, tutto ciò che devi fare è questo:

// Check to see if this is a compatible CPU
bool isAvailable = RdRandom.GeneratorAvailable();

// Generate 10 random characters
string key       = RdRandom.GenerateKey(10);

 // Generate 64 random characters, useful for API keys 
string apiKey    = RdRandom.GenerateAPIKey();

// Generate an array of 10 random bytes
byte[] b         = RdRandom.GenerateBytes(10);

// Generate a random unsigned int
uint i           = RdRandom.GenerateUnsignedInt();

Se non si dispone di una CPU compatibile per eseguire il codice, utilizzare i servizi RESTful su rdrand.com. Con la libreria wrapper RdRandom inclusa nel tuo progetto, dovrai solo farlo (ricevi 1000 chiamate gratuite al momento dell'iscrizione):

string ret = Randomizer.GenerateKey(<length>, "<key>");
uint ret   = Randomizer.GenerateUInt("<key>");
byte[] ret = Randomizer.GenerateBytes(<length>, "<key>");

7

Ho usato il codice qui sotto per avere un numero casuale (non raccomandato):

var random = new Random((int)DateTime.Now.Ticks);
var randomValue = random.Next(startValue, endValue + 1);

4

Mentre questo va bene:

Random random = new Random();
int randomNumber = random.Next()

Dovresti controllare il limite (mumbers min e max) per la maggior parte del tempo. Quindi è necessario specificare dove inizia e finisce il numero casuale.

Il Next()metodo accetta due parametri, min e max.

Quindi, se voglio che il mio numero casuale sia compreso tra 5 e 15, lo farei

int randomNumber = random.Next(5, 16)

4

Questa è la classe che uso. Funziona comeRandomNumber.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);
    }
}

La tua classe GenerateRandom non restituirà mai il numero 666, solo 665. Questo è un malinteso comune (funzione) di Random. Valore massimo successivo.
Gordon Bell,

3

Volevo dimostrare cosa succede quando un nuovo generatore casuale viene utilizzato ogni volta. Supponiamo di avere due metodi o due classi, ciascuno dei quali richiede un numero casuale. E ingenuamente li codifichi come:

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

Pensi che otterrai due ID diversi? NO

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 soluzione è utilizzare sempre un singolo generatore casuale statico. Come questo:

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

Come scegli in modo sicuro un seme allora?
Ja72,

Bene, in primo luogo, se i tuoi oggetti vengono creati anche a una distanza di 10 ms, i numeri casuali generati sono diversi con il seme predefinito. In secondo luogo, puoi ottenere qualsiasi dato ambientale o di processo casuale che hai in giro per ottenere un seme. Quindi c'è il compromesso se si desidera una lunga sequenza di numeri che molto probabilmente inizierà a ripetersi, o più flussi anche se due flussi finiscono per essere identici. E se sei preoccupato per la sicurezza, RNGCryptoServiceProviderè comunque una chiamata migliore.
Millie Smith l'

Sarebbe bello avere un chip randomizzatore con una piccola sorgente radioattiva di particelle alfa e un rilevatore (come funziona il rilevatore di fumo) al fine di randomizzare i numeri in base al decadimento radioattivo (che è molto casuale).
Ja72,

3

Per un forte seme casuale uso sempre CryptoRNG e non Time.

using System;
using System.Security.Cryptography;

public class Program
{
    public static void Main()
    {
        var random = new Random(GetSeed());
        Console.WriteLine(random.Next());
    }

    public static int GetSeed() 
    {
        using (var rng = new RNGCryptoServiceProvider())
        {
            var intBytes = new byte[4];
            rng.GetBytes(intBytes);
            return BitConverter.ToInt32(intBytes, 0);
        }
    }
}

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

1
Sebbene questo codice possa rispondere alla domanda, è meglio spiegare come risolvere il problema e fornire il codice come esempio o riferimento. Le risposte di solo codice possono essere confuse e prive di contesto.
Robert Columbia,

3

Proprio come una nota per riferimento futuro.

Se stai usando .NET Core, più istanze casuali non sono così pericolose come prima. Sono consapevole che questa domanda è del 2010, ma poiché questa domanda è vecchia ma ha qualche attrazione, penso che sia una buona cosa documentare il cambiamento.

Puoi fare riferimento a questa domanda che ho fatto tempo fa:

Microsoft ha modificato il seed predefinito casuale?

Fondamentalmente, hanno cambiato il seed predefinito da Environment.TickCounta Guid.NewGuid().GetHashCode(), quindi se crei 2 istanze di Random non visualizzerà gli stessi numeri.

Puoi vedere le differenze tra i file da .NET Framework / .NET Core (2.0.0+) qui: https://github.com/dotnet/coreclr/pull/2192/commits/9f6a0b675e5ac0065a268554de49162c539ff66d

Non è sicuro come RNGCryptoServiceProvider, ma almeno non ti darà risultati strani.


Questo è obsoleto. C'è stato un notevole contraccolpo contro l'uso delle guide. Il codice è adesso Interop.GetRandomBytes((byte*)&result, sizeof(int));.
Enigmativity

2

I numeri calcolati da un computer attraverso un processo deterministico, per definizione, non possono essere casuali.

Se si desidera un vero numero casuale, la casualità deriva dal rumore atmosferico o dal decadimento radioattivo.

Puoi provare ad esempio RANDOM.ORG (riduce le prestazioni)


2
Random rand = new Random();
int name = rand.Next()

Inserisci i valori che vuoi tra parentesi seconde assicurati di aver impostato un nome scrivendo prop e double tab per generare il codice


1
Prop e doppia scheda?
DCShannon,

Perché prop e doppia scheda ? Stai dicendo che, senza scorciatoia da tastiera, che è a breve mano per la proprietà, il codice non funziona?
Sнаđошƒаӽ

2

Se vuoi che un CSRNG generi numeri casuali tra un minimo e un massimo, questo è per te. Inizializzerà le Randomclassi con seed casuali sicuri.

    class SecureRandom : Random
    {
        public static byte[] GetBytes(ulong length)
        {
            RNGCryptoServiceProvider RNG = new RNGCryptoServiceProvider();
            byte[] bytes = new byte[length];
            RNG.GetBytes(bytes);
            RNG.Dispose();
            return bytes;
        }
        public SecureRandom() : base(BitConverter.ToInt32(GetBytes(4), 0))
        {

        }
        public int GetRandomInt(int min, int max)
        {
            int treashold = max - min;
            if(treashold != Math.Abs(treashold))
            {
                throw new ArithmeticException("The minimum value can't exceed the maximum value!");
            }
            if (treashold == 0)
            {
                throw new ArithmeticException("The minimum value can't be the same as the maximum value!");
            }
            return min + (Next() % treashold);
        }
        public static int GetRandomIntStatic(int min, int max)
        {
            int treashold = max - min;
            if (treashold != Math.Abs(treashold))
            {
                throw new ArithmeticException("The minimum value can't exceed the maximum value!");
            }
            if(treashold == 0)
            {
                throw new ArithmeticException("The minimum value can't be the same as the maximum value!");
            }
            return min + (BitConverter.ToInt32(GetBytes(4), 0) % treashold);
        }
    }

1

Spiacenti, OP richiede effettivamente un intvalore casuale , ma per il semplice scopo di condividere la conoscenza se si desidera un BigIntegervalore casuale è possibile utilizzare la seguente istruzione:

BigInteger randomVal = BigInteger.Abs(BigInteger.Parse(Guid.NewGuid().ToString().Replace("-",""), NumberStyles.AllowHexSpecifier));

0

Presumo che tu voglia un generatore di numeri casuali distribuito uniformemente come di seguito. Il numero casuale nella maggior parte del linguaggio di programmazione, inclusi C # e C ++, non viene mischiato correttamente prima di usarli. Ciò significa che otterrai sempre lo stesso numero, il che non è davvero casuale. Per evitare di disegnare sempre lo stesso numero, è necessario un seme. In genere, i tick in time sono ok per questa attività. Ricorda che otterrai lo stesso numero più volte se stai usando lo stesso seme ogni volta. Quindi cerca di usare sempre semi diversi. Il tempo è una buona fonte per i semi perché si rincorrono sempre.

int GetRandomNumber(int min, int max)
{
    Random rand = new Random((int)DateTime.Now.Ticks);
    return rand.Next(min, max);
}

se stai cercando un generatore di numeri casuali per la distribuzione normale, potresti usare una trasformazione Box-Muller. Controlla la risposta di yoyoyoyosef nella Domanda variabile gaussiana casuale. Dato che vuoi un numero intero, devi lanciare il doppio valore in numero intero alla fine.

Random rand = new Random(); //reuse this if you are generating many
double u1 = 1.0-rand.NextDouble(); //uniform(0,1] random doubles
double u2 = 1.0-rand.NextDouble();
double randStdNormal = Math.Sqrt(-2.0 * Math.Log(u1)) *
         Math.Sin(2.0 * Math.PI * u2); //random normal(0,1)
double randNormal =
         mean + stdDev * randStdNormal; //random normal(mean,stdDev^2)

Variabili gaussiane casuali


0

Il modo più semplice è probabilmente solo Random.range(1, 3)Questo genererebbe un numero compreso tra 1 e 2.


-1

Puoi provare con un valore seme casuale usando di seguito:

var rnd = new Random(11111111); //note: seed value is 11111111

string randomDigits = rnd.Next();

var requestNumber = $"SD-{randomDigits}";

Grazie @ MikaelDúiBolinder per vedere questo snipet
Rejwanul Reja

-2

Perché non usare int randomNumber = Random.Range(start_range, end_range)?


In realtà int randomNumber = Random.Range (start_range, end_range + 1)
Gordon Bell,

3
Esiste Random.Range ()? Non sono riuscito a trovarlo nella documentazione MSDN.
Phillip Ngan,

Non sono riuscito a trovare Random.Range () anche nella documentazione MSDN
user2455111

-2

Utilizzare ripetutamente un'istanza di Casuale

// Somewhat better code...
Random rng = new Random();
for (int i = 0; i < 100; i++)
{
    Console.WriteLine(GenerateDigit(rng));
}
...
static int GenerateDigit(Random rng)
{
    // Assume there'd be more logic here really
    return rng.Next(10);
}

Questo articolo esamina perché la casualità causa così tanti problemi e come risolverli. http://csharpindepth.com/Articles/Chapter12/Random.aspx


Randomnon è una classe thread-safe. Se si crea una singola istanza, è necessario limitare l'accesso ad essa dietro un meccanismo di blocco.
Brad M,

-2

Prova questi semplici passaggi per creare numeri casuali:

Crea funzione:

private int randomnumber(int min, int max)
{
    Random rnum = new Random();
    return rnum.Next(min, max);
}

Utilizzare la funzione sopra in una posizione in cui si desidera utilizzare numeri casuali. Supponiamo che tu voglia usarlo in una casella di testo.

textBox1.Text = randomnumber(0, 999).ToString();

0 è min e 999 è max. È possibile modificare i valori come desiderato.


Questo restituirà lo stesso numero se chiamato più volte da vicino poiché utilizza l'ora di sistema come seme ...
MOnsDaR

1
randomnumber (0, 999) non restituirà mai 999. Il valore massimo non è incluso. Questo è un malinteso comune (caratteristica) di Random.Next valore massimo.
Gordon Bell,

-2

Ho sempre metodi che generano numeri casuali che aiutano per vari scopi. Spero che questo possa aiutare anche te:

public class RandomGenerator  
{  
    public int RandomNumber(int min, int max)  
    {  
        var random = new Random();  
        return random.Next(min, max);  
    }  

    public string RandomString(int size, bool lowerCase)  
    {  
        var builder = new StringBuilder();  
        var random  = new Random();  
        char ch;  

        for (int i = 0; i < size; i++)  
        {  
            ch = Convert.ToChar(Convert.ToInt32(Math.Floor(26 * random.NextDouble() + 65)));  
            builder.Append(ch);  
        }  

        if (lowerCase)  
            return builder.ToString().ToLower();  
        return builder.ToString();  
    }  
}

-3

Veloce e facile per in linea, utilizzare il codice seguente:

new Random().Next(min, max);

// for example unique name
strName += "_" + new Random().Next(100, 999);
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.