Gerador de número aleatório gerando apenas um número aleatório

Eu tenho a seguinte função:

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

Como eu chamo isso:

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

Se eu passo esse loop com o depurador durante o tempo de execução, recebo valores diferentes (que é o que eu quero). No entanto, se eu colocar um ponto de interrupção duas linhas abaixo desse código, todos os membros da macmatriz terão valor igual.

Por que isso acontece?

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

//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 comentários): por que precisamos de um lockaqui?

Basicamente, Nextvai mudar o estado interno da Randominstância. Se fizermos isso ao mesmo tempo a partir de vários encadeamentos, você poderá argumentar "acabamos de tornar o resultado ainda mais aleatório", mas o que realmente estamos fazendo é potencialmente violar a implementação interna e também podemos começar a obter os mesmos números de threads diferentes, o que pode ser um problema - e talvez não. A garantia do que acontece internamente é o problema maior; desde Randomque não faça nenhuma garantia de segurança de linha. Portanto, existem duas abordagens válidas:

• Sincronize para não acessá-lo ao mesmo tempo a partir de threads diferentes
• Use Randominstâncias diferentes por thread

Qualquer um pode ficar bem; mas mutex uma instância única de vários chamadores ao mesmo tempo está apenas causando problemas.

O lockatinge a primeira (e mais simples) dessas abordagens; no entanto, outra abordagem pode ser:

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

isso é por thread, para que você não precise sincronizar.

Para facilitar a reutilização em todo o aplicativo, uma classe estática pode ajudar.

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

Você pode usar e usar instância aleatória estática com código como

StaticRandom.Instance.Next(1, 100);

A solução de Mark pode ser bastante cara, pois precisa ser sincronizada sempre.

Podemos contornar a necessidade de sincronização usando o padrão de armazenamento específico do encadeamento:

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

Meça as duas implementações e você verá uma diferença significativa.

Minha resposta daqui :

Apenas reiterando a solução certa :

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

Então você pode ligar para:

var i = Util.GetRandom();

em toda parte.

Se você precisar estritamente de um método estático verdadeiro sem estado para gerar números aleatórios, poderá confiar em a Guid.

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

Vai ser um pouco mais lento, mas pode ser muito mais aleatório do que Random.Next, pelo menos da minha experiência.

Mas não :

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

A criação desnecessária de objetos vai torná-lo mais lento, especialmente em um loop.

E nunca :

new Random().Next();

Não só é mais lento (dentro de um loop), sua aleatoriedade é ... bem, não é muito boa de acordo comigo.

Prefiro usar a seguinte classe para gerar números aleatórios:

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

1) Como Marc Gravell disse, tente usar UM gerador aleatório. É sempre legal adicionar isso ao construtor: System.Environment.TickCount.

2) Uma dica. Digamos que você queira criar 100 objetos e suponha que cada um deles tenha seu próprio gerador aleatório (útil se você calcular LOADS de números aleatórios em um período muito curto de tempo). Se você fizer isso em um loop (geração de 100 objetos), poderá fazer o seguinte (para garantir a aleatoriedade 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);

Felicidades.

Toda vez que você executa

Random random = new Random (15);

Não importa se você o executar milhões de vezes, sempre usará a mesma semente.

Se você usar

Random random = new Random ();

Você obtém uma sequência numérica aleatória diferente, se um hacker adivinhar a semente e seu algoritmo estiver relacionado à segurança do seu sistema - seu algoritmo está quebrado. Eu você executa mult. Nesse construtor, a semente é especificada pelo relógio do sistema e, se várias instâncias são criadas em um período muito curto de tempo (milissegundos), é possível que elas tenham a mesma semente.

Se você precisar de números aleatórios seguros, deverá usar a classe

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

Apenas declare a variável da classe Random assim:

    Random r = new Random();
    // ... Get three random numbers.
    //     Here you'll get numbers from 5 to 9
    Console.WriteLine(r.Next(5, 10));

se você deseja obter um número aleatório diferente de cada vez da sua lista, use

r.Next(StartPoint,EndPoint) //Here end point will not be included

Cada vez, declarando Random r = new Random()uma vez.

Existem muitas soluções, eis uma: se você deseja que apenas o número apague as letras e o método receba aleatoriamente e o comprimento do resultado.

public String GenerateRandom(Random oRandom, int iLongitudPin)
{
    String sCharacters = "123456789ABCDEFGHIJKLMNPQRSTUVWXYZ123456789";
    int iLength = sCharacters.Length;
    char cCharacter;
    int iLongitudNuevaCadena = iLongitudPin; 
    String sRandomResult = "";
    for (int i = 0; i < iLongitudNuevaCadena; i++)
    {
        cCharacter = sCharacters[oRandom.Next(iLength)];
        sRandomResult += cCharacter.ToString();
    }
    return (sRandomResult);
}