Ndtyjky

For ease of re-use throughout your application a static class may help.

public static class StaticRandom

{

    private static int seed;



    private static ThreadLocal<Random> threadLocal = new ThreadLocal<Random>

        (() => new Random(Interlocked.Increment(ref seed)));



    static StaticRandom()

    {

        seed = Environment.TickCount;

    }



    public static Random Instance { get { return threadLocal.Value; } }

}

You can use then use static random instance with code such as

StaticRandom.Instance.Next(1, 100);

Mark's solution can be quite expensive since it needs to synchronize everytime.

We can get around the need for synchronization by using the thread-specific storage pattern:

public class RandomNumber : IRandomNumber

{

    private static readonly Random Global = new Random();

    [ThreadStatic] private static Random _local;



    public int Next(int max)

    {

        var localBuffer = _local;

        if (localBuffer == null) 

        {

            int seed;

            lock(Global) seed = Global.Next();

            localBuffer = new Random(seed);

            _local = localBuffer;

        }

        return localBuffer.Next(max);

    }

}

Measure the two implementations and you should see a significant difference.

My answer from here:

Just reiterating the right solution:

namespace mySpace

{

    public static class Util

    {

        private static rnd = new Random();

        public static int GetRandom()

        {

            return rnd.Next();

        }

    }

}

So you can call:

var i = Util.GetRandom();

all throughout.

If you strictly need a true stateless static method to generate random numbers, you can rely on a Guid.

public static class Util

{

    public static int GetRandom()

    {

        return Guid.NewGuid().GetHashCode();

    }

}

It's going to be a wee bit slower, but can be much more random than Random.Next, at least from my experience.

But not:

new Random(Guid.NewGuid().GetHashCode()).Next();

The unnecessary object creation is going to make it slower especially under a loop.

And never:

new Random().Next();

Not only it's slower (inside a loop), its randomness is... well not really good according to me..

I would rather use the following class to generate random numbers:

byte random;

System.Security.Cryptography.RNGCryptoServiceProvider prov = new System.Security.Cryptography.RNGCryptoServiceProvider();

prov.GetBytes(random);

1) As Marc Gravell said, try to use ONE random-generator. It's always cool to add this to the constructor: System.Environment.TickCount.

2) One tip. Let's say you want to create 100 objects and suppose each of them should have its-own random-generator (handy if you calculate LOADS of random numbers in a very short period of time). If you would do this in a loop (generation of 100 objects), you could do this like that (to assure fully-randomness):

int inMyRandSeed;



for(int i=0;i<100;i++)

{

   inMyRandSeed = System.Environment.TickCount + i;

   .

   .

   .

   myNewObject = new MyNewObject(inMyRandSeed);  

   .

   .

   .

}



// Usage: Random m_rndGen = new Random(inMyRandSeed);

Cheers.

Every time you execute

Random random = new Random (15);

It does not matter if you execute it millions of times, you will always use the same seed.

If you use

Random random = new Random ();

You get different random number sequence, if a hacker guesses the seed and your algorithm is related to the security of your system - your algorithm is broken. I you execute mult. In this constructor the seed is specified by the system clock and if several instances are created in a very short period of time (milliseconds) it is possible that they may have the same seed.

If you need safe random numbers you must use the class

System.Security.Cryptography.RNGCryptoServiceProvider

public static int Next(int min, int max)

{

    if(min >= max)

    {

        throw new ArgumentException("Min value is greater or equals than Max value.");

    }

    byte intBytes = new byte[4];

    using(RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider())

    {

        rng.GetNonZeroBytes(intBytes);

    }

    return  min +  Math.Abs(BitConverter.ToInt32(intBytes, 0)) % (max - min + 1);

}

Usage:

int randomNumber = Next(1,100);

just declare the Random class variable like this:

    Random r = new Random();

    // ... Get three random numbers.

    //     Here you'll get numbers from 5 to 9

    Console.WriteLine(r.Next(5, 10));

if you want to get different random number each time from your list then use

r.Next(StartPoint,EndPoint) //Here end point will not be included

Each time by declaring Random r = new Random() once.

There are a lot of solutions, here one: if you want only number erase the letters and the method receives a random and the result length.

public String GenerateRandom(Random oRandom, int iLongitudPin)

{

    String sCharacters = "123456789ABCDEFGHIJKLMNPQRSTUVWXYZ123456789";

    int iLength = sCharacters.Length;

    char cCharacter;

    int iLongitudNuevaCadena = iLongitudPin; 

    String sRandomResult = "";

    for (int i = 0; i < iLongitudNuevaCadena; i++)

    {

        cCharacter = sCharacters[oRandom.Next(iLength)];

        sRandomResult += cCharacter.ToString();

    }

    return (sRandomResult);

}