C# 仅生成一个随机数的随机数生成器

我有以下功能：

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

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

我如何称呼它：

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

byte[]mac=新字节[6]；
对于（int x=0；x<6；++x）
mac[x]=（字节）（杂项随机数（（int）0xFFFF，（int）0xFFFFFF）%256）；

如果我在运行时使用调试器步进该循环，我会得到不同的值（这是我想要的）。 但是，如果我在代码下面两行放置断点，那么

mac

数组的所有成员的值都相等

---

为什么会发生这种情况？

每次执行

new Random（）

时，它都会使用时钟进行初始化。这意味着在一个紧密的循环中，你会多次得到相同的值。您应该保留一个实例，并在相同的实例上继续使用

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

---

编辑（参见注释）：为什么我们需要一个

锁

基本上，

Next

将更改

Random

实例的内部状态。如果我们同时从多个线程执行此操作，您可能会说“我们只是让结果变得更加随机”，但我们实际执行的操作可能会破坏内部实现，而且我们还可能从不同线程获得相同的数字，这可能是个问题，也可能不是。不过，更大的问题是保证内部发生的事情；因为

Random

不保证线程安全。因此，有两种有效的方法：

• 同步，这样我们就不会从不同的线程同时访问它
• 每个线程使用不同的

  随机
  实例

两者都可以；但是同时对来自多个调用方的单个实例进行静音只是自找麻烦

lock

实现了这些方法中的第一种（也是更简单的）；然而，另一种方法可能是：

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

private static readonly ThreadLocal appRandom
=新线程本地（（）=>新随机（））；

---

这是每个线程的，因此不需要同步

每次执行

new Random（）

时，它都会使用时钟进行初始化。这意味着在一个紧密的循环中，你会多次得到相同的值。您应该保留一个实例，并在相同的实例上继续使用

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

---

编辑（参见注释）：为什么我们需要一个

锁

基本上，

Next

将更改

Random

实例的内部状态。如果我们同时从多个线程执行此操作，您可能会说“我们只是让结果变得更加随机”，但我们实际执行的操作可能会破坏内部实现，而且我们还可能从不同线程获得相同的数字，这可能是个问题，也可能不是。不过，更大的问题是保证内部发生的事情；因为

Random

不保证线程安全。因此，有两种有效的方法：

• 同步，这样我们就不会从不同的线程同时访问它
• 每个线程使用不同的

  随机
  实例

两者都可以；但是同时对来自多个调用方的单个实例进行静音只是自找麻烦

lock

实现了这些方法中的第一种（也是更简单的）；然而，另一种方法可能是：

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

private static readonly ThreadLocal appRandom
=新线程本地（（）=>新随机（））；

---

这是每个线程的，因此不需要同步

我宁愿使用以下类来生成随机数：

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

---

我宁愿使用以下类来生成随机数：

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

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

2） 一个提示。假设您想要创建100个对象，并且假设每个对象都应该有自己的随机生成器（如果您在很短的时间内计算随机数的负载，那么这很方便）。如果在循环中执行此操作（生成100个对象），可以这样执行（以确保完全随机）：

int-inMyRandSeed；
对于Marc Gravell所说的（inti=0；i1），尝试使用一个随机生成器。将其添加到构造函数中总是很酷的：System.Environment.TickCount

2） 一个提示。假设您想要创建100个对象，并且假设每个对象都应该有自己的随机生成器（如果您在很短的时间内计算随机数的负载，那么这很方便）。如果在循环中执行此操作（生成100个对象），可以这样执行（以确保完全随机）：

int-inMyRandSeed；
对于（int i=0；iMark的解决方案可能非常昂贵，因为它每次都需要同步

我们可以通过使用特定于线程的存储模式来解决同步问题：


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


测量这两种实现，您应该会看到显著的差异。
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);
    }
}


测量这两种实现，您应该会看到显著的差异。
为了在整个应用程序中易于重用，静态类可能会有所帮助

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

为了在整个应用程序中易于重用，静态类可能会有所帮助

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

我的回答来自：

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

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

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

new Random().Next();

所以你可以打电话：

var i = Util.GetRandom();

自始至终

如果您严格地需要一个真正的无状态静态方法来生成随机数，您可以依赖
Guid

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

它会稍微慢一点，但可能比随机的要随机得多。下一步，至少从我的经验来看

但是不是：

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

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

new Random().Next();

不必要的对象创建将使其速度变慢，尤其是在循环下

而且从不