C# 如何生成随机整数？

如何在C#中生成随机整数？

注意

new random（）

是在当前时间戳上播种的

如果只想生成一个数字，可以使用：

new Random（）.Next（int.MinValue，int.MaxValue）

有关更多信息，请查看课程，但请注意：

但是，由于时钟分辨率有限，因此使用无参数构造函数创建不同的连续随机对象会创建随机数生成器，生成相同的随机数序列

因此，不要使用此代码生成一系列随机数。

用于创建随机数。（当然是伪随机的）

例如：

Random rnd=new Random（）；
整月=下一个月（1，13）；//创建一个介于1和12之间的数字
int dice=rnd.Next（1,7）；//创建一个介于1和6之间的数字
int card=rnd.Next（52）；//创建一个介于0和51之间的数字

如果要创建多个随机数，应保留

random

实例并重用它。如果您创建的新实例在时间上过于接近，它们将产生与随机生成器从系统时钟中播种相同的随机数序列。

您可以在他为伪随机数构建的MiscUtil类库中使用Jon Skeet的方法

using MiscUtil;
...

for (int i = 0; i < 100; 
    Console.WriteLine(StaticRandom.Next());

使用MiscUtil；
...
对于（int i=0；i<100；
Console.WriteLine（StaticRandom.Next（））；

每次执行new Random（）时，它都会被初始化。这意味着在一个紧密循环中，您会多次获得相同的值。您应该保留一个Random实例，并在同一实例上继续使用Next

//Function to get random number
private static readonly Random getrandom = new Random();

public static int GetRandomNumber(int min, int max)
{
    lock(getrandom) // synchronize
    {
        return getrandom.Next(min, max);
    }
}

修改了来自的答案

如果您有权访问与Intel Secure Key兼容的CPU，则可以使用这些库生成真正的随机数和字符串：和

只需从下载最新版本，包括Jebtek.RdRand并为其添加using语句。然后，您只需执行以下操作：

// Check to see if this is a compatible CPU
bool isAvailable = RdRandom.GeneratorAvailable();

// Generate 10 random characters
string key       = RdRandom.GenerateKey(10);

 // Generate 64 random characters, useful for API keys 
string apiKey    = RdRandom.GenerateAPIKey();

// Generate an array of 10 random bytes
byte[] b         = RdRandom.GenerateBytes(10);

// Generate a random unsigned int
uint i           = RdRandom.GenerateUnsignedInt();

如果您没有兼容的CPU来执行代码，只需使用rdrand.com上的RESTful服务即可。项目中包含了RdRandom包装器库，您只需执行此操作（注册时可获得1000个免费调用）：

string ret=Randomizer.GenerateKey（，“”）；
uint-ret=随机化器.GenerateUInt（“”）；
字节[]ret=随机化器。生成字节（，“”）；

在第二个括号中填入所需的值 确保您已通过写入道具和双制表符来设置名称，以生成代码，而这是正常的：

Random random = new Random();
int randomNumber = random.Next()

大多数情况下，您都希望控制限制（最小和最大数量）。因此，您需要指定随机数的开始和结束位置

Next（）

方法接受两个参数，min和max

所以如果我想让我的随机数在5到15之间，我就这么做

int randomNumber = random.Next(5, 16)

---

这是我使用的类。类似于

RandomNumber.generateradom（1666）

---

除了COBOL答案，我已经尝试了所有这些解决方案…哈哈

这些解决方案都不够好。我需要在fast for int循环中使用随机数，即使在很宽的范围内，我也会得到大量重复值。在适应了太长时间的随机结果后，我决定最终一劳永逸地解决这个问题

这都是关于种子的

我通过解析Guid中的非数字来创建一个随机整数，然后用它来实例化我的随机类

public int GenerateRandom(int min, int max)
{
    var seed = Convert.ToInt32(Regex.Match(Guid.NewGuid().ToString(), @"\d+").Value);
    return new Random(seed).Next(min, max);
}

更新：如果只实例化一次随机类，则不需要种子设定。因此，最好创建一个静态类并取消该类的方法

public static class IntUtil
{
   private static Random random;

   private static void Init()
   {
      if (random == null) random = new Random();
   }

   public static int Random(int min, int max)
   {
      Init();
      return random.Next(min, max);
   }
}

然后可以像这样使用静态类

for(var i = 0; i < 1000; i++)
{
   int randomNumber = IntUtil.Random(1,100);
   Console.WriteLine(randomNumber); 
}

for（变量i=0；i<1000；i++）
{
int randomNumber=IntUtil.Random（1100）；
控制台写入线（随机数）；
}

---

我承认我更喜欢这种方法。

内置的

Random

类（System.Random）生成的数字会生成伪随机数

Random random = new Random ();
int randomNumber = random.Next (lowerBound,upperBound);

如果你想要真随机数，我们能得到的最接近的是“安全伪随机生成器”，它可以使用C中的加密类生成，例如

RNGCryptoServiceProvider

---

即便如此，如果你仍然需要真正的随机数，你也需要使用外部源，例如用于放射性衰变的设备，作为随机数发生器的种子。因为，根据定义，任何纯算法方法生成的数字都不能是真正的随机数。

尝试以下简单步骤来创建随机数：

创建函数：

private int randomnumber(int min, int max)
{
    Random rnum = new Random();
    return rnum.Next(min, max);
}

在要使用随机数的位置使用上述函数。假设要在文本框中使用该函数

textBox1.Text = randomnumber(0, 999).ToString();

---

0是最小值，999是最大值。您可以将值更改为您想要的任何值。

我使用下面的代码获得一个随机数（不推荐）：

创建一个随机对象

Random rand = new Random();

并使用它

int randomNumber = rand.Next(min, max);

---

您不必每次需要一个随机数时都初始化

new Random（）

，只需启动一个随机数，然后在循环中或任何需要的时候使用它

RNGCryptoServiceProvider类（或）

它实现了IDisposable

using (RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider())
{
   byte[] randomNumber = new byte[4];//4 for int32
   rng.GetBytes(randomNumber);
   int value = BitConverter.ToInt32(randomNumber, 0);
}

---

根据定义，计算机通过确定性过程计算出的数字不能是随机的

如果你想要一个真正的随机数，随机性来自大气噪音或放射性衰变

---

您可以尝试使用RANDOM.ORG（它会降低性能）

为什么不使用

int randomNumber=RANDOM.Range（开始范围、结束范围）

？

我想演示每次使用一个新的随机生成器时会发生什么。假设您有两个方法或两个类，每个方法或类都需要一个随机数。您天真地编写了如下代码：

public class A
{
    public A()
    {
        var rnd=new Random();
        ID=rnd.Next();
    }
    public int ID { get; private set; }
}
public class B
{
    public B()
    {
        var rnd=new Random();
        ID=rnd.Next();
    }
    public int ID { get; private set; }
}

你认为你会得到两个不同的ID吗？不

class Program
{
    static void Main(string[] args)
    {
        A a=new A();
        B b=new B();

        int ida=a.ID, idb=b.ID;
        // ida = 1452879101
        // idb = 1452879101
    }
}

解决方案是始终使用单个静态随机发生器。如下所示：

public static class Utils
{
    public static readonly Random random=new Random();
}

public class A
{
    public A()
    {
        ID=Utils.random.Next();
    }
    public int ID { get; private set; }
}
public class B
{
    public B()
    {
        ID=Utils.random.Next();
    }
    public int ID { get; private set; }
}

---

这个问题看起来很简单，但是

using (RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider())
{
   byte[] randomNumber = new byte[4];//4 for int32
   rng.GetBytes(randomNumber);
   int value = BitConverter.ToInt32(randomNumber, 0);
}

public class A
{
    public A()
    {
        var rnd=new Random();
        ID=rnd.Next();
    }
    public int ID { get; private set; }
}
public class B
{
    public B()
    {
        var rnd=new Random();
        ID=rnd.Next();
    }
    public int ID { get; private set; }
}

class Program
{
    static void Main(string[] args)
    {
        A a=new A();
        B b=new B();

        int ida=a.ID, idb=b.ID;
        // ida = 1452879101
        // idb = 1452879101
    }
}

public static class Utils
{
    public static readonly Random random=new Random();
}

public class A
{
    public A()
    {
        ID=Utils.random.Next();
    }
    public int ID { get; private set; }
}
public class B
{
    public B()
    {
        ID=Utils.random.Next();
    }
    public int ID { get; private set; }
}

var random = new Random();
int randomnumber = random.Next()

using (RNGCryptoServiceProvider rg = new RNGCryptoServiceProvider()) 
{ 
    byte[] rno = new byte[5];    
    rg.GetBytes(rno);    
    int randomvalue = BitConverter.ToInt32(rno, 0); 
}

Random random = new Random ();
int randomNumber = random.Next (lowerBound,upperBound);

var rnd = new Random(11111111); //note: seed value is 11111111

string randomDigits = rnd.Next();

var requestNumber = $"SD-{randomDigits}";

int GetRandomNumber(int min, int max)
{
    Random rand = new Random((int)DateTime.Now.Ticks);
    return rand.Next(min, max);
}

Random rand = new Random(); //reuse this if you are generating many
double u1 = 1.0-rand.NextDouble(); //uniform(0,1] random doubles
double u2 = 1.0-rand.NextDouble();
double randStdNormal = Math.Sqrt(-2.0 * Math.Log(u1)) *
         Math.Sin(2.0 * Math.PI * u2); //random normal(0,1)
double randNormal =
         mean + stdDev * randStdNormal; //random normal(mean,stdDev^2)

public class RandomGenerator  
{  
    public int RandomNumber(int min, int max)  
    {  
        var random = new Random();  
        return random.Next(min, max);  
    }  

    public string RandomString(int size, bool lowerCase)  
    {  
        var builder = new StringBuilder();  
        var random  = new Random();  
        char ch;  

        for (int i = 0; i < size; i++)  
        {  
            ch = Convert.ToChar(Convert.ToInt32(Math.Floor(26 * random.NextDouble() + 65)));  
            builder.Append(ch);  
        }  

        if (lowerCase)  
            return builder.ToString().ToLower();  
        return builder.ToString();  
    }  
}

using System;
using System.Security.Cryptography;

public class Program
{
    public static void Main()
    {
        var random = new Random(GetSeed());
        Console.WriteLine(random.Next());
    }

    public static int GetSeed() 
    {
        using (var rng = new RNGCryptoServiceProvider())
        {
            var intBytes = new byte[4];
            rng.GetBytes(intBytes);
            return BitConverter.ToInt32(intBytes, 0);
        }
    }
}

// Somewhat better code...
Random rng = new Random();
for (int i = 0; i < 100; i++)
{
    Console.WriteLine(GenerateDigit(rng));
}
...
static int GenerateDigit(Random rng)
{
    // Assume there'd be more logic here really
    return rng.Next(10);
}

BigInteger randomVal = BigInteger.Abs(BigInteger.Parse(Guid.NewGuid().ToString().Replace("-",""), NumberStyles.AllowHexSpecifier));

static public class CachedService<T> where T : new() {
    static public T Get { get; } = new T();
}

CachedService<System.Random>.Get.Next(999);