Cum pot genera o întâmplare int număr?

A "Aleator" clasa este folosit pentru a crea numere aleatoare. (Pseudo-aleatoare, care este desigur.).

Exemplu:

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

Dacă aveți de gând pentru a crea mai mult de un număr aleator, tu ar trebui să păstreze "Aleatoare" instanță și refolosi. Dacă veți crea noi instanțe prea aproape în timp, se va produce aceeași serie de numere aleatoare ca generator de aleatoriu este însămânțat de la ceasul de sistem.

Întrebarea pare foarte simplă, dar răspunsul este mai complicat. Dacă ai văzut aproape toată lumea a sugerat să folosească Aleatoare clasă și unii au sugerat să folosească RNG crypto clasa. Dar atunci când a alege ceea ce.

Pentru că avem nevoie să înțelegem mai întâi termenul de DEZORDINE și filosofia din spatele ei.

Aș dori să vă încurajez să urmăriți acest video, care merge în profunzime în filosofia de DEZORDINE folosind C# [https://www.youtube.com/watch?v=tCYxc-2-3fY][1]

Primul lucru pe care să ne înțelegem filosofia de DEZORDINE. Când spunem unei persoane de a alege între ROȘU, VERDE și GALBEN ce se întâmplă pe plan intern. Ceea ce face o persoană pentru a alege ROSU sau GALBEN sau VERDE?

Inițial a crezut că intră în mintea omului care decide alegerea lui, poate fi preferat de culoare , de culoare norocos și așa mai departe. Cu alte cuvinte inițială de declanșare ceea ce noi numim în mod ALEATORIU ca SEMINȚE.Această SĂMÂNȚĂ este punctul de inceput, de declanșare, care provoacă-l pentru a selecta valoarea ALEATORIE.

Acum, dacă o SĂMÂNȚĂ este ușor de ghicit atunci acele numere aleatoare sunt denumite PSEUDO și când o sămânță este greu să cred că aceste numere aleatoare sunt denumite ASIGURAT numere aleatoare.

De exemplu, o persoană alege este de culoare în funcție de vreme și combinația de sunet atunci ar fi greu de ghicit inițial de semințe.

Acum permiteți-mi să fac o declarație importantă:-

*"Random" clasa generează doar PSEUDO random number și pentru a genera SIGURE număr aleator avem nevoie pentru a utiliza "RNGCryptoServiceProvider" de clasa.

Clasa aleatorie ia semințe de valori de la ceas a PROCESORULUI care este foarte previzibil. Deci, cu alte cuvinte ALEATOARE clasa de C# generează numere pseudo-aleatoare , mai jos este codul pentru același.

Notă: .NET Core 2.0.0+ folosește o altă sămânță pe parameterless constructor: în loc de ceas a PROCESORULUI se folosește Guid.NewGuid().GetHashCode().

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

În timp ce `RNGCryptoServiceProvider clasa utilizează sistemul de OPERARE entropie pentru a genera semințe. Sistemul de OPERARE entropia este o valoare aleatoare care este generat folosind sunetul, faceți clic pe mouse-ul și tastatura timpii, termice temp etc. Mai jos merge codul pentru același.

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

Pentru a înțelege sistemul de OPERARE entropie vedea acest video de la 14:30 [https://www.youtube.com/watch?v=tCYxc-2-3fY][5] în cazul în care logica sistemului de OPERARE entropia este explicat. Deci, punând în cuvinte simple RNG Crypto generează SIGURE de numere aleatoare.

De fiecare dată când faci new Random() este inițializat . Acest lucru înseamnă că într-o buclă strânsă veți obține aceeași valoare de o mulțime de ori. Tu ar trebui să păstreze un singur exemplu Aleator și să păstreze utilizarea Viitoare la aceeași instanță.

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

Feriți-vă că new Random() este însămânțat pe amprenta de timp curent.

Dacă doriți pentru a genera doar un număr de puteți utiliza:

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

Pentru mai multe informații, uita-te la Aleatorie clasa totuși, vă rugăm să rețineți:

cu toate Acestea, pentru că ceasul are finite rezoluție, folosind parameterless constructor pentru a crea diferite obiecte Aleatorii în strânsă succesiune creează generatoare de numere aleatorii care produc identice secvențe de numere aleatoare

Asa ca nu folositi acest cod pentru a genera o serie de numere aleatorii.

Am vrut să adăugați un criptografice sigure versiune:

RNGCryptoServiceProvider Class ([MSDN][1] sau dotnetperls)

El pune în aplicare IDisposable.

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

[1]: https://msdn.microsoft.com/en-us/library/system.security.cryptography.rngcryptoserviceprovider(v=vs. 110).aspx

Ai putea folosi Jon Skeet's StaticRandom metoda în interiorul MiscUtil class library pe care a construit-o de numere pseudo-aleatoare.

using MiscUtil;
...

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

l's mai bine pentru semințe Aleatoare obiect cu curent de milisecunde, pentru a se asigura de numere aleatoare adevărat, și aproape că ai câștigat't găsi duplicate folosind-o de multe ori

Random rand = new Random(DateTime.Now.Millisecond);

Update

Știu asta pentru new Random()` utilizează curent căpușe ca semințe, dar semănat cu curent de milisecunde este încă suficient de bine ca's întâmplare bun început

Ultimul punct este că don't au pentru a inițializa new Random() de fiecare dată când ai nevoie de un număr aleator, de a iniția un obiect Aleatoriu apoi să-l utilizați ori de câte ori aveți nevoie în interiorul unei bucle sau orice

Am'am încercat toate aceste soluții, cu excepția COBOL raspuns... lol

Niciuna dintre aceste soluții nu au fost suficient de bun. Am nevoie de oameni într-un mod rapid pentru int buclă și am fost obtinerea de tone de valorile duplicate chiar și în limite largi. După stabilindu-se pentru un fel de rezultate aleatorii prea mult timp m-am decis în sfârșit să abordeze această problemă o dată și pentru toate.

L's tot despre semințe.

Am crea un număr întreg aleator de analiză non-cifre de Guid, apoi am folosi pentru a instantia mea clasa Aleatorie.

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

**** Update: Însămânțare e't este necesar dacă instantia clasa Aleatorie-o dată. Deci'd fi cel mai bine pentru a crea o clasă static și apela o metodă pe care.

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

Apoi, puteți utiliza static clasa place asa..

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

Recunosc că-mi place această abordare mai bine.

Modificat răspunde de aici.

Dacă aveți acces la un procesor Intel Secure Key PROCESOR compatibil, puteți genera numere aleatoare real și siruri de caractere folosind aceste biblioteci: https://github.com/JebteK/RdRand și https://www.rdrand.com/

Doar descărca cea mai recentă versiune de aici, includ Jebtek.RdRand și se adaugă o folosind declarație pentru ea. Apoi, tot ce trebuie sa faci este aceasta:

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

Dacă tu nu't avea un PROCESOR compatibil pentru a executa codul, trebuie doar să utilizați servicii Odihnitor la rdrand.com. Cu RdRandom wrapper library incluse în proiect, ai nevoie doar pentru a face acest lucru (ai 1000 de apeluri gratuite atunci când înscriere):

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

Numerele generate de incorporat "Aleatorie" de clasă (de Sistem.Aleatoare) generează numere pseudo-aleatoare.

Daca vrei cu adevarat aleatorie de numere, cele mai apropiate este "sigur Pseudo-Aleatoare Generator de" care pot fi generate cu ajutorul Criptografice clase în C#, precum RNGCryptoServiceProvider.

Chiar și așa, dacă ai nevoie de încă adevărat numere aleatoare va fi nevoie de a utiliza o sursă externă, cum ar fi dispozitive de contabilitate pentru dezintegrare radioactivă ca o sămânță pentru un generator de numere aleatoare. Deoarece, prin definiție, orice număr generate de pur algoritmice înseamnă că nu poate fi cu adevărat aleatoriu.

Eu folosesc codul de mai jos pentru a avea un număr aleator:

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

Aceasta este clasa I folosi. Funcționează ca RandomNumber.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);
    }
}

În timp ce acest lucru este bine:

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

Te'd doresc să controleze limita (min și max mumbers) majoritatea timpului. Deci, ai nevoie pentru a specifica în cazul în care numărul aleatoriu începe și se termină.

Next() metoda acceptă doi parametri, min și max.

Deci, dacă vreau să-mi număr aleator să fie între 5 și 15 ani, am'd fă

int randomNumber = random.Next(5, 16)

Pentru puternic de semințe aleatoare eu folosesc întotdeauna CryptoRNG și nu de Timp.

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

Cifre calculate de către un computer printr-un proces determinist, nu poate, prin definiție, să fie aleatoare.

Dacă doriți un veritabil numere aleatoare, aleator vine de zgomot atmosferic sau dezintegrare radioactivă.

Puteți încerca, de exemplu RANDOM.ORG (reduce performanta)

Am vrut pentru a demonstra ce se întâmplă când un nou generator de numere aleatoare este folosit de fiecare dată. Să presupunem că aveți două metode sau două clase, fiecare necesitând un număr aleator. Și naivitate ai codul de ei, cum ar fi:

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

Crezi că vei primi doua Id-uri diferite? NU

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

Soluția este să always folosi un singur static generator de aleatoriu. Astfel:

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

Codul de mai jos returnează un număr aleator. 

int num = random.Next(); 

Codul de mai jos returnează un număr aleator mai mic decât 1000. 

int num = random.Next(1000);

Codul de mai jos returnează un număr aleator între min și max de serie.

Genera un aleatorie număr între doi numere:

public int RandomNumber(int min, int max)  

 { 

Random random = new Random(); 

return random.Next(min, max);  

}

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

Pune ce valori vrei în cea de-a doua paranteze asigurați-vă că ați setat un nume de scriere a propunerii și fila dublu pentru a genera codul