C# 系统随机性是否会始终为跨平台的给定种子生成可预测的数字？

我知道Object.GetHashCode可以根据平台为同一对象返回不同的值（例如，相同的字符串）。因此，我不能依赖它来实现跨平台的简单散列

---

但我能依赖系统吗？随机的？无论我是否使用Microsoft.NET/Mono/x86/x64等，它是否会为给定的种子生成相同的结果？

不，您不能依赖跨平台或版本生成的一致值。来源（不太详细的内容不涉及此问题）：

random类中随机数生成器的实现不能保证在.NET Framework的主要版本中保持不变。因此，您不应该假设相同的种子将在不同版本的.NET Framework中产生相同的伪随机序列

正如Jeremy提到的，文档中指出，数字生成器不能保证在.NET版本中保持一致

然而，文档也告诉您

您可以通过从random类继承并提供随机数生成算法来实现自己的随机数生成器。要提供自己的算法，必须重写实现随机数生成算法的

Sample

方法。您还应该重写

Next（）

，

Next（Int32， Int32）

和

NextBytes

方法，以确保它们调用重写的示例方法。您不必重写

Next（Int32）

和

NextDouble

方法

利用它，我们可以创建我们自己的随机类，使用已知的固定算法。例如，我们可以去实现当前的随机算法，这将允许我们使用

ConsistantRandom

类，并确保算法不会在我们身上改变

using System;

namespace ConsoleApplication1
{
    public class ConsistantRandom: Random
    {
        private const int MBIG = Int32.MaxValue;
        private const int MSEED = 161803398;
        private const int MZ = 0;

        private int inext;
        private int inextp;
        private int[] SeedArray = new int[56];

        public ConsistantRandom()
            : this(Environment.TickCount)
        {
        }

        public ConsistantRandom(int seed)
        {
            int ii;
            int mj, mk;

            int subtraction = (seed == Int32.MinValue) ? Int32.MaxValue : Math.Abs(seed);
            mj = MSEED - subtraction;
            SeedArray[55] = mj;
            mk = 1;
            for (int i = 1; i < 55; i++)
            {
                ii = (21 * i) % 55;
                SeedArray[ii] = mk;
                mk = mj - mk;
                if (mk < 0) mk += MBIG;
                mj = SeedArray[ii];
            }
            for (int k = 1; k < 5; k++)
            {
                for (int i = 1; i < 56; i++)
                {
                    SeedArray[i] -= SeedArray[1 + (i + 30) % 55];
                    if (SeedArray[i] < 0) SeedArray[i] += MBIG;
                }
            }
            inext = 0;
            inextp = 21;
        }
        protected override double Sample()
        {
            return (InternalSample() * (1.0 / MBIG));
        }

        private int InternalSample()
        {
            int retVal;
            int locINext = inext;
            int locINextp = inextp;

            if (++locINext >= 56) locINext = 1;
            if (++locINextp >= 56) locINextp = 1;

            retVal = SeedArray[locINext] - SeedArray[locINextp];

            if (retVal == MBIG) retVal--;
            if (retVal < 0) retVal += MBIG;

            SeedArray[locINext] = retVal;

            inext = locINext;
            inextp = locINextp;

            return retVal;
        }

        public override int Next()
        {
            return InternalSample();
        }

        private double GetSampleForLargeRange()
        {
            int result = InternalSample();
            bool negative = (InternalSample() % 2 == 0) ? true : false;
            if (negative)
            {
                result = -result;
            }
            double d = result;
            d += (Int32.MaxValue - 1);
            d /= 2 * (uint)Int32.MaxValue - 1;
            return d;
        }


        public override int Next(int minValue, int maxValue)
        {
            if (minValue > maxValue)
            {
                throw new ArgumentOutOfRangeException("minValue");
            }

            long range = (long)maxValue - minValue;
            if (range <= (long)Int32.MaxValue)
            {
                return ((int)(Sample() * range) + minValue);
            }
            else
            {
                return (int)((long)(GetSampleForLargeRange() * range) + minValue);
            }
        }
        public override void NextBytes(byte[] buffer)
        {
            if (buffer == null) throw new ArgumentNullException("buffer");
            for (int i = 0; i < buffer.Length; i++)
            {
                buffer[i] = (byte)(InternalSample() % (Byte.MaxValue + 1));
            }
        }
    }

}

使用系统；
命名空间控制台应用程序1
{
公共类一致性：随机
{
private const int MBIG=Int32.MaxValue；
私有常量int MSEED=161803398；
私有常量int MZ=0；
私人不精确；
私营企业；
私有int[]种子数组=新int[56]；
公共一致性（）
：此（Environment.TickCount）
{
}
公共一致性（int seed）
{
int ii；
int-mj，mk；
int减法=（seed==Int32.MinValue）？Int32.MaxValue:Math.Abs（seed）；
mj=MSEED-减法；
种子阵列[55]=mj；
mk=1；
对于（int i=1；i<55；i++）
{
ii=（21*i）%55；
种子数组[ii]=mk；
mk=mj-mk；
如果（mk<0）mk+=MBIG；
mj=种子阵列[ii]；
}
对于（int k=1；k<5；k++）
{
对于（int i=1；i<56；i++）
{
种子阵列[i]-=种子阵列[1+（i+30）%55]；
if（SeedArray[i]<0）SeedArray[i]+=MBIG；
}
}
不精确=0；
inxtp=21；
}
受保护覆盖双样本（）
{
返回（InternalSample（）*（1.0/MBIG））；
}
私有int InternalSample（）
{
内部检索；
int locINext=不精确；
int locinxtp=inxtp；
如果（++locINext>=56）locINext=1；
如果（++locINextp>=56）locINextp=1；
retVal=SeedArray[locINext]-SeedArray[locINextp]；
如果（retVal==MBIG）retVal--；
如果（retVal<0）retVal+=MBIG；
SeedArray[locinquet]=retVal；
不精确=不精确；
inxtp=locinxtp；
返回返回；
}
公共覆盖int Next（）
{
返回内部样本（）；
}
私有双GetSampleForLargeRange（）
{
int result=InternalSample（）；
布尔负=（InternalSample（）%2==0）？真：假；
如果（否定）
{
结果=-结果；
}
双d=结果；
d+=（Int32.MaxValue-1）；
d/=2*（uint）Int32.MaxValue-1；
返回d；
}
公共覆盖int-Next（int-minValue，int-maxValue）
{
如果（最小值>最大值）
{
抛出新ArgumentOutOfRangeException（“minValue”）；
}
长范围=（长）最大值-最小值；
if（range，我建议依赖一个名为“Random”的类来给出可预测的数字是一个错误：）我不认为有任何保证他们在某个时候不会改变算法……你有新的随机循环吗？@DavidG在给定特定种子的情况下，依靠随机数生成器生成可预测的结果是很常见的，以便确定地再现问题，等等@DavidG在这种情况下，你会建议如何再现gamep非专业场景等。考虑到它们涉及许多RNG计算，这是决定性的？谢谢你，这正是我要寻找的，我很惭愧我没有在文档中看到这一点。现在我必须搜索一些保证可预测的东西，或者写我自己的（因为它不需要花哨）@vargonian：我在这里整理了一个简单的PRNG，如果你愿意，你可以使用它或改进它：@vargonian供你参考，这样你就可以使用它的重命名副本，并且安全一致。