System.Random是否总能为跨平台的给定种子生成可预测的数字？

Question

我知道Object.GetHashCode可以为同一个对象(例如,相同的字符串)返回不同的值,具体取决于平台.因此我不能依赖于这个跨平台的简单哈希.

但我可以依赖System.Random吗？无论我是否使用Microsoft .NET/Mono/x86/x64等,它是否会为给定的种子产生相同的结果？

Answer 1

正如Jeremy 在他的回答中提到的那样,文档说明数字生成器在.NET版本中并不保证一致.

但是,文档还告诉您如何实现算法.

您可以通过继承Random类并提供随机数生成算法来实现自己的随机数生成器.要提供自己的算法,必须覆盖Sample实现随机数生成算法的方法.你也应该重写Next(),Next(Int32,?Int32)和NextBytes方法,以确保他们打电话给你重写的抽样方法.您不必重写Next(Int32)和NextDouble方法.

使用它我们可以创建我们自己的随机类,使用您可以使用的已知固定算法.例如,我们可以转到.Net源并实现当前的随机算法,这将允许我们使用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));
            }
        }
    }

}

因为ConsistantRandom派生自Random你可以使用该类作为替代品,只要您拥有Random之前的类型,您只需要替换Random rnd = new Random(yourSeed);为Random rnd = new ConsistantRandom(yourSeed);.

Answer 2

不,您不能依赖跨平台或版本生成的一致值.从.NET Framework文档System.Random(不太详细的.NET Core文档不解决此问题):

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