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

如果我在运行时使用调试器步进该循环，我会得到不同的值，这正是我想要的。 但是，如果我在代码下面两行放置断点，mac数组的所有成员的值都相等

为什么会发生这种情况？

每次执行新的随机操作时，都会使用时钟进行初始化。这意味着在一个紧密的循环中，你会多次得到相同的值。您应该保留一个实例，并在同一实例上继续使用

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

编辑-查看注释：为什么我们需要一个锁

基本上，接下来将更改随机实例的内部状态。如果我们同时从多个线程执行此操作，您可能会认为我们只是使结果变得更加随机，但我们实际执行的操作可能会破坏内部实现，而且我们还可能从不同线程获得相同的数字，这可能是个问题，也可能不是。不过，更大的问题是保证内部发生的事情；因为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);

---

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

---

干杯。

马克的解决方案可能非常昂贵，因为它每次都需要同步

我们可以通过使用特定于线程的存储模式来解决同步问题：

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

我的回答来自：

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

所以你可以打电话：

var i = Util.GetRandom();

自始至终

如果您严格地需要一个真正的无状态静态方法来生成随机数，那么您可以依赖Guid

它会稍微慢一点，但可能会比随机的更随机。接下来，至少从我的经验来看

但不是：

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

而且永远不会：

---

它不仅在一个循环中慢，而且它的随机性是。。。根据我的说法，这不是很好。

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

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

---

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

始终获得正随机数

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

---

一般来说，所有静态方法都应该是线程安全的，因为很难保证多个线程不会同时调用它。通常不需要使实例（即非静态方法）成为线程安全的。@Florin-基于这两种方法的重新堆栈没有区别。静态字段和外部状态一样，在调用方之间绝对共享。对于实例，不同的线程很有可能有不同的实例和公共模式。使用statics，可以保证它们都共享，但不包括[ThreadStatic]。为什么不能使用lockrandom？@Dan如果对象从未公开过：可以。理论上的风险是，其他线程正在以您意想不到的方式锁定它。@smiron很可能您也只是在使用锁的随机外部。锁定并不能阻止对wha的所有访问

---

它只是确保同一实例上的两个lock语句不会同时运行。所以，只有当所有随机调用都在lock syncObject中时，lock syncObject才会有帮助。接下来的调用也在lock syncObject中。如果您描述的场景即使在正确使用锁的情况下也会发生，那么它也极有可能发生在单线程场景中，例如Random被巧妙地破坏。我不是一个失败的投票者，但请注意，标准PNRG确实满足了一个真正的需要，即能够从已知种子重复生成序列。有时，真正的加密RNG的纯粹成本太高了。有时需要加密。可以说，马匹是为了课程。根据这个类是线程安全的，所以这是它的优势。使用它，两个随机字符串成为一个相同字符串的概率是多少？如果字符串只有3个字符，我想这种情况很有可能发生，但是如果长度为255个字符，那么有可能有相同的随机字符串，或者可以从算法中保证不会发生这种情况吗？@LyubomirVelchev-从数学上讲，不可能设计一个函数、一个硬件甚至一个理论结构这保证了两个独立生成的有限长度字符串永远不会相同。这不可能：选择的数量是有限的。给定n个可能的字符串，存在并且必须存在两个独立字符串相同的1/n概率。是的，这意味着任何加密方案都不是100%安全的；然而，如果某件事在宇宙的生命周期内发生两次的几率足够低。。。在实践中已经足够好了。包含基于RNGCryptoServiceProvider的更完整的代码段。请参阅公共静态int Nextint min、int max。。。。但是为了提高性能，请修改他的代码，将新方法移出下一个方法-请参见我的评论。我将把System.Environment.TickCount移出循环。如果它在您迭代时闪烁，那么您将有两个项目初始化为同一种子。另一种选择是将tickcount与i以不同的方式组合，例如System.Environment.tickcount如果我理解正确：你的意思是，这可能发生，System.Environment.tickcount+i可能会产生相同的值吗？编辑：当然，循环中不需要有tickcount。我的错误：。默认的随机构造函数调用RandomEnvironment.TickCountanyway@Alsty-有用的观察-如果只有一个全局随机发生器。但是，如果在同一时间调用默认的随机构造函数两次，将得到两个随机生成器，每个生成器生成完全相同的随机数序列。可能不是你想要的！上面的逻辑2使用种子TickCount+0、TickCount+1等-因此生成器都是不同的。锁在没有竞争时非常便宜。。。即使有争议，我也希望现在对数字代码做些什么，在最有趣的场景中使锁的成本相形见绌。同意，这解决了锁的问题，但这不是一个简单问题的高度复杂的解决方案：你需要编写两行代码来生成一个随机数，而不是一个。节省阅读一行简单的代码真的值得吗？+1使用额外的全局随机实例获取种子是一个好主意。还请注意，可以使用.NET4中引入的ThreadLocal类进一步简化代码。既然local是ThreadStatic，为什么要将它复制到var localBuffer中/从中复制？这是性能优化吗？也就是说，访问ThreadStatic变量的性能是否比访问常规变量的成本要高得多？如果是这样的话，在典型情况下，这可能会抵消所谓的相对于锁的优势。如果没有，则代码可以简化。@ToolmakerSteve是的，堆栈比TSS更快。我不担心与锁定相比的成本，因为锁定引入了100到1000个周期。我的解决方案的问题是，当分支预测器出错时，由于管道和指令缓存的刷新，If语句引入的分支可能会花费100多个周期。我不同意Guid的情况。Random类实现了均匀分布。Guid中的情况并非如此。Guid的目标是唯一的而不是均匀分布的，它的实现大部分时间是基于某些硬件/机器属性的，这与。。。随机性。如果您无法证明Guid生成的一致性，那么将其作为随机项使用是错误的，哈希将是距离一致性的又一步。同样，碰撞也不是问题：碰撞的均匀性才是关键。关于不再在硬件上生成Guid的问题，我将使用RTFM，我的坏消息是：有什么参考吗？对Random有两种理解：1。缺乏模式或2。1中包含的概率分布2描述的进化后缺乏模式。您的Guid示例在案例1中是正确的，而不是在案例2中。相反：Random类与案例2匹配，因此案例1也是如此。你可以

---

n如果不在案例2中，则仅用Guid+哈希替换Random的用法。案例1可能足以回答这个问题，然后，Guid+Hash就可以正常工作了。但ps并没有明确说明：@Askolein只是为了一些测试数据，我通过Ent运行了几个批次的Random和Guid.NewGuid.GetHashCode，它们都是类似的随机数据。new RandomGuid.NewGuid.GetHashCode的工作原理与使用同步主随机数为子随机数生成种子的工作原理一样。。当然，这确实取决于您的系统如何生成GUID——对于我的系统来说，它们是非常随机的，而对于其他系统来说，甚至可能是加密随机的。因此，Windows或MS SQL现在看起来不错。Mono和/或mobile可能不同，但是。@EdB正如我在前面的评论中所说的，虽然Guid的大数字是唯一的，但是.NET中Guid的GetHashCode是从它的字符串表示形式派生出来的。根据我的喜好，输出非常随机。使用new random.nexting0xffff，int0xFFFFFF%256；不会产生比.Next0、256更好的随机数。您可能会发现这很有用。它提供了一个静态Rand.Nextint，int方法，该方法提供对随机值的静态访问，而无需锁定或遇到种子重用问题。无论您执行它数百万次，您都将始终使用相同的种子。除非你自己指定种子，否则这不是真的。正如你所说的那样，如果总是指定相同的种子，那么总是会生成相同的随机数序列。在我的回答中，如果您总是使用相同的种子，我将使用带参数的构造函数。Random类只生成伪随机数。如果有人发现你在算法中使用了什么种子，它可能会危及算法的安全性或随机性。使用RNGCryptoServiceProvider类，您可以安全地获得随机数。我已经更正了，非常感谢您的更正。每次都给新的RNGCryptoServiceProvider打电话太过分了。相反，声明私有静态RNGCryptoServiceProvider rng=new RNGCryptoServiceProvider；然后取下包装纸；只需调用rng.GetNonZeroBytesintBytes；在这个静态上。Re Random类只生成伪随机数。-所有软件算法都生成伪随机数序列。真正的随机性需要基于某些被认为是真正随机的物理现象的硬件。OTOH，加密算法经过精心设计和测试，以改善生成序列的统计分布，从而避免可能利用简单随机生成器的弱点进行暴力攻击。尽管在很多情况下使用过多，但我同意这会提供更好的统计分布。基本问题仍然是一样的——您传入的是一个随机实例，但您仍然希望调用方创建一个共享实例。如果调用方每次创建一个新实例，并且代码在时钟改变之前执行两次，那么您将得到相同的随机数。因此，这个答案仍然做出了可能是错误的假设。此外，拥有一个生成随机数的方法的全部意义在于封装——调用方法不必担心实现，它只关心返回一个随机数。这个问题是关于C，而不是VisualBasic.NET。尽管这两种语言都是.NET语言，而且从C访问VB函数是可能的，但也不是那么简单。这段代码没有使用问题中显而易见的随机对象，而且GUI的目标并不是如上所述的技术随机。

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

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

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