乱数ジェネレーターは1つの乱数のみを生成します

次の機能があります。

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

ランタイム中にそのループをデバッガーでステップすると、異なる値が得られます（これが私が望んでいることです）。ただし、そのコードの2行下にブレークポイントを配置すると、mac配列のすべてのメンバーの値が等しくなります。

なぜそれが起こるのですか？

実行するたびにnew Random()、時計を使用して初期化されます。つまり、タイトなループでは、同じ値が何度も得られます。単一の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いません。したがって、2つの有効なアプローチがあります。

• 異なるスレッドから同時にアクセスしないように同期する
• 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);

Markのソリューションは毎回同期する必要があるため、非常に高価になる可能性があります。

スレッド固有のストレージパターンを使用することで、同期の必要性を回避できます。

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

2つの実装を測定すると、大きな違いが見られます。

ここから私の答え：

適切なソリューションを繰り返すだけ：

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

だからあなたは呼び出すことができます：

var i = Util.GetRandom();

全体を通して。

乱数を生成するために真のステートレス静的メソッドが厳密に必要な場合は、に依存できます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）マークグラベルが言ったように、1つのランダムジェネレーターを使用してみてください。これをコンストラクターSystem.Environment.TickCountに追加することは常にクールです。

2）1つのヒント。100個のオブジェクトを作成し、それぞれに独自のランダムジェネレータが必要であるとします（非常に短い期間で乱数のLOADSを計算する場合に便利です）。これをループ（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 ();

ハッカーが種を推測し、アルゴリズムがシステムのセキュリティに関連している場合、異なる乱数シーケンスが得られます-アルゴリズムが壊れています。マルチを実行します。このコンストラクターでは、シードはシステムクロックによって指定され、いくつかのインスタンスが非常に短い時間（ミリ秒）で作成される場合、それらが同じシードを持つ可能性があります。

安全な乱数が必要な場合は、クラスを使用する必要があります

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

毎回1回宣言することによってRandom r = new Random()。

解決策はたくさんありますが、ここでは1つです。数字だけを消去したい場合、メソッドはランダムに結果の長さを受け取ります。

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