Класс Random, зерно в конструкторе

[OmegaBerkut]

Здравствуйте. Проблема такова: конструктор класса Random принимает зерно только параметром int (32 разряда). Где и как можно найти/сделать генератор, который принимает в качестве зерна число в 64 разряда (long) ?
Это вопрос уникальности выходных данных генератора, поэтому создавать костыли типа "разбить зерно на два 32 разрядных числа, и использовать два генератора ..." - не прокатит, ибо на какие нибудь два разных зерна будет одинаковый набор выходных данных.

[Пепел Феникса]

может вам тогда заюзать крипторандом?
https://msdn.microsoft.com/en-us/lib...v=vs.110).aspx
+ у нас есть исходники же, можно переделать, например так:

    public class LongRandom:Random
    {
        //
        // Private Constants 
        //
        private const long MBIG = long.MaxValue;
        private const long MSEED = 161803398;
        private const long MZ = 0;


        //
        // Member Variables
        //
        private long inext;
        private long inextp;
        private long[] SeedArray = new long[56];

        //
        // Public Constants
        //

        //
        // Native Declarations
        //

        //
        // Constructors
        //

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

        public LongRandom(long Seed)
        {
            long ii;
            long mj, mk;

            //Initialize our Seed array.
            //This algorithm comes from Numerical Recipes in C (2nd Ed.)
            long subtraction = (Seed == long.MinValue) ? long.MaxValue : Math.Abs(Seed);
            mj = MSEED - subtraction;
            SeedArray[55] = mj;
            mk = 1;
            for (int i = 1; i < 55; i++)
            {  //Apparently the range [1..55] is special (Knuth) and so we're wasting the 0'th position.
                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;
            Seed = 1;
        }
        protected override double Sample()
        {
            return (InternalSample() * (1.0 / MBIG));
        }
        private long InternalSample()
        {
            long retVal;
            long locINext = inext;
            long 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;
        }
        private double GetSampleForLargeRange()
        {
            // The distribution of double value returned by Sample 
            // is not distributed well enough for a large range.
            // If we use Sample for a range [Int32.MinValue..Int32.MaxValue)
            // We will end up getting even numbers only.

            long result = InternalSample();
            // Note we can't use addition here. The distribution will be bad if we do that.
            bool negative = (InternalSample() % 2 == 0) ? true : false;  // decide the sign based on second sample
            if (negative)
            {
                result = -result;
            }
            double d = result;
            d += (long.MaxValue - 1); // get a number in range [0 .. 2 * Int32MaxValue - 1)
            d /= 2 * (ulong)long.MaxValue - 1;
            return d;
        }
        public override int Next()
        {
            return (int)InternalSample();
        }
        public override int Next(int minValue, int maxValue)
        {
            long range = (long)maxValue - minValue;
            if (range <= (long)long.MaxValue)
            {
                return ((int)(Sample() * range) + minValue);
            }
            else
            {
                return (int)((long)(GetSampleForLargeRange() * range) + minValue);
            }
        }
        public long NextLong()
        {
            return InternalSample();
        }
        public long NextLong(long minValue, long maxValue)
        {
            long range = (long)maxValue - minValue;
            if (range <= (long)long.MaxValue)
            {
                return ((long)(Sample() * range) + minValue);
            }
            else
            {
                return ((long)(GetSampleForLargeRange() * range) + minValue);
            }
        }
        public long NextLong(long maxValue)
        {
            return (long)(Sample() * maxValue);
        }
        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));
            }
        }
    }

[OmegaBerkut]

Пепел Феникса
А где можно нарыть исходники этого фреймворка, который под WinForms ?
Это мне интересно, и не только для рандома ...

[Пепел Феникса]

Random не является ни частью WinForms, ни WPF, ни прочего.
http://referencesource.microsoft.com...stem/random.cs