每次执行新的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());

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

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

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

1） 正如马克·格雷维尔所说，尝试使用一个随机生成器。将此添加到构造函数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);

干杯

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

然后可以使用静态随机实例，代码如下

StaticRandom.Instance.Next(1, 100);

我的答案是：

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

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更随机。接下来，至少从我的经验来看。

但不是：

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

不必要的对象创建会使其变慢，尤其是在循环下。

永远不要：

new Random().Next();

不仅速度慢（在循环内），它的随机性……根据我的说法，不是很好。。

有很多解决方案，这里有一个：如果你只想要数字，那么就删除字母，然后方法会收到随机数和结果长度。

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

每次执行时

Random random = new Random (15);

执行数百万次并不重要，您将始终使用相同的种子。

如果您使用

Random random = new Random ();

如果黑客猜到了种子，并且你的算法与系统的安全性有关，你会得到不同的随机数序列——你的算法被破坏了。如果你处决了骡子。在该构造函数中，种子由系统时钟指定，如果在极短的时间（毫秒）内创建了多个实例，则它们可能具有相同的种子。

如果你需要安全的随机数，你必须使用这个类

System.Security.Cryptography.RGCryptoServiceProvider

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

我使用Rnd（）函数解决了这个问题：

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

当表单加载时，我使用Randomize（）方法确保每次运行都不会得到相同的随机数序列。

总是得到一个正随机数。

 var nexnumber = Guid.NewGuid().GetHashCode();
        if (nexnumber < 0)
        {
            nexnumber *= -1;
        }

在Visual Basic中，这是可行的（可能可以转换为C#，如果不是，DLL引用可以是一个解决方案）：

Private Function GetRandomInt(ByVal Min As Integer, ByVal Max As Integer) As Integer
     Static Generator As System.Random = New System.Random()
     Return Generator.Next(Min, Max)
End Function

我使用这个：

int randomNumber = int.Parse(Guid.NewGuid().ToString().FirstOrDefault(Char.IsDigit).ToString().Replace("\0", "0"));

性能：在我的电脑上生成100万个随机数：711毫秒。

如果Guid不包含任何数字（我不知道这是否可能），则将使用0作为结果。

您可以使用以下代码：

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与预处理器指令之间进行选择。

从.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类的新副本（因此它返回相同的值）。

现在，从.NET6开始，有一个易于使用且线程安全的替代方案：Random.Shared

在您的示例中，您可以删除所有函数RandomNumber，然后使用以下代码（使用相同的逻辑，但现在它工作正常）：

byte[] mac = new byte[6];
for (int x = 0; x < 6; ++x)
    mac[x] = (byte)(Random.Shared.Next(0, 255));