随机数生成器仅生成一个随机数

我有以下功能：

//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()使用时钟初始化它。这意味着在紧密的循环中，您会多次获得相同的值。您应该保留一个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);

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

测量这两个实现，您应该会看到很大的不同。

从我的答案在这里：

只是重申正确的解决方案：

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）正如Marc Gravell所说，请尝试使用一个随机生成器。将其添加到构造函数中总是很酷的：System.Environment.TickCount。

2）一个提示。假设您要创建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

每次通过声明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);
}