Генератор випадкових чисел генерує лише одне випадкове число

У мене є така функція:

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

Як я це називаю:

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

Якщо я переходжу цей цикл з налагоджувачем під час виконання, я отримую різні значення (що я хочу). Однак якщо я поставив точку розриву на два рядки нижче цього коду, всі члени macмасиву мають однакове значення.

Чому це відбувається?

Кожен раз, коли ви new Random()це робите , ініціалізується за допомогою годинника. Це означає, що в тісному циклі ви отримуєте однакове значення багато разів. Ви повинні зберігати один випадковий екземпляр і продовжувати використовувати Next у тому ж екземплярі.

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

Редагувати (див. Коментарі): навіщо нам lockтут потрібен ?

В основному, Nextзбирається змінити внутрішній стан Randomекземпляра. Якщо ми будемо робити це одночасно з декількох потоків, ви можете стверджувати, що "ми просто зробили результат ще більш випадковим", але те, що ми насправді робимо, - це потенційно порушує внутрішню реалізацію, і ми також можемо почати отримувати однакові цифри з різних ниток, що може бути проблемою - а може й не бути. Однак, більша проблема - гарантія того, що відбувається всередині; так як Randomце НЕ робить ніяких гарантій безпеки потоків. Таким чином, існує два дійсних підходи:

• Синхронізуйте, щоб ми не мали доступу до нього одночасно з різних потоків
• Використовуйте різні Randomекземпляри на нитку

Або може бути добре; але зміна одного екземпляра з кількох абонентів одночасно - це просто клопотання.

lockДосягає перші (і простіше) ці підходи; однак, може бути інший підхід:

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

це тоді за ниткою, тому вам не потрібно синхронізувати.

Для зручності повторного використання у вашій програмі може допомогти статичний клас.

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

Потім можна використовувати статичний випадковий екземпляр з таким кодом, як

StaticRandom.Instance.Next(1, 100);

Рішення Марка може бути досить дорогим, оскільки його потрібно синхронізувати щоразу.

Ми можемо обійти необхідність синхронізації, використовуючи специфічний для потоку шаблон зберігання:

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

Виміряйте дві реалізації та ви побачите значну різницю.

Моя відповідь звідси :

Просто повторюючи правильне рішення :

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

Тож ви можете зателефонувати:

var i = Util.GetRandom();

всі по всьому.

Якщо вам точно потрібен справжній статичний метод без громадянства для генерування випадкових чисел, ви можете покластися на a Guid.

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

Це буде трохи пізніше, але може бути набагато більш випадковим, ніж Random.Next, принаймні, з мого досвіду.

Але не :

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

Потрібне створення об'єкта зробить його більш повільним, особливо під циклом.

І ніколи :

new Random().Next();

Мало того, що він повільніше (всередині циклу), його випадковість ... ну, не дуже добре, на мене.

Я вважаю за краще використовувати наступний клас для генерування випадкових чисел:

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

1) Як сказав Марк Гравелл, спробуйте використовувати ОДИН випадковий генератор. Завжди здорово додавати це до конструктора: System.Environment.TickCount.

2) Одна порада. Скажімо, ви хочете створити 100 об'єктів і припустимо, що кожен з них повинен мати власний генератор випадкових випадків (зручно, якщо ви обчислюєте ЗАВАНТАЖЕННЯ випадкових чисел за дуже короткий проміжок часу). Якщо ви зробите це в циклі (генерація 100 об'єктів), ви можете зробити це так (щоб забезпечити повну випадковість):

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

Ура.

Кожен раз, коли ви виконуєте

Random random = new Random (15);

Не має значення, чи виконаєте ви це мільйони разів, ви завжди будете використовувати одне і те ж насіння.

Якщо ви використовуєте

Random random = new Random ();

Ви отримуєте різну послідовність випадкових чисел, якщо хакер здогадається про насіння, а ваш алгоритм пов’язаний із безпекою вашої системи - ваш алгоритм порушений. I ти виконуєш мульти. У цьому конструкторі насіння задається системним годинником, і якщо кілька екземплярів буде створено за дуже короткий проміжок часу (мілісекунд), можливо, вони можуть мати одне насіння.

Якщо вам потрібні безпечні випадкові числа, ви повинні використовувати клас

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

Використання:

int randomNumber = Next(1,100);

просто оголосимо змінну класу Random так:

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

якщо ви хочете отримувати різні випадкові числа кожного разу зі свого списку, тоді використовуйте

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

Кожен раз, оголошуючи Random r = new Random()один раз.

Рішень існує безліч, ось одне: якщо ви хочете лише стерти цифри, викресліть букви, і метод отримує випадкову і довжину результату.

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