我有以下功能：
//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数组的所有成员都具有相等的值。
为什么会这样？
当前回答
为了在整个应用程序中易于重用，静态类可能会有所帮助。
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);
其他回答
为什么会这样？
正如前面所回答的，每次调用new Random（）时，都会得到用相同时钟初始化的Random类的新副本（因此它返回相同的值）。
现在，从.NET6开始，有一个易于使用且线程安全的替代方案：Random.Shared
在您的示例中，您可以删除所有函数RandomNumber，然后使用以下代码（使用相同的逻辑，但现在它工作正常）：
byte[] mac = new byte[6];
for (int x = 0; x < 6; ++x)
mac[x] = (byte)(Random.Shared.Next(0, 255));
您可以使用以下代码：
public static class ThreadSafeRandom
{
private static readonly Random _global = new Random();
private static readonly ThreadLocal<Random> _local = new ThreadLocal<Random>(() =>
{
int seed;
lock (_global)
{
seed = _global.Next();
}
return new Random(seed);
});
public static Random Instance => _local.Value;
}
此代码可以按原样使用，也可以通过NuGet包ThreadSafeRandomizer使用。
编辑：从.NET 6.0开始，您可以改用Random.Shared.Next（）。您仍然可以使用上面的包，它可以在上面的代码或Random.Shared与预处理器指令之间进行选择。
每次执行新的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);
}
}
编辑（见评论）：为什么我们这里需要锁？
基本上，Next将更改Random实例的内部状态。如果我们同时从多个线程执行这一操作，你可能会认为“我们只是让结果变得更加随机”，但我们实际上正在做的事情可能会破坏内部实现，我们也可能会从不同的线程获得相同的数据，这可能是一个问题，也可能不是。不过，内部情况的保证是更大的问题；因为Random不保证线程安全。因此，有两种有效的方法：
同步，以便我们不会同时从不同的线程访问它每个线程使用不同的随机实例
两者都可以；但同时从多个调用方互斥一个实例只是自找麻烦。
锁实现了这些方法中的第一种（也是更简单的）；然而，另一种方法可能是：
private static readonly ThreadLocal<Random> appRandom
= new ThreadLocal<Random>(() => new Random());
这是每个线程，因此不需要同步。
总是得到一个正随机数。
var nexnumber = Guid.NewGuid().GetHashCode();
if (nexnumber < 0)
{
nexnumber *= -1;
}
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);
}
}
衡量这两种实现，您应该会看到显著的差异。
