¿Cómo puedo generar un número entero aleatorio en C #?

¿Cómo puedo generar un entero aleatorio en C #?

La clase Random se usa para crear números aleatorios. (Pseudoaleatorio eso es por supuesto).

Ejemplo:

 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 

Si vas a crear más de un número aleatorio, debes conservar la instancia Random y reutilizarla. Si crea instancias nuevas demasiado próximas en el tiempo, producirán la misma serie de números aleatorios a medida que el generador aleatorio se seleciona desde el reloj del sistema.

Cada vez que haces un nuevo Random () se inicializa. Esto significa que, en un ciclo cerrado, obtienes el mismo valor muchas veces. Deberías mantener una sola instancia Aleatoria y seguir usando Siguiente en la misma instancia.

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

La pregunta parece muy simple, pero la respuesta es un poco complicada. Si ve que casi todos han sugerido usar la clase Random y algunos han sugerido usar la clase de criptografía RNG. Pero luego cuando elegir qué.

Para eso necesitamos entender primero el término ALEATORIO y la filosofía detrás de él.

Te animo a que veas este video que profundiza en la filosofía de RANDOMNESS usando C # https://www.youtube.com/watch?v=tCYxc-2-3fY

Primero, entendamos la filosofía de RANDOMNESS. Cuando le decimos a una persona que elija entre ROJO, VERDE y AMARILLO lo que sucede internamente. ¿Qué hace que una persona elija ROJO, AMARILLO o VERDE?

c # Aleatorio

Algunos pensamientos iniciales se dirigen a la mente de las personas que decide su elección, puede ser el color favorito, el color de la suerte, etc. En otras palabras, un disparador inicial que denominamos ALEATORIO como SEMILLA. Esta SEMILLA es el punto de inicio, el disparador que lo instiga a seleccionar el valor ALEATORIO.

Ahora bien, si una SEED es fácil de adivinar, ese tipo de números aleatorios se denominan PSEUDO y cuando una semilla es difícil de adivinar, esos números aleatorios se denominan números aleatorios ASEGURADOS .

Por ejemplo, una persona elige el color dependiendo del clima y la combinación de sonido, entonces sería difícil adivinar la semilla inicial.

c # Aleatorio

Ahora déjame hacer una statement importante:

* La clase “Aleatoria” genera solo el número aleatorio de PSEUDO y para generar un número aleatorio SEGURO necesitamos usar la clase “RNGCryptoServiceProvider”.

c # Aleatorio

La clase aleatoria toma valores semilla de tu reloj de la CPU que es muy predecible. Entonces, en otras palabras, la clase RANDOM de C # genera números pseudoaleatorios, a continuación se muestra el código para la misma.

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

Mientras que la clase RNGCryptoServiceProvider usa la entropía del sistema operativo para generar semillas. La entropía del sistema operativo es un valor aleatorio que se genera mediante el sonido, el clic del mouse y el teclado, la temperatura térmica, etc. A continuación se muestra el código para el mismo.

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

Para comprender la entropía del sistema operativo, consulte este video https://www.youtube.com/watch?v=tCYxc-2-3fY a partir de las 11:20, donde se explica la lógica de la entropía del sistema operativo. Entonces, poniendo palabras simples, RNG Crypto genera números aleatorios SEGUROS.

Tenga en cuenta que el new Random() se incluye en la marca de tiempo actual.

Si desea generar solo un número , puede usar:

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

Para obtener más información, consulte la clase Aleatoria , aunque tenga en cuenta:

Sin embargo, como el reloj tiene una resolución finita, al usar el constructor sin parámetros para crear diferentes objetos aleatorios en estrecha sucesión se crean generadores de números aleatorios que producen secuencias idénticas de números aleatorios.

Entonces, no use este código para generar una serie de números aleatorios.

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

Quería agregar una versión criptográficamente segura:

RNGCryptoServiceProvider Class ( 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); } 

Puedes usar el método StaticRandom de Jon Skeet dentro de la biblioteca de clases MiscUtil que él construyó para un número pseudoaleatorio.

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

es mejor sembrar el objeto Random con milisegundos actuales, para asegurar un verdadero número aleatorio, y casi no encontrará duplicados usándolo muchas veces

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

Actualizar

Sé que el new Random() usa los tics actuales como semilla, pero sembrar con los milisegundos actuales sigue siendo lo suficientemente bueno ya que es un buen comienzo aleatorio

El último punto restante es que no tiene que inicializar new Random() cada vez que necesite un número aleatorio, inicie un objeto aleatorio y luego lo use tantas veces como lo necesite dentro de un bucle o lo que sea

He intentado todas estas soluciones excluyendo la respuesta COBOL … jajaja

Ninguna de estas soluciones fue lo suficientemente buena. Necesitaba randoms en un ciclo rápido para int y estaba obteniendo toneladas de valores duplicados incluso en rangos muy amplios. Después de conformarme con los resultados aleatorios durante demasiado tiempo, decidí finalmente abordar este problema de una vez por todas.

Se trata de la semilla.

Creo un entero al azar analizando los no dígitos de Guid, luego lo uso para crear una instancia de mi clase Aleatoria.

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

Actualización : no es necesario sembrar si crea una instancia de la clase Random una vez. Así que sería mejor crear una clase estática y llamar a un método de eso.

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

Entonces puedes usar la clase estática como así ..

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

Admito que me gusta este enfoque mejor.

Los números generados por la clase Random incorporada (System.Random) generan números pseudoaleatorios.

Si desea números aleatorios verdaderos, lo más cercano que podemos obtener es “generador pseudo aleatorio seguro” que se puede generar utilizando las clases criptográficas en C # como RNGCryptoServiceProvider .

Aun así, si todavía necesita números aleatorios verdaderos , deberá usar una fuente externa, como dispositivos que representen la desintegración radiactiva como una semilla para un generador de números aleatorios. Dado que, por definición, cualquier número generado por medios puramente algorítmicos no puede ser verdaderamente aleatorio.

Uso el código siguiente para tener un número aleatorio:

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

Respuesta modificada desde aquí .

Si tiene acceso a una CPU compatible con Intel Secure Key, puede generar números aleatorios reales y cadenas utilizando estas bibliotecas: https://github.com/JebteK/RdRand y https://www.rdrand.com/

Simplemente descargue la última versión desde aquí , incluya Jebtek.RdRand y agregue una statement de uso para ello. Entonces, todo lo que necesitas hacer es esto:

 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 

Si no tiene una CPU compatible para ejecutar el código, solo use los servicios RESTful en rdrand.com. Con la biblioteca contenedora RdRandom incluida en su proyecto, solo necesita hacer esto (obtiene 1000 llamadas gratuitas cuando se registra):

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

Mientras esto está bien:

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

Desea controlar el límite (min y max mumbers) la mayor parte del tiempo. Por lo tanto, debe especificar dónde comienza y dónde termina el número aleatorio.

El método Next() acepta dos parámetros, mínimo y máximo.

Entonces, si quiero que mi número aleatorio esté entre 5 y 15, simplemente lo haría

 int randomNumber = random.Next(5, 16) 

Esta es la clase que 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() 

Pon los valores que quieras en el segundo paréntesis asegúrate de haber establecido un nombre escribiendo prop y doble pestaña para generar el código

Los números calculados por una computadora a través de un proceso determinista, no pueden, por definición, ser aleatorios.

Si desea un número aleatorio genuino, la aleatoriedad proviene del ruido atmosférico o la desintegración radiactiva.

Puedes probar, por ejemplo, RANDOM.ORG (reduce el rendimiento)

Quería demostrar lo que sucede cuando se usa un generador aleatorio nuevo cada vez. Supongamos que tiene dos métodos o dos clases, cada uno de los cuales requiere un número aleatorio. Y ingenuamente los codificas 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; } } 

¿Crees que obtendrás dos ID diferentes? NOPE

 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 solución es usar siempre un solo generador aleatorio estático. Me gusta esto:

 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 una semilla aleatoria fuerte siempre uso CryptoRNG y no 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 qué no utilizar int randomNumber = Random.Range(start_range, end_range) ?

Pruebe estos simples pasos para crear números aleatorios:

crear función

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

Use la función anterior en una ubicación donde desee usar números aleatorios. Supongamos que desea usarlo en un cuadro de texto.

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

0 es mínimo y 999 es máximo. Puedes cambiar los valores a lo que quieras.

También verifique la respuesta en esta página .

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

Puede intentar con el valor de inicialización aleatorio usando a continuación:

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

Rápido y fácil para en línea, use el código de abajo:

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

Siempre tengo métodos que generan números aleatorios que ayudan para varios propósitos. Espero que esto también te pueda ayudar a ti:

 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 una instancia 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 artículo analiza por qué la aleatoriedad causa tantos problemas y cómo abordarlos. http://csharpindepth.com/Articles/Chapter12/Random.aspx

Asumiré que quiere un generador de números aleatorios distribuido uniformemente como a continuación. El número aleatorio en la mayoría del lenguaje de progtwigción, incluidos C # y C ++, no se baraja correctamente antes de usarlos. Esto significa que obtendrá el mismo número una y otra vez, lo cual no es realmente aleatorio. Para evitar dibujar el mismo número una y otra vez, necesita una semilla. Normalmente, las marcas en el tiempo están bien para esta tarea. Recuerde que obtendrá el mismo número una y otra vez si usa la misma semilla cada vez. Por lo tanto, trate de usar semillas variables siempre. El tiempo es una buena fuente de semilla porque siempre cambian.

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

Si está buscando un generador de números aleatorios para la distribución normal, puede usar una transformación de Box-Muller. Verifique la respuesta por yoyoyoyosef en Random Gaussian Variable Question. Como desea un entero, debe convertir el valor doble en entero al 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) 

Variables gaussianas aleatorias

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

también puede dar un valor mínimo y máximo a la función Next() . Me gusta

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