Generador de números aleatorios que solo genera un número aleatorio

Tengo la siguiente función:

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

Como lo llamo:

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

Si paso ese bucle con el depurador durante el tiempo de ejecución, obtengo valores diferentes (que es lo que quiero). Sin embargo, si pongo un punto de interrupción dos líneas debajo de ese código, todos los miembros de la macmatriz tienen el mismo valor.

¿Por qué pasa eso?

Cada vez que lo haces new Random()se inicializa usando el reloj. Esto significa que en un circuito cerrado obtienes el mismo valor muchas veces. Debe mantener una sola instancia aleatoria y seguir usando Next en la misma instancia.

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

Editar (ver comentarios): ¿por qué necesitamos un lockaquí?

Básicamente, Nextva a cambiar el estado interno de la Randominstancia. Si hacemos eso al mismo tiempo desde varios subprocesos, podría argumentar "acabamos de hacer que el resultado sea aún más aleatorio", pero lo que realmente estamos haciendo es potencialmente romper la implementación interna, y también podríamos comenzar a obtener los mismos números de diferentes subprocesos, lo que puede ser un problema, o no. Sin embargo, la garantía de lo que sucede internamente es el problema más importante; ya Randomque no ofrece ninguna garantía de seguridad de subprocesos. Por tanto, hay dos enfoques válidos:

• Sincronizar para que no accedamos a él al mismo tiempo desde diferentes hilos
• Usa diferentes Randominstancias por hilo

Cualquiera puede estar bien; pero silenciar una sola instancia de varias personas que llaman al mismo tiempo es solo buscar problemas.

El locklogra el primero (y más simple) de estos enfoques; sin embargo, otro enfoque podría ser:

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

esto es por subproceso, por lo que no es necesario sincronizar.

Para facilitar la reutilización en toda la aplicación, una clase estática puede ayudar.

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

Puede usar y luego usar una instancia aleatoria estática con código como

StaticRandom.Instance.Next(1, 100);

La solución de Mark puede ser bastante costosa ya que necesita sincronizarse cada vez.

Podemos evitar la necesidad de sincronización utilizando el patrón de almacenamiento específico del hilo:

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

Mida las dos implementaciones y verá una diferencia significativa.

Mi respuesta desde aquí :

Solo reiterando la solución correcta :

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

Entonces puedes llamar:

var i = Util.GetRandom();

todo a través de.

Si necesita estrictamente un verdadero método estático sin estado para generar números aleatorios, puede confiar en un Guid.

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

Va a ser un poquito más lento, pero puede ser mucho más aleatorio que Random.Next, al menos según mi experiencia.

Pero no :

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

La creación de objetos innecesarios lo hará más lento, especialmente bajo un bucle.

Y nunca más :

new Random().Next();

No solo es más lento (dentro de un bucle), su aleatoriedad es ... bueno, no es realmente bueno para mí ...

Prefiero usar la siguiente clase para generar números aleatorios:

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

1) Como dijo Marc Gravell, intente usar UN generador aleatorio. Siempre es bueno agregar esto al constructor: System.Environment.TickCount.

2) Un consejo. Supongamos que desea crear 100 objetos y supongamos que cada uno de ellos debería tener su propio generador aleatorio (útil si calcula CARGAS de números aleatorios en un período de tiempo muy corto). Si hiciera esto en un bucle (generación de 100 objetos), podría hacerlo así (para asegurar la aleatoriedad total):

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

Salud.

Cada vez que ejecutas

Random random = new Random (15);

No importa si lo ejecuta millones de veces, siempre usará la misma semilla.

Si utiliza

Random random = new Random ();

Obtiene una secuencia de números aleatorios diferente, si un pirata informático adivina la semilla y su algoritmo está relacionado con la seguridad de su sistema, su algoritmo está roto. Yo ejecuto mult. En este constructor, la semilla es especificada por el reloj del sistema y si se crean varias instancias en un período de tiempo muy corto (milisegundos) es posible que tengan la misma semilla.

Si necesita números aleatorios seguros, debe usar la clase

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

Resolví el problema usando la función Rnd ():

Function RollD6() As UInteger
        RollD6 = (Math.Floor(6 * Rnd())) + 1
        Return RollD6
End Function

Cuando se carga el formulario, utilizo el método Randomize () para asegurarme de que no siempre obtengo la misma secuencia de números aleatorios de una ejecución a otra.

Obtenga siempre un número aleatorio positivo.

 var nexnumber = Guid.NewGuid().GetHashCode();
        if (nexnumber < 0)
        {
            nexnumber *= -1;
        }