如何在 C# 中生成随机整数?
Random
class 用于创建随机数。 (当然是伪随机的。)。
例子:
Random rnd = new Random();
int month = rnd.Next(1, 13); // creates a number between 1 and 12
int dice = rnd.Next(1, 7); // creates a number between 1 and 6
int card = rnd.Next(52); // creates a number between 0 and 51
如果要创建多个随机数,则应保留 Random
实例并重复使用它。如果您创建新实例的时间太接近,它们将产生与随机生成器从系统时钟播种的相同系列的随机数。
这个问题看起来很简单,但答案有点复杂。如果您看到几乎每个人都建议使用 Random 类,有些人建议使用 RNG 加密类。但是什么时候选择什么。
为此,我们需要首先了解“随机”一词及其背后的哲学。
我鼓励您观看此视频,该视频深入探讨了使用 C# https://www.youtube.com/watch?v=tCYxc-2-3fY 的 RANDOMNESS 哲学
首先让我们了解随机性的哲学。当我们告诉一个人在红色、绿色和黄色之间进行选择时,内部会发生什么。是什么让一个人选择红色、黄色或绿色?
https://i.stack.imgur.com/nsoQL.png
一些初步的想法进入决定他选择的人的脑海中,它可以是最喜欢的颜色,幸运的颜色等等。换句话说,一些我们在 RANDOM 中称为 SEED 的初始触发器。这个 SEED 是起点,是促使他选择 RANDOM 值的触发器。
现在,如果种子很容易猜到,那么这些随机数被称为伪随机数,而当种子难以猜测时,这些随机数被称为安全随机数。
例如,一个人根据天气和声音组合选择颜色,那么很难猜出最初的种子。
https://i.stack.imgur.com/vQ9y5.png
现在让我做一个重要的声明:-
*“Random”类仅生成 PSEUDO 随机数,要生成 SECURE 随机数,我们需要使用“RNGCryptoServiceProvider”类。
https://i.stack.imgur.com/JJ93T.png
随机类从您的 CPU 时钟中获取种子值,这是非常可预测的。所以换句话说,C# 的 RANDOM 类生成伪随机数,下面是相同的代码。
var random = new Random();
int randomnumber = random.Next()
而 RNGCryptoServiceProvider
类使用操作系统熵来生成种子。操作系统熵是使用声音、鼠标点击和键盘计时、热温度等生成的随机值。下面是相同的代码。
using (RNGCryptoServiceProvider rg = new RNGCryptoServiceProvider())
{
byte[] rno = new byte[5];
rg.GetBytes(rno);
int randomvalue = BitConverter.ToInt32(rno, 0);
}
要了解操作系统熵,请观看 14:30 https://www.youtube.com/watch?v=tCYxc-2-3fY 的这段视频,其中解释了操作系统熵的逻辑。因此,简单地说,RNG Crypto 会生成 SECURE 随机数。
RandomNumberGenerator.Create()
而不是调用 RNGCryptoServiceProvider
的构造函数,因为它并非在所有平台上都可用。
每次执行 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);
}
}
Random
对象。在这两种情况下,我都得到了相同的随机数。使用 Pankaj 的方法并没有发生。也许这是随机,但我现在对此表示怀疑。我在同一秒内从不同的线程查询随机数。
请注意,new Random()
是在当前时间戳上播种的。
如果您只想生成一个数字,您可以使用:
new Random().Next( int.MinValue, int.MaxValue )
有关更多信息,请查看 Random 类,但请注意:
但是,由于时钟的分辨率有限,因此使用无参数构造函数来创建不同的 Random 对象以紧密连续地创建随机数生成器,这些生成器会生成相同的随机数序列
所以不要用这段代码来生成一系列随机数。
new Random()
是很重要的一点。
Random r = new Random();
int n = r.Next();
我想添加一个加密安全版本:
RNGCryptoServiceProvider 类(MSDN 或 dotnetperls)
它实现了 IDisposable。
using (RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider())
{
byte[] randomNumber = new byte[4];//4 for int32
rng.GetBytes(randomNumber);
int value = BitConverter.ToInt32(randomNumber, 0);
}
创建一个随机对象
Random rand = new Random();
并使用它
int randomNumber = rand.Next(min, max);
您不必每次需要一个随机数时都初始化 new Random()
,启动一个 Random 然后在循环或其他任何内容中根据需要多次使用它
new Random()
使用当前报价作为种子。当您在同一毫秒内(而不是滴答声)实例化多个实例时,您将获得相同的返回值。
您可以在他为伪随机数构建的 MiscUtil 类库中使用 Jon Skeet 的 StaticRandom 方法。
using MiscUtil;
...
for (int i = 0; i < 100;
Console.WriteLine(StaticRandom.Next());
我已经尝试了所有这些解决方案,不包括 COBOL 答案......哈哈
这些解决方案都不够好。我需要快速 for int 循环中的随机数,即使在非常宽的范围内,我也会得到大量重复值。在适应了太久的随机结果之后,我决定最终一劳永逸地解决这个问题。
一切都与种子有关。
我通过解析 Guid 中的非数字来创建一个随机整数,然后我用它来实例化我的 Random 类。
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);
}
更新:如果您实例化 Random 类一次,则不需要播种。所以最好创建一个静态类并调用一个方法。
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);
}
我承认我更喜欢这种方法。
内置 Random
类 (System.Random) 生成的数字会生成伪随机数。
如果您想要真正的随机数,我们可以获得的最接近的是“安全伪随机生成器”,它可以通过使用 C# 中的 Cryptographic 类(例如 RNGCryptoServiceProvider
)生成。
即便如此,如果您仍然需要真正的随机数,您将需要使用外部源(例如考虑放射性衰变的设备)作为随机数生成器的种子。因为,根据定义,纯算法生成的任何数字都不能是真正随机的。
来自 here 的修改答案。
如果您可以访问与 Intel 安全密钥兼容的 CPU,则可以使用以下库生成真正的随机数和字符串:https://github.com/JebteK/RdRand 和 https://www.rdrand.com/
只需从 here 下载最新版本,包括 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(<length>, "<key>");
uint ret = Randomizer.GenerateUInt("<key>");
byte[] ret = Randomizer.GenerateBytes(<length>, "<key>");
只是作为将来参考的说明。
如果您使用的是 .NET Core,则多个 Random 实例不会像以前那样危险。我知道这个问题来自 2010 年,但由于这个问题很老但有一些吸引力,我认为记录变化是一件好事。
你可以参考我之前提出的这个问题:
Did Microsoft change Random default seed?
基本上,他们已将默认种子从 Environment.TickCount
更改为 Guid.NewGuid().GetHashCode()
,因此如果您创建 2 个 Random 实例,它不应显示相同的数字(1:40 亿)。
您可以在此处查看 .NET Framework/.NET Core (2.0.0+) 的文件差异:https://github.com/dotnet/coreclr/pull/2192/commits/9f6a0b675e5ac0065a268554de49162c539ff66d
它不如 RNGCryptoServiceProvider 安全,但至少不会给你带来奇怪的结果。
通过@Enigmativity:
这现在已经过时了。使用 Guids 遭到了相当大的反对。代码现在是 Interop.GetRandomBytes((byte*)&result, sizeof(int));
Interop.GetRandomBytes((byte*)&result, sizeof(int));
。
如其他答案中所述,一种良好的安全方法是使用安全密码生成器。这里的所有示例都显示了 RNGCryptoServiceProvider
的用法,与我建议的解决方案相比,它编写的代码很长。
使用在密码学 API 之上编写的 RandomNumberGenerator。它与 RNGCryptoServiceProvider
一样安全且具有相同的随机性。
// Gives a random number for the integer range.
// You can simply update the parameters as your needs.
RandomNumberGenerator.GetInt32(int.MinValue, int.MaxValue);
RNGCryptoServiceProvider
已标记为 [Obsolete()]
,建议改为使用 RandomNumberGenerator
。
这是我使用的类。像RandomNumber.GenerateRandom(1, 666)
一样工作
internal static class RandomNumber
{
private static Random r = new Random();
private static object l = new object();
private static Random globalRandom = new Random();
[ThreadStatic]
private static Random localRandom;
public static int GenerateNewRandom(int min, int max)
{
return new Random().Next(min, max);
}
public static int GenerateLockedRandom(int min, int max)
{
int result;
lock (RandomNumber.l)
{
result = RandomNumber.r.Next(min, max);
}
return result;
}
public static int GenerateRandom(int min, int max)
{
Random random = RandomNumber.localRandom;
if (random == null)
{
int seed;
lock (RandomNumber.globalRandom)
{
seed = RandomNumber.globalRandom.Next();
}
random = (RandomNumber.localRandom = new Random(seed));
}
return random.Next(min, max);
}
}
虽然这没关系:
Random random = new Random();
int randomNumber = random.Next()
大多数情况下,您都希望控制限制(最小和最大数量)。因此,您需要指定随机数的开始和结束位置。
Next()
方法接受两个参数,最小值和最大值。
所以如果我希望我的随机数在 5 到 15 之间,我会这样做
int randomNumber = random.Next(5, 16)
我想演示每次使用新的随机生成器时会发生什么。假设您有两个方法或两个类,每个都需要一个随机数。你天真地把它们编码成:
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; }
}
RNGCryptoServiceProvider
是一个更好的选择。
根据定义,计算机通过确定性过程计算出的数字不能是随机的。
如果你想要一个真正的随机数,随机性来自大气噪声或放射性衰变。
您可以尝试例如 RANDOM.ORG(它会降低性能)
Random rand = new Random();
int name = rand.Next()
将您想要的任何值放在第二个括号中,确保您已通过编写 prop 和双制表符来设置名称以生成代码
对于强随机种子,我总是使用 CryptoRNG 而不是 Time。
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);
}
}
}
RNGCryptoServiceProvider
?
Random random = new Random ();
int randomNumber = random.Next (lowerBound,upperBound);
如果您希望 CSRNG 生成介于最小值和最大值之间的随机数,那么这是给您的。它将使用安全随机种子初始化 Random
类。
class SecureRandom : Random
{
public static byte[] GetBytes(ulong length)
{
RNGCryptoServiceProvider RNG = new RNGCryptoServiceProvider();
byte[] bytes = new byte[length];
RNG.GetBytes(bytes);
RNG.Dispose();
return bytes;
}
public SecureRandom() : base(BitConverter.ToInt32(GetBytes(4), 0))
{
}
public int GetRandomInt(int min, int max)
{
int treashold = max - min;
if(treashold != Math.Abs(treashold))
{
throw new ArithmeticException("The minimum value can't exceed the maximum value!");
}
if (treashold == 0)
{
throw new ArithmeticException("The minimum value can't be the same as the maximum value!");
}
return min + (Next() % treashold);
}
public static int GetRandomIntStatic(int min, int max)
{
int treashold = max - min;
if (treashold != Math.Abs(treashold))
{
throw new ArithmeticException("The minimum value can't exceed the maximum value!");
}
if(treashold == 0)
{
throw new ArithmeticException("The minimum value can't be the same as the maximum value!");
}
return min + (BitConverter.ToInt32(GetBytes(4), 0) % treashold);
}
}
我将假设您想要一个如下所示的均匀分布的随机数生成器。大多数编程语言(包括 C# 和 C++)中的随机数在使用它们之前都没有正确洗牌。这意味着您将一遍又一遍地获得相同的数字,这并不是真正随机的。为避免一遍又一遍地绘制相同的数字,您需要一个种子。通常,对于这个任务来说,时间滴答是可以的。请记住,如果您每次都使用相同的种子,您将一遍又一遍地获得相同的数字。因此,请尝试始终使用不同的种子。时间是种子的良好来源,因为它们总是在变化。
int GetRandomNumber(int min, int max)
{
Random rand = new Random((int)DateTime.Now.Ticks);
return rand.Next(min, max);
}
如果您正在寻找正态分布的随机数生成器,则可以使用 Box-Muller 变换。检查 yoyoyoyosef 在随机高斯变量问题中的答案。由于您需要整数,因此您必须在最后将双精度值转换为整数。
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)
抱歉,OP 确实需要一个随机的 int
值,但如果您想要一个随机的 BigInteger
值,为了分享知识的简单目的,您可以使用以下语句:
BigInteger randomVal = BigInteger.Abs(BigInteger.Parse(Guid.NewGuid().ToString().Replace("-",""), NumberStyles.AllowHexSpecifier));
byte[] bytes = new byte[byteCount]; random.NextBytes(bytes); BigInteger value = new BigInteger(bytes);
或使用对 Random.Next((int) '0', ((int) '9') + 1)
的重复调用来构建随机数字的 string
并对其进行解析。 Guid
的这种(ab)用法是非正统的,并且几乎可以保证仅返回天文数字(因此不是真正的“随机”)。此外,the documentation 建议“......应用程序不将 NewGuid
方法用于加密目的。”
有许多实用程序函数或服务以与 System.Random 相同的方式更好地缓存,因此它适用于通用实现:
static public class CachedService<T> where T : new() {
static public T Get { get; } = new T();
}
用于随机(或类似):
CachedService<System.Random>.Get.Next(999);
在 C# 中获取随机数
Random rand = new Random();
int i = rand.Next();
如果要生成随机数,可以使用一些随机数生成器,例如
https://arandomgenerator.com/random-number-generator-decimal/
https://random.org 等
Random r=new Random();
int Numbers=r.next(min value, max value);
Next
,而不是 next
,因此无法编译。此外,上限参数是exclusive,因此 r.Next(minValue, maxValue);
将返回的最大数字实际上是 maxValue - 1
。对于存储单个数字的变量,Numbers
也是一个坏名字。最后,也是最重要的,Random
类的这种基本用法已被许多其他答案所涵盖。
为什么不使用 int randomNumber = Random.Range(start_range, end_range)
?
System.Random
会有所帮助。
重复使用一个 Random 实例
// 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);
}
本文着眼于为什么随机性会导致如此多的问题,以及如何解决这些问题。 http://csharpindepth.com/Articles/Chapter12/Random.aspx
Random
不是线程安全类。如果您创建单个实例,则应在锁定机制后面限制对它的访问。
尝试这些简单的步骤来创建随机数:
创建函数:
private int randomnumber(int min, int max)
{
Random rnum = new Random();
return rnum.Next(min, max);
}
在要使用随机数的位置使用上述功能。假设您想在文本框中使用它。
textBox1.Text = randomnumber(0, 999).ToString();
是最小值,999 是最大值。您可以将值更改为您想要的任何值。
我总是有一些方法可以生成有助于各种目的的随机数。我希望这也可以帮助你:
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();
}
}
不定期副业成功案例分享
rnd
声明为static
和/或在初始化代码时只设置一次。Random
进行加密......Random
有一些很好的“增强”,可以使您的随机性更加健壮: ericlippert.com/2019/02/04/fixing-random-part-2 和 codeblog.jonskeet.uk/2009/11/04/revisiting-randomness 。