Como faço para gerar um número int random em c #?

Como faço para gerar um inteiro random em c #?

A class Random é usada para criar números randoms. (Pseudo-random que é claro).

Exemplo:

 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 você for criar mais de um número random, deverá manter a instância Random e reutilizá-la. Se você criar novas instâncias muito próximas no tempo, elas produzirão a mesma série de números randoms que o gerador random é propagado do relógio do sistema.

Toda vez que você faz o novo Random (), ele é inicializado. Isso significa que em um loop apertado você obtém o mesmo valor várias vezes. Você deve manter uma única instância aleatória e continuar usando o Next na mesma instância.

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

A questão parece muito simples, mas a resposta é um pouco complicada. Se você ver quase todo mundo sugeriu usar a class Random e alguns sugeriram usar a class de criptografia RNG. Mas então quando escolher o que.

Para isso, precisamos primeiro entender o termo RANDOMNESS e a filosofia por trás dele.

Gostaria de encorajá-lo a assistir este vídeo que vai em profundidade na filosofia da RANDOMNESS usando C # https://www.youtube.com/watch?v=tCYxc-2-3fY

Primeira coisa, vamos entender a filosofia da RANDOMNESS. Quando dizemos a uma pessoa para escolher entre VERMELHO, VERDE e AMARELO o que acontece internamente. O que faz uma pessoa escolher VERMELHO ou AMARELO ou VERDE?

c # aleatório

Algum pensamento inicial entra na mente das pessoas que decide sua escolha, pode ser a cor favorita, a cor da sorte e assim por diante. Em outras palavras, um gatilho inicial que denominamos de RANDOM como SEED. Este SEED é o ponto inicial, o gatilho que o instiga a selecionar o valor RANDOM.

Agora, se um SEED é fácil de adivinhar, então esse tipo de número random é denominado PSEUDO e quando uma semente é difícil de adivinhar, esses números randoms são denominados números randoms SECURED .

Por exemplo, uma pessoa escolhe a cor dependendo da combinação de clima e som, então seria difícil adivinhar a semente inicial.

c # aleatório

Agora deixe-me fazer uma declaração importante:

* A class “Random” gera apenas um número random PSEUDO e para gerar o número random SECURE, precisamos usar a class “RNGCryptoServiceProvider”.

c # aleatório

A class aleatória pega valores iniciais do clock da CPU, o que é muito previsível. Então, em outras palavras, a class RANDOM de C # gera números pseudo-randoms, abaixo está o código para o mesmo.

 Random rnd= new Random(); int rndnumber = rnd.Next() 

Enquanto a class RNGCryptoServiceProvider usa a entropia do sistema operacional para gerar sementes. A entropia do sistema operacional é um valor random que é gerado usando o som, o clique do mouse e o tempo do teclado, a temperatura térmica etc. Abaixo, o código para o mesmo.

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

Para entender a entropia do sistema operacional, veja este vídeo em https://www.youtube.com/watch?v=tCYxc-2-3fY a partir das 11:20, onde a lógica da entropia do sistema operacional é explicada. Por isso, colocando palavras simples, o RNG Crypto gera números randoms SECURE.

Tenha em atenção que o new Random() é propagado no timestamp atual.

Se você quiser gerar apenas um número, você pode usar:

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

Para mais informações, veja a class Random , mas observe:

No entanto, como o relógio tem resolução finita, usar o construtor sem parâmetros para criar objects randoms diferentes em sucessão próxima cria geradores de números randoms que produzem seqüências idênticas de números randoms

Portanto, não use esse código para gerar uma série de números randoms.

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

Eu queria adicionar uma versão criptograficamente segura:

Classe RNGCryptoServiceProvider ( MSDN ou dotnetperls )

Ele implementa IDisposable.

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

Você poderia usar o método StaticRandom de Jon Skeet dentro da biblioteca de classs MiscUtil que ele construiu para um número pseudo-random.

 using System; using MiscUtil; class Program { static void Main(string[] args) { for (int i = 0; i < 100; i++) { Console.WriteLine(StaticRandom.Next()); } } } 

é melhor semear o object Random com milissegundos atuais, para garantir um número random verdadeiro, e você quase não encontrará duplicatas usando-o muitas vezes

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

Atualizar

Eu sei que o new Random() usa os ticks atuais como semente, mas a propagação com milissegundos atuais ainda é boa o bastante, já que é um bom começo random

O último ponto remanescente é que você não precisa inicializar o new Random() toda vez que precisar de um número random, iniciar um object Random e usá-lo quantas vezes precisar dentro de um loop ou qualquer outra coisa.

Eu tentei todas essas soluções excluindo a resposta COBOL … lol

Nenhuma dessas soluções foi boa o suficiente. Eu precisava de randoms em um loop rápido para int e eu estava recebendo toneladas de valores duplicados mesmo em intervalos muito amplos. Depois de decidir por um tipo de resultado random por muito tempo, decidi finalmente resolver esse problema de uma vez por todas.

É tudo sobre a semente.

Eu crio um inteiro random analisando os não-dígitos de Guid, então eu uso isso para instanciar minha class 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); } 

Update : A propagação não é necessária se você instanciar a class Random uma vez. Portanto, seria melhor criar uma class estática e chamar um método disso.

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

Então você pode usar a class estática como assim ..

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

Eu admito que gosto dessa abordagem melhor.

Os números gerados pela class Random inerente (System.Random) geram números pseudo-randoms.

Se você quiser números randoms verdadeiros, o mais próximo que podemos obter é “Secure Pseudo Random Generator”, que pode ser gerado usando as classs de criptografia em C #, como RNGCryptoServiceProvider .

Mesmo assim, se você ainda precisar de números randoms verdadeiros , precisará usar uma fonte externa, como dispositivos responsáveis ​​pelo decaimento radioativo, como uma semente para um gerador de números randoms. Como, por definição, qualquer número gerado por meios puramente algorítmicos não pode ser verdadeiramente random.

Eu uso abaixo do código para ter um número random:

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

Resposta modificada daqui .

Se você tiver access a uma CPU compatível com Intel Secure Key, poderá gerar números e strings randoms reais usando essas bibliotecas: https://github.com/JebteK/RdRand e https://www.rdrand.com/

Apenas baixe a versão mais recente daqui , inclua Jebtek.RdRand e adicione uma instrução using para ele. Então, tudo que você precisa fazer é isto:

 bool isAvailable = RdRandom.GeneratorAvailable(); //Check to see if this is a compatible CPU string key = RdRandom.GenerateKey(10); //Generate 10 random characters string apiKey = RdRandom.GenerateAPIKey(); //Generate 64 random characters, useful for API keys byte[] b = RdRandom.GenerateBytes(10); //Generate an array of 10 random bytes uint i = RdRandom.GenerateUnsignedInt() //Generate a random unsigned int 

Se você não tiver uma CPU compatível para executar o código, basta usar os serviços RESTful em rdrand.com. Com a biblioteca de wrapper RdRandom incluída no seu projeto, você só precisa fazer isso (você recebe 1000 chamadas gratuitas quando se inscreve):

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

Enquanto isso está bem:

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

Você deseja controlar o limite (min e max mumbers) a maior parte do tempo. Então você precisa especificar onde o número random começa e termina.

O método Next() aceita dois parâmetros, min e max.

Então, se eu quiser que meu número random fique entre 5 e 15, eu faria

 int randomNumber = random.Next(5, 16) 

Esta é a class que eu uso. Funciona como 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); } } 
 Random rand = new Random(); int name = rand.Next() 

Coloque os valores que você deseja no segundo parênteses, certifique-se de ter definido um nome escrevendo prop e double tab para gerar o código

Números calculados por um computador através de um processo determinístico, não podem, por definição, ser randoms.

Se você quiser um número random genuíno, a aleatoriedade vem do ruído atmosférico ou do decaimento radioativo.

Você pode tentar, por exemplo, RANDOM.ORG (reduz o desempenho)

Eu queria demonstrar o que acontece quando um novo gerador random é usado todas as vezes. Suponha que você tenha dois methods ou duas classs, cada um exigindo um número random. E ingenuamente você codifica-os como:

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

Você acha que terá dois IDs diferentes? NÃO

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

A solução é sempre usar um único gerador random estático. Como isso:

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

Para semente aleatória forte eu sempre uso CryptoRNG e não 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); } } } 

Por que não usar int randomNumber = Random.Range(start_range, end_range) ?

Tente estas etapas simples para criar números randoms:

criar function

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

Use a function acima em um local onde você deseja usar números randoms. Suponha que você queira usá-lo em uma checkbox de texto.

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

0 é min e 999 é o máximo. Você pode alterar os valores para o que quiser.

Além disso, verifique a resposta nesta página .

( http://solutions.musanitech.com/c-how-to-create-random-numbers/ )

Você pode tentar com um valor de semente random usando abaixo:

 var rnd = new Random(11111111); //note: seed value is 11111111 string randomDigits = rnd.Next().ToString().Substring(0, 8); var requestNumber = $"SD-{randomDigits}"; 

Rápido e fácil para inline, use o código abaixo:

 new Random().Next(min, max); // for example unique name strName += "_" + new Random().Next(100, 999); 

Eu sempre tenho methods que geram números randoms que ajudam em vários propósitos. Espero que isso possa ajudá-lo também:

 public class RandomGenerator { public int RandomNumber(int min, int max) { Random random = new Random(); return random.Next(min, max); } public string RandomString(int size, bool lowerCase) { StringBuilder builder = new StringBuilder(); Random 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(); } } 

Use uma instância de Random repetidamente

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

Este artigo analisa por que a aleatoriedade causa tantos problemas e como resolvê-los. http://csharpindepth.com/Articles/Chapter12/Random.aspx

Eu suponho que você quer um gerador de números randoms distribuído uniformemente como abaixo. Número random na maioria das linguagens de programação, incluindo C # e C ++, não é embaralhado corretamente antes de usá-los. Isso significa que você receberá o mesmo número várias vezes, o que não é realmente random. Para evitar desenhar o mesmo número repetidamente, você precisa de uma semente. Normalmente, os tiques no tempo são bons para essa tarefa. Lembre-se de que você obterá o mesmo número repetidamente se estiver usando a mesma semente todas as vezes. Portanto, tente usar sementes variadas sempre. O tempo é uma boa fonte de sementes porque elas sempre mudam.

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

Se você estiver procurando por um gerador de números randoms para distribuição normal, você pode usar uma transformação Box-Muller. Verifique a resposta por yoyoyoyosef em Random Gaussian Variable Question. Desde que você quer inteiro, você tem que converter o valor duplo para inteiro no final.

 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) 

Variáveis ​​Gaussianas Aleatórias

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

você também pode dar valor mínimo e máximo à function Next() . Gostar

  int n = new Random().Next(5,10);