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
=新线程本地（（）=>新随机（））；

---

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

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

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；
对于（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);
    }
}


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

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

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

而从不：

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

它不仅速度较慢（在循环中），而且随机性……据我所知，不是很好。
有很多解决方案，这里有一个：如果您只想删除字母的数字，那么该方法将接收随机数和结果长度

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

公共字符串生成器域（随机或随机，int-iLongitudPin）
{
字符串schracters=“12345678abcdefghijklmnpqrstuvwxyz123456789”；
int ILENGHT=Schracters.长度；
字符；
int-iLongitudNuevaCadena=iLongitudPin；
字符串sRandomResult=“”；
对于（int i=0；i
每次执行

Random random = new Random (15);

如果你执行它数百万次，这并不重要，你将始终使用相同的种子

如果你使用

Random random = new Random ();

如果黑客猜测种子，并且您的算法与系统的安全性相关，则会得到不同的随机数序列-您的算法已被破坏。我将执行mult。在此构造函数中，种子由系统时钟指定，并且如果在很短的时间段（毫秒）内创建了多个实例它们可能有相同的种子

如果您需要安全的随机数，则必须使用该类

System.Security.Cryptography.RNGCryptoServiceProvider

用法：

int randomNumber = Next(1,100);

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

//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

加载表单时，我使用Randomize（）方法确保每次运行时不会总是获得相同的随机数序列。
始终获得正随机数

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

var nexnumber=Guid.NewGuid（）.GetHashCode（）；
如果（nexnumber<0）
{
nexnumber*=-1；
}
一般来说，所有静态方法都应该是线程安全的，因为很难保证多个线程不会同时调用它。通常不需要使实例（即非静态）方法是线程安全的。@Florin-这两者之间没有“基于堆栈”的区别。静态字段也一样多“外部状态”，并且将在调用方之间完全共享。对于实例，不同的线程很有可能有不同的实例（一个公共模式）。对于静态，可以保证它们都共享（不包括[ThreadStatic]）。为什么不能使用
锁（随机）
？@Dan如果对象从未公开：您可以