How to use random class in multi threaded application correct

Question

I need to use random class to generate random numbers in a multi threaded application inside public static function. How can i achieve it. Currently the function below is working very well but it is not very fast when compared to random class. So i need to modify the function below and make it work with random class while thousands of concurrent calls are happening to that class. if i use random it uses same seed for every call i suppose and the randomization is being very bad. my current class

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Security.Cryptography;

public static class GenerateRandomValue
{
    static RNGCryptoServiceProvider Gen = new RNGCryptoServiceProvider();

    public static int GenerateRandomValueDefault(int irRandValRange)//default min val 1
    {
        if (irRandValRange == 0)
            irRandValRange = 1;
        byte[] randomNumber = new byte[4]; // 4 bytes per Int32
        Gen.GetBytes(randomNumber);
        return Math.Abs(BitConverter.ToInt32(randomNumber, 0) % irRandValRange) + 1;
    }

    public static int GenerateRandomValueMin(int irRandValRange, int irMinValue)
    {
        byte[] randomNumber = new byte[4]; // 4 bytes per Int32
        Gen.GetBytes(randomNumber);
        return BitConverter.ToInt32(randomNumber, 0) % irRandValRange + irMinValue;
    }
}

Another function which seems pretty good and thread safe

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Threading;

public static class GenerateRandomValue
{
    private static Random seedGenerator = new Random();

    private static ThreadLocal<Random> random = new ThreadLocal<Random>(SeededRandomFactory);

    private static Random SeededRandomFactory()
    {
        lock(seedGenerator)
            return new Random(seedGenerator.Next());
    }

    public static int GenerateRandomValueMin(int irRandValRange, int irMinValue)
    {
        return random.Value.Next(irMinValue, irRandValRange);
    }
}

Answer 1

You didn't specify any constraints other than speed, so I would think that Random should do.

// Field in the class
Random rand = new Random();

// Inside a method:
int randomValue = rand.Next(); // Random positive integer returned
int randomValue = rand.Next(max); // Random under max
int randomValue = rand.Next(min, max); // Random in range

Answer 2

What you need is a better way to start the seeding in your ASP.NET application, the quality of Random should be fine using the below method.

public static int GenerateRandomValueDefault(int irRandValRange)//default min val 1
{
    return GenerateRandomValueMin(irRandValRange, 1);
}

public static int GenerateRandomValueMin(int irRandValRange, int irMinValue)
{
    Random rand = GetRandom();
    return rand.GetNext(irMinValue,irRandValRange)
}

//This is a global random number generator, it is only used to provide the seed for the local RNG's.
private static Random GlobalRandom = new Random();

private static Random GetRandom()
{
    if (HttpContext.Current.Session["RNG"] == null)
    {
        //This lock is only hit the very first time the users Session state is used, every time after that it should use the cached local copy without taking the lock.
        lock(GlobalRandom)
        {
            //We use the Global RNG for seed instead of the default because it uses time to seed by default, and if two people get a new Random() within the same time-slice they will have the same seed. This prevents that from happening.
            HttpContext.Current.Session["RNG"] = new Random(GlobalRandom.Next());
        }
    }
    //Return the cached/new RNG.
    return (Random)HttpContext.Current.Session["RNG"];
}

You have one instance of a global RNG that does lock, however this is only hit when a new session state is generated, after that the session uses only it's local copy. You will get very good performance at run time with a slight load on the first page load per person as it generates one number from the global store.

You can modify this to suit your needs but it gives you the general idea, but it gives you the general idea.

---

Per Henk Holterman's suggestion, here is a lock less solution that may be faster and does not use HttpState.

private static int SeedCounter = 0;
private readonly object SeedInitLock = new Object();

private static Random GetRandom()
{
    //Do init the first time this function is ever called.
    if(SeedCounter == -1)
    {
        //The first time the function is called everyone will try to update SeedCounter, but only the first 
        //thread to complete it will be the value everyone uses.
        Random initRNG = new Random();
        Interlocked.CompareExchange(ref SeedCounter, initRNG.Next(), -1);

    }
    else if (SeedCounter < 0)
    {
        //Because Interlocked.Increment wraps the value to int.MinValue and Random(int) will take the absolute
        //value of the seed, we skip all of the negitive numbers and go to 0.
        Interlocked.CompareExchange(ref SeedCounter, 0, int.MinValue);
    }

    int tempSeed = Interlocked.Increment(ref SeedCounter);
    if (tempSeed < 0)
    {
        //If tempSeed is negative we hit a edge case where SeedCounter wrapped around. We just call the function
        //again so we do not reuse a seed that was just used.
        return GetRandom();
    }

    return new Random(tempSeed);
}

Answer 3

I would suggest System.Web.Security.Membership.GeneratePassword() method.

string generated = System.Web.Security.Membership.GeneratePassword(
                   10, // maximum length
                   3)  // number of non-ASCII characters.

Answer 4

Using Random with a good seed is suppose to be "performance wise" better. But do you need the performance ?

Check this blog for metrics : http://blogs.msdn.com/b/pfxteam/archive/2009/02/19/9434171.aspx There is a hint at the end about seeding with the provider.

Take it with a grain of salt though. You will have to redo the tests to be sure.