Question

I am working on a static class to provide random values for my program, but there are some issues with implementing the equivalent of the Random.Next(int maxValue) functionality:

public class CRandom {
    static readonly byte[] randomSet;
    static readonly Func<int> closedIndex; 
    static CRandom() {
        randomSet = new byte[60000000];
        closedIndex = _ClosedIndex(0); 
        RNGCryptoServiceProvider Gen = new RNGCryptoServiceProvider();
        Gen.GetBytes(randomSet);
    }
    public static int Next() {
        int index = closedIndex();
        return Convert.ToInt32(randomSet[index]);
    }
    public static int Next(int maxValue) {
        int index = closedIndex();
        byte[] remainingSet = randomSet.Skip(index + 1).ToArray();
        byte next = remainingSet.First(x => Convert.ToInt32(x) < maxValue); 
        return Convert.ToInt32(next);
    }
    public static Func<int> _ClosedIndex(int seed) {
        // seed is the initial value
        int _index = seed - 1; 
        Func<int> del = new Func<int>(() =>
        {  // always returns auto-incremented value
            _index++; 
            return _index; 
        });
        return del; 
    }
}

Basically what it does is fill up a static/readonly byte array of random values and in the case of the Next(maxValue) method just gets the next value thats in range but hasn’t been used before. However trying out Next(100) in a loop is giving these results, which obviously aren’t random:

53
20
20
34
34
73
73
73
73

This is also a very slow way of doing it. I’m sure there is a better way but I don’t know quite how Random.Next() works under the hood.

Answer 1

MSDN Magazine has a very detailed article about this exact topic.
It’s more complicated than you think.

He wrote the following class; however, read the article for important notes about randomness.

public class CryptoRandom : Random
{
    private RNGCryptoServiceProvider _rng =
        new RNGCryptoServiceProvider();
    private byte[] _uint32Buffer = new byte[4];

    public CryptoRandom() { }
    public CryptoRandom(Int32 ignoredSeed) { }

    public override Int32 Next()
    {
        _rng.GetBytes(_uint32Buffer);
        return BitConverter.ToInt32(_uint32Buffer, 0) & 0x7FFFFFFF;
    }

    public override Int32 Next(Int32 maxValue)
    {
        if (maxValue < 0)
            throw new ArgumentOutOfRangeException("maxValue");
        return Next(0, maxValue);
    }

    public override Int32 Next(Int32 minValue, Int32 maxValue)
    {
        if (minValue > maxValue) 
            throw new ArgumentOutOfRangeException("minValue");
        if (minValue == maxValue) return minValue;
        Int64 diff = maxValue - minValue;
        while (true)
        {
            _rng.GetBytes(_uint32Buffer);
            UInt32 rand = BitConverter.ToUInt32(_uint32Buffer, 0);

            Int64 max = (1 + (Int64)UInt32.MaxValue);
            Int64 remainder = max % diff;
            if (rand < max - remainder)
            {
                return (Int32)(minValue + (rand % diff));
            }
        }
    }

    public override double NextDouble()
    {
        _rng.GetBytes(_uint32Buffer);
        UInt32 rand = BitConverter.ToUInt32(_uint32Buffer, 0);
        return rand / (1.0 + UInt32.MaxValue);
    }

    public override void NextBytes(byte[] buffer)
    {
        if (buffer == null) throw new ArgumentNullException("buffer");
        _rng.GetBytes(buffer);
    }
}