我有如下函数：
//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());
这是针对每个线程的，因此您不需要同步。
lock(random)？ - Dan Bechardrandom.Next() 调用也在 lock (syncObject) 内时，lock (syncObject) 才会有所帮助。如果即使使用了正确的 lock 语句，你描述的场景仍然发生，那么这种情况在单线程环境下（例如 Random 存在微妙的错误）也极有可能发生。 - Luaan为了在整个应用程序中方便地重复使用，静态类可能会有所帮助。
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);
}
}
测量这两个实现，你应该会看到显著的差异。
Random 实例来获取种子是个好主意。还要注意，代码可以进一步简化，使用在 .NET 4 中引入的 ThreadLocal<T> 类（正如 Phil 在下面所写的那样）。 - vgru_local 是 ThreadStatic 的，为什么要将它复制到/从 var localBuffer 中？这是一种性能优化吗？也就是说，访问 ThreadStatic 变量的性能是否比访问常规变量显著更昂贵？（如果是这样，在典型情况下，这可能会抵消对 lock 的所谓优势。如果不是，则可以简化代码。） - ToolmakerSteve我的回答来自这里：
只是重申正确的解决方案：
namespace mySpace
{
public static class Util
{
private static Random 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();
不仅它在循环内速度较慢，而且它的随机性... 在我看来并不是很好。
Random 和 Guid.NewGuid().GetHashCode() 通过 Ent (http://www.fourmilab.ch/random/)，两者都是类似随机的。`new Random(Guid.NewGuid().GetHashCode())同样有效，使用同步的“主”Random生成“子”Random` 的种子也可以。当然，这取决于您的系统如何生成 Guids - 对于我的系统，它们非常随机，对于其他系统甚至可能是加密随机。所以现在 Windows 或 MS SQL 看起来都很好。但 Mono 和/或移动设备可能会有所不同。 - LuaanGetHashCode 是从其字符串表示派生的。输出对我来说相当随机。 - nawfal我更愿意使用以下类来生成随机数：
byte[] random;
System.Security.Cryptography.RNGCryptoServiceProvider prov = new System.Security.Cryptography.RNGCryptoServiceProvider();
prov.GetBytes(random);
public static int Next(int min, int max) ...。但是为了提高性能，修改他的代码将new移出Next方法 - 参见我的评论。 - ToolmakerSteve1）就像Marc Gravell所说，尽量只使用一个随机数生成器。将以下内容添加到构造函数中效果更佳：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(Environment.TickCount)。 - AlstyRandom()构造函数两次，您将获得两个随机生成器，它们每个都生成完全相同的随机数序列。可能不是您想要的！上述逻辑(#2)使用种子TickCount+0、TickCount+1等 - 因此生成器都是不同的。 - ToolmakerSteve每次执行时
Random random = new Random (15);
无论您执行多少次，都将使用相同的种子。
如果您使用
Random random = new Random ();
如果黑客猜测了种子并且您的算法与系统安全有关，则您的算法将被破解，并且会获得不同的随机数序列。 如果您执行mult，那么在此构造函数中，种子是由系统时钟指定的，如果在非常短的时间内（毫秒级别）创建了多个实例，则可能会具有相同的种子。
如果您需要安全的随机数字，则必须使用以下类：
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);
Next 上调用 new RNGCryptoServiceProvider() 是过度的。相反，声明 private static RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider(); 然后移除 using 包装器；只需在该静态上调用 rng.GetNonZeroBytes(intBytes);。 - ToolmakerSteve从.NET 6开始，Random类现在配备了一个名为Shared的静态属性:
提供一个线程安全的随机实例，可在任何线程中并发使用。
你可以像这样使用它:
// Function to get random number
public static int RandomNumber(int min, int max)
{
return Random.Shared.Next(min, max);
}
访问线程安全的对象会有一定开销，因此如果您计划在单个线程上尽可能快地生成数百万个随机数，最好创建一个专用的 Random 实例，而不是依赖于 Shared。
new Random()都会得到一个新的Random类副本，它使用相同的时钟进行初始化（因此返回相同的值）。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之间进行选择。
new Random().Next((int)0xFFFF, (int)0xFFFFFF) % 256);并不能生成比.Next(0, 256)更好的“随机”数。 - bohdan_trotsenkoRand.Next(int, int)方法，可以在不锁定或遇到种子重用问题的情况下静态访问随机值。 - ChaseMedallion