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

每次执行此操作时，都会使用时钟进行初始化。这意味着在紧密循环中，您多次获得相同的值。您应该保留一个 Random 实例，并在同一实例上继续使用 Next。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);
    }
}

---

编辑（见评论）：为什么我们需要这里？lock

基本上，将更改实例的内部状态。如果我们从多个线程同时这样做，你可能会争辩说“我们只是让结果更加随机”，但我们实际上所做的是破坏内部实现，我们也可能开始从不同的线程获得相同的数字，这可能是一个问题 - 也可能不是。然而，对内部发生的事情的保证是更大的问题;因为不对线程安全做出任何保证。因此，有两种有效的方法：NextRandomRandom

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

两者都可以;但是，同时将多个调用方的单个实例互斥只是自找麻烦。

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

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）正如Marc Gravel所说，尝试使用一个随机生成器。将它添加到构造函数中总是很酷的：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 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();

它不仅速度较慢（在循环内），而且它的随机性是......好吧，在我看来不是很好。.

有很多解决方案，这里有一个：如果你只想数字擦除字母，该方法会收到一个随机数和结果长度。

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

你会得到不同的随机数序列，如果黑客猜到了种子，而你的算法与你的系统安全有关——你的算法被破坏了。我你执行 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);

我通过使用 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"));

性能：在我的 PC 上生成 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 开始，该类现在配备了一个名为 Shared 的静态属性：Random

提供线程安全的 Random 实例，可从任何线程并发使用。

你可以这样使用它：

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

访问线程安全对象的开销很小，因此，如果您计划 尽可能快地在单个线程上生成数百万个随机数，最好创建一个专用实例，而不是依赖 .RandomShared

为什么会这样？

如前所述，每次调用时，您都会获得使用相同时钟初始化的 Random 类的新副本（因此它返回相同的值）。new Random()

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

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

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