How do I generate a random integer in C#?

Asked 2023-09-20 20:32:07 View 184,771

How do I generate a random integer in C#?

  • See this answer for the current (and easiest) cryptographically secure solution - anyone
  • Random.Shared is the current way to go on the server side. Cryptographical security is needed in a use case where a single user can infer the inner state of the generator from observing sequences of generated numbers, and also knowing the relative position of the generated numbers whose values they are trying to predict. - anyone

Answers

The Random class is used to create random numbers. (Pseudo-random that is of course.).

Example:

Random rnd = new Random();
int month  = rnd.Next(1, 13);  // creates a number between 1 and 12
int dice   = rnd.Next(1, 7);   // creates a number between 1 and 6
int card   = rnd.Next(52);     // creates a number between 0 and 51

If you are going to create more than one random number, you should keep the Random instance and reuse it. If you create new instances too close in time, they will produce the same series of random numbers as the random generator is seeded from the system clock.

Answered   2023-09-20 20:32:07

  • In order to reuse it, you can declare rnd as static and/or set it just once when initializing the code. - anyone
  • @JuniorM: Yes, you can make is static to reuse it, but you have to be careful so that you don't access it from multiple threads as it's not thread safe (as is usual for any class that is not specifically made thread safe). - anyone
  • I think it would be useful to add a disclaimer that this is not cryptographically secure, since this is a popular question, just in case someone blindly tries to do cryptography with Random... - anyone
  • Excellent answer. There are some good "enhancements" to Random out there to make your random-ness more robust: ericlippert.com/2019/02/04/fixing-random-part-2 and codeblog.jonskeet.uk/2009/11/04/revisiting-randomness . - anyone
  • In case anyone is confused, rnd.Next(1,13) includes 1 and excludes 13. i.e. lower bound is inclusive - anyone

The question looks very simple but the answer is bit complicated. If you see almost everyone has suggested to use the Random class and some have suggested to use the RNG crypto class. But then when to choose what.

For that we need to first understand the term RANDOMNESS and the philosophy behind it.

I would encourage you to watch this video that I made which goes in depth in the philosophy of RANDOMNESS using C# https://www.youtube.com/watch?v=tCYxc-2-3fY

First thing let us understand the philosophy of RANDOMNESS. When we tell a person to choose between RED, GREEN and YELLOW what happens internally. What makes a person choose RED or YELLOW or GREEN?

c# Random

Some initial thought goes into the persons mind which decides his choice, it can be favorite color , lucky color and so on. In other words some initial trigger which we term in RANDOM as SEED.This SEED is the beginning point, the trigger which instigates him to select the RANDOM value.

Now if a SEED is easy to guess then those kind of random numbers are termed as PSEUDO and when a seed is difficult to guess those random numbers are termed SECURED random numbers.

For example a person chooses is color depending on weather and sound combination then it would be difficult to guess the initial seed.

c# Random

Now let me make an important statement:-

*“Random” class generates only PSEUDO random number and to generate SECURE random number we need to use “RNGCryptoServiceProvider” class.

c# Random

Random class takes seed values from your CPU clock which is very much predictable. So in other words RANDOM class of C# generates pseudo random numbers , below is the code for the same.

Random random = new Random();
int randomNumber = random.Next();

While the RNGCryptoServiceProvider class uses OS entropy to generate seeds. OS entropy is a random value which is generated using sound, mouse click, and keyboard timings, thermal temp etc. Below goes the code for the same.

using (RNGCryptoServiceProvider rg = new RNGCryptoServiceProvider()) 
{ 
    byte[] rno = new byte[5];    
    rg.GetBytes(rno);    
    int randomvalue = BitConverter.ToInt32(rno, 0); 
}

To understand OS entropy see this video of mine starting at 14:30 https://www.youtube.com/watch?v=tCYxc-2-3fY where the logic of OS entropy is explained. So putting in simple words RNG Crypto generates SECURE random numbers.

Answered   2023-09-20 20:32:07

  • shouldn't be your byte[5] only [4] as ToInt32 parses only 4 bytes? - anyone
  • It's always helpful to know where these classes live. System.Security.Cryptography - anyone
  • It is recommended to use RandomNumberGenerator.Create() instead of calling the constructor of RNGCryptoServiceProvider since it is not available on all platforms. - anyone
  • I want just to precise that SecureRandom IS pseudo random generation. - anyone
  • Due to the increased randomness of the seed, is it OK to create new RNGCryptoServiceProvider objects each time I need to generate a random number, or is it still better to create one RNGCryptoServiceProvider object and reuse it whenever I need to generate a random number, as should be done with the Random class? - anyone

Every time you do new Random() it is initialized. This means that in a tight loop you get the same value lots of times. You should keep a single Random instance and keep using Next on the same instance.

//Function to get random number
private static readonly Random getrandom = new Random();

public static int GetRandomNumber(int min, int max)
{
    lock(getrandom) // synchronize
    {
        return getrandom.Next(min, max);
    }
}

Answered   2023-09-20 20:32:07

  • Is this not what @Guffa said in his answer 6 months ago? "If you create new instances too close in time, they will produce the same series of random numbers" - anyone
  • @Chris- That's right what you said. In this I have provided the implementation of that. I think it's a good way of doing it. It works better. - anyone
  • This is an implementation that synchronises the code for use from seval threads. That is good for a multi threaded application, but a waste of time for a single threaded application. - anyone
  • @SeanWorle: First, I tried it with the approach from Guffa. Then I tried to store the same Random object. At both cases I got the same random number. With the approach from Pankaj it didn't happen. Perhaps this is random, but I doubt it now. I'm querying for the random number in the same second from different threads. - anyone
  • @testing: I agree that Pankaj's method is the correct one to use. What I'm saying is that it can be simplified to this: //Function to get random number private static readonly Random getrandom = new Random(); public static int GetRandomNumber(int min, int max) { lock(getrandom ) { // synchronize return getrandom.Next(min, max); } } - anyone

Beware that new Random() is seeded on current timestamp.

If you want to generate just one number you can use:

new Random().Next( int.MinValue, int.MaxValue )

For more information, look at the Random class, though please note:

However, because the clock has finite resolution, using the parameterless constructor to create different Random objects in close succession creates random number generators that produce identical sequences of random numbers

So do not use this code to generate a series of random number.

Answered   2023-09-20 20:32:07

  • -1: The default seed is based on time; do this in a loop and you'll get very non-random results. You should create one generator and use it for all your numbers, not a separate generator each time. - anyone
  • Hey, that's unfair. The question was how to generate random int number. No loops or series were mentioned. - anyone
  • Ok, fair point. Rescinded. Though, I still think that not using new Random() in a loop is an important point. - anyone
  • For those coming across this in the future, it should be obvious now, but I'll just point it out; the answer was updated with this point, to not use this in a loop for multiple values. - anyone
Random r = new Random();
int n = r.Next();

Answered   2023-09-20 20:32:07

  • This seems an underrated valuable response!! - anyone
  • @nilon Well, depending on what OP - or a random reader like me - wants, this might be an overrated response. In my book, int is something between int.MinValue and int.MaxValue, but this call (in accordance with the documentation) never emits a negative number. - anyone
  • @Eike Since the OP didn't provide any details I also didn't feel the need to write a whole blog post. 🤷‍♂️ - anyone

I wanted to add a cryptographically secure version:

RNGCryptoServiceProvider Class (MSDN or dotnetperls)

It implements IDisposable.

using (RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider())
{
   byte[] randomNumber = new byte[4];//4 for int32
   rng.GetBytes(randomNumber);
   int value = BitConverter.ToInt32(randomNumber, 0);
}

Answered   2023-09-20 20:32:07

create a Random object

Random rand = new Random();

and use it

int randomNumber = rand.Next(min, max);

you don't have to initialize new Random() every time you need a random number, initiate one Random then use it as many times as you need inside a loop or whatever

Answered   2023-09-20 20:32:07

  • new Random() uses the current ticks as seed. When you instantiate multiple instances within the same millisecond (as opposed to tick), then you will get the same value returned. - anyone
  • This is actively bad. DateTime.Now.Millisecond (unlike DateTime.Now.Ticks) is a number between 0 and 999. If you're creating a new one of these for each random number, you'll only have 1000 possibilities. - anyone
  • What were 24 people thinking in up-voting this answer...? - anyone

You could use Jon Skeet's StaticRandom method inside the MiscUtil class library that he built for a pseudo-random number.

using MiscUtil;
...

for (int i = 0; i < 100; 
    Console.WriteLine(StaticRandom.Next());

Answered   2023-09-20 20:32:07

  • I just had a look at the source code, and this function uses exactly the same random number engine, the one "included" in C#, but makes sure that the same "seed"/"mother object" is used for all calls. (I am sorry that I do not know the C# terminology. But my point is that this function does not make any better random numbers than the standard function.) - anyone
  • It's impossible for anything to be 'truly random' since there is always some limiting factor or prejudice included that is inherent by its very existence. Didn't you listen to the teacher in science classes? ;-) - anyone
  • Let's say , according to him this is as 'truly random' as it gets - anyone

I've tried all of these solutions excluding the COBOL answer... lol

None of these solutions were good enough. I needed randoms in a fast for int loop and I was getting tons of duplicate values even in very wide ranges. After settling for kind of random results far too long I decided to finally tackle this problem once and for all.

It's all about the seed.

I create a random integer by parsing out the non-digits from Guid, then I use that to instantiate my Random class.

public int GenerateRandom(int min, int max)
{
    var seed = Convert.ToInt32(Regex.Match(Guid.NewGuid().ToString(), @"\d+").Value);
    return new Random(seed).Next(min, max);
}

Update: Seeding isn't necessary if you instantiate the Random class once. So it'd be best to create a static class and call a method off that.

public static class IntUtil
{
   private static Random random;

   private static void Init()
   {
      if (random == null) random = new Random();
   }

   public static int Random(int min, int max)
   {
      Init();
      return random.Next(min, max);
   }
}

Then you can use the static class like so..

for(var i = 0; i < 1000; i++)
{
   int randomNumber = IntUtil.Random(1,100);
   Console.WriteLine(randomNumber); 
}

I admit I like this approach better.

Answered   2023-09-20 20:32:07

  • Guid is not random, it is not a good seed. A GUID doesn't make guarantees about randomness, it makes guarantees around uniqueness. stackoverflow.com/questions/2621563/… - anyone
  • Guid is a good seed. I am only using the numbers in the Guid. Try the method for yourself. Put it in a long for loop and look at the results for yourself. - anyone
  • Hmm, on second thought.. seed isn't necessary at all. Updating answer - anyone
  • Great point on the update. I didn't even think to make it a static field, this way works much better and is cleaner. - anyone
  • There are some problems with this answer. First of all GUID is not a great seed source - just because it looks random doesn't mean it is. It may be good enough for your personal needs. Secondly the Random class isn't thread safe. You need to instantiate it once per thread. - anyone

As described in other answers, a good secured approach would be to use a secure cryptographic generator. All examples here show the usage of RNGCryptoServiceProvider which is writing a long code compared to the solution I suggest.

Use RandomNumberGenerator which is written on top of cryptography API’s. It is as secure as RNGCryptoServiceProvider and same randomness.

// Gives a random number for the integer range.
// You can simply update the parameters as your needs.
RandomNumberGenerator.GetInt32(int.MinValue, int.MaxValue);

Answered   2023-09-20 20:32:07

  • As of .NET 6 RNGCryptoServiceProvider has been marked [Obsolete()] and RandomNumberGenerator is recommended instead. - anyone

The numbers generated by the inbuilt Random class (System.Random) generates pseudo random numbers.

If you want true random numbers, the closest we can get is "secure Pseudo Random Generator" which can be generated by using the Cryptographic classes in C# such as RNGCryptoServiceProvider.

Even so, if you still need true random numbers you will need to use an external source such as devices accounting for radioactive decay as a seed for an random number generator. Since, by definition, any number generated by purely algorithmic means cannot be truly random.

Answered   2023-09-20 20:32:07

Modified answer from here.

If you have access to an Intel Secure Key compatible CPU, you can generate real random numbers and strings using these libraries: https://github.com/JebteK/RdRand and https://www.rdrand.com/

Just download the latest version from here, include Jebtek.RdRand and add a using statement for it. Then, all you need to do is this:

// Check to see if this is a compatible CPU
bool isAvailable = RdRandom.GeneratorAvailable();

// Generate 10 random characters
string key       = RdRandom.GenerateKey(10);

 // Generate 64 random characters, useful for API keys 
string apiKey    = RdRandom.GenerateAPIKey();

// Generate an array of 10 random bytes
byte[] b         = RdRandom.GenerateBytes(10);

// Generate a random unsigned int
uint i           = RdRandom.GenerateUnsignedInt();

If you don't have a compatible CPU to execute the code on, just use the RESTful services at rdrand.com. With the RdRandom wrapper library included in your project, you would just need to do this (you get 1000 free calls when you signup):

string ret = Randomizer.GenerateKey(<length>, "<key>");
uint ret   = Randomizer.GenerateUInt("<key>");
byte[] ret = Randomizer.GenerateBytes(<length>, "<key>");

Answered   2023-09-20 20:32:07

Just as a note for future reference.

If you're using .NET Core, multiple Random instances aren't as dangerous as before. I'm aware that this question is from 2010, but since this question is old but has some attraction, I think it's a good thing to document the change.

You may refer to this question I made a while back:

Did Microsoft change Random default seed?

Basically, they have changed the default seed from Environment.TickCount to Guid.NewGuid().GetHashCode(), so if you create 2 instances of Random it shouldn't display the same numbers (1:4 billion).

You can see the file diffs from .NET Framework/.NET Core (2.0.0+) here: https://github.com/dotnet/coreclr/pull/2192/commits/9f6a0b675e5ac0065a268554de49162c539ff66d

It isn't as safe as RNGCryptoServiceProvider, but at least it won't give you weird results.


By @Enigmativity:

This is now out-of-date. There was a considerable backlash against using Guids. The code is now Interop.GetRandomBytes((byte*)&result, sizeof(int));

Answered   2023-09-20 20:32:07

  • This is now out-of-date. There was a considerable backlash against using Guids. The code is now Interop.GetRandomBytes((byte*)&result, sizeof(int));. - anyone

While this is okay:

Random random = new Random();
int randomNumber = random.Next()

You'd want to control the limit (min and max mumbers) most of the time. So you need to specify where the random number starts and ends.

The Next() method accepts two parameters, min and max.

So if i want my random number to be between say 5 and 15, I'd just do

int randomNumber = random.Next(5, 16)

Answered   2023-09-20 20:32:07

This is the class I use. Works like RandomNumber.GenerateRandom(1, 666)

internal static class RandomNumber
{
    private static Random r = new Random();
    private static object l = new object();
    private static Random globalRandom = new Random();
    [ThreadStatic]
    private static Random localRandom;
    public static int GenerateNewRandom(int min, int max)
    {
        return new Random().Next(min, max);
    }
    public static int GenerateLockedRandom(int min, int max)
    {
        int result;
        lock (RandomNumber.l)
        {
            result = RandomNumber.r.Next(min, max);
        }
        return result;
    }
    public static int GenerateRandom(int min, int max)
    {
        Random random = RandomNumber.localRandom;
        if (random == null)
        {
            int seed;
            lock (RandomNumber.globalRandom)
            {
                seed = RandomNumber.globalRandom.Next();
            }
            random = (RandomNumber.localRandom = new Random(seed));
        }
        return random.Next(min, max);
    }
}

Answered   2023-09-20 20:32:07

  • Your GenerateRandom class will never return the number 666, only 665. This is common misunderstanding (feature) of Random.Next max value. - anyone

I wanted to demonstrate what happens when a new random generator is used every time. Suppose you have two methods or two classes each requiring a random number. And naively you code them like:

public class A
{
    public A()
    {
        var rnd=new Random();
        ID=rnd.Next();
    }
    public int ID { get; private set; }
}
public class B
{
    public B()
    {
        var rnd=new Random();
        ID=rnd.Next();
    }
    public int ID { get; private set; }
}

Do you think you will get two different IDs? NOPE

class Program
{
    static void Main(string[] args)
    {
        A a=new A();
        B b=new B();

        int ida=a.ID, idb=b.ID;
        // ida = 1452879101
        // idb = 1452879101
    }
}

The solution is to always use a single static random generator. Like this:

public static class Utils
{
    public static readonly Random random=new Random();
}

public class A
{
    public A()
    {
        ID=Utils.random.Next();
    }
    public int ID { get; private set; }
}
public class B
{
    public B()
    {
        ID=Utils.random.Next();
    }
    public int ID { get; private set; }
}

Answered   2023-09-20 20:32:07

  • How do you safely choose a seed then? - anyone
  • Well, first, if your objects are created even 10 ms apart, the random numbers generated are different with the default seed. Second, you can mash whatever random environmental or process data you have around to get a seed. Then there's the tradeoff of whether you want one long sequence of numbers that will most likely start repeating itself, or multiple streams even if two streams end up being identical. And if you're concerned about security, RNGCryptoServiceProvider is a better call anyway. - anyone
  • It would be cool to have a randomizer chip with a small alpha particle radioactive source and a detector (how smoke detector works) in order to randomize numbers based on radioactive decay (which is very random). - anyone

In .NET 6 you can use Random.Shared:

int random = Random.Shared.Next();

And in .NET 8 preview this class was added with many new missing methods, e.g. Shuffle array randomly, etc.

Answered   2023-09-20 20:32:07

Numbers calculated by a computer through a deterministic process, cannot, by definition, be random.

If you want a genuine random numbers, the randomness comes from atmospheric noise or radioactive decay.

You can try for example RANDOM.ORG (it reduces performance)

Answered   2023-09-20 20:32:07

Random rand = new Random();
int name = rand.Next()

Put whatever values you want in the second parentheses make sure you have set a name by writing prop and double tab to generate the code

Answered   2023-09-20 20:32:07

  • Why prop and double tab? Are you saying without that keyboard shortcut, which is short-hand for property, your code won't work? - anyone

For strong random seed I always use CryptoRNG and not Time.

using System;
using System.Security.Cryptography;

public class Program
{
    public static void Main()
    {
        var random = new Random(GetSeed());
        Console.WriteLine(random.Next());
    }

    public static int GetSeed() 
    {
        using (var rng = new RNGCryptoServiceProvider())
        {
            var intBytes = new byte[4];
            rng.GetBytes(intBytes);
            return BitConverter.ToInt32(intBytes, 0);
        }
    }
}

Answered   2023-09-20 20:32:07

  • You're using one random number generator to get the seed for another? If you need a "strong" seed then wouldn't you want (cryptographically) strong numbers output as well? Why not just use RNGCryptoServiceProvider for everything at this point? - anyone

If you want a CSRNG to generate random numbers between a min and max, this is for you. It will initialize Random classes with secure random seeds.

    class SecureRandom : Random
    {
        public static byte[] GetBytes(ulong length)
        {
            RNGCryptoServiceProvider RNG = new RNGCryptoServiceProvider();
            byte[] bytes = new byte[length];
            RNG.GetBytes(bytes);
            RNG.Dispose();
            return bytes;
        }
        public SecureRandom() : base(BitConverter.ToInt32(GetBytes(4), 0))
        {

        }
        public int GetRandomInt(int min, int max)
        {
            int treashold = max - min;
            if(treashold != Math.Abs(treashold))
            {
                throw new ArithmeticException("The minimum value can't exceed the maximum value!");
            }
            if (treashold == 0)
            {
                throw new ArithmeticException("The minimum value can't be the same as the maximum value!");
            }
            return min + (Next() % treashold);
        }
        public static int GetRandomIntStatic(int min, int max)
        {
            int treashold = max - min;
            if (treashold != Math.Abs(treashold))
            {
                throw new ArithmeticException("The minimum value can't exceed the maximum value!");
            }
            if(treashold == 0)
            {
                throw new ArithmeticException("The minimum value can't be the same as the maximum value!");
            }
            return min + (BitConverter.ToInt32(GetBytes(4), 0) % treashold);
        }
    }

Answered   2023-09-20 20:32:07

Random random = new Random ();
int randomNumber = random.Next (lowerBound,upperBound);

Answered   2023-09-20 20:32:07

  • While this code may answer the question, it is better to explain how to solve the problem and provide the code as an example or reference. Code-only answers can be confusing and lack context. - anyone

Sorry, OP indeed requires a random int value, but for the simple purpose to share knowledge if you want a random BigInteger value you can use following statement:

BigInteger randomVal = BigInteger.Abs(BigInteger.Parse(Guid.NewGuid().ToString().Replace("-",""), NumberStyles.AllowHexSpecifier));

Answered   2023-09-20 20:32:07

  • I think you'd do better to use byte[] bytes = new byte[byteCount]; random.NextBytes(bytes); BigInteger value = new BigInteger(bytes); or use repeated calls to Random.Next((int) '0', ((int) '9') + 1) to build a string of random digits and parse that instead. This (ab)usage of Guid is unorthodox and pretty much guaranteed to only return astronomically-large numbers (so not really "random"). Further, the documentation recommends "... that applications not use the NewGuid method for cryptographic purposes." - anyone

There are a number utility functions or services that are better cached in the same way that System.Random should be, so it lends itself to a generic implementation:

static public class CachedService<T> where T : new() {
    static public T Get { get; } = new T();
}

To use for random (or similar):

CachedService<System.Random>.Get.Next(999);

Answered   2023-09-20 20:32:07

  • This seems to be unnecessary complicated. Why is the caching needed? - anyone
  • I cache quite a few services that I would only use as if they're singletons - works for me. - anyone

I will assume that you want a uniformly distributed random number generator like below. Random number in most of programming language including C# and C++ is not properly shuffled before using them. This means that you will get the same number over and over, which isn't really random. To avoid to draw the same number over and over, you need a seed. Typically, ticks in time is ok for this task. Remember that you will get the same number over and over if you are using the same seed every time. So try to use varying seed always. Time is a good source for seed because they chage always.

int GetRandomNumber(int min, int max)
{
    Random rand = new Random((int)DateTime.Now.Ticks);
    return rand.Next(min, max);
}

if you are looking for random number generator for normal distribution, you might use a Box-Muller transformation. Check the answer by yoyoyoyosef in Random Gaussian Variable Question. Since you want integer, you have to cast double value to integer at the end.

Random rand = new Random(); //reuse this if you are generating many
double u1 = 1.0-rand.NextDouble(); //uniform(0,1] random doubles
double u2 = 1.0-rand.NextDouble();
double randStdNormal = Math.Sqrt(-2.0 * Math.Log(u1)) *
         Math.Sin(2.0 * Math.PI * u2); //random normal(0,1)
double randNormal =
         mean + stdDev * randStdNormal; //random normal(mean,stdDev^2)

Random Gaussian Variables

Answered   2023-09-20 20:32:07

Why not use int randomNumber = Random.Range(start_range, end_range) ?

Answered   2023-09-20 20:32:07

Use one instance of Random repeatedly

// Somewhat better code...
Random rng = new Random();
for (int i = 0; i < 100; i++)
{
    Console.WriteLine(GenerateDigit(rng));
}
...
static int GenerateDigit(Random rng)
{
    // Assume there'd be more logic here really
    return rng.Next(10);
}

This article takes a look at why randomness causes so many problems, and how to address them. http://csharpindepth.com/Articles/Chapter12/Random.aspx

Answered   2023-09-20 20:32:07

  • Random isn't a thread safe class. If you create a single instance, you should restrict access to it behind a locking mechanism. - anyone

The Random class is used for generating a pseudo-random number. An example could be like this:

public int GenRandom(int minimum, int maximum)
{
    Random random = new Random();
    int result = random.Next(minimum - 1, maximum + 1);
    return result;
}

I added 1 to the minimum and maximum because the Next(int, int) function can never reach minimum and maximum.

Also look at this, would be a random number guesser:

class Program
{
    static void Main(string[] args)
    {
        int i = 0;
        while (true)
        {
            if (i < 1)
            {
                Console.Write("Minimum value: ");
                int min = int.Parse(Console.ReadLine());
                Console.Write("Maximum value: ");
                int max = int.Parse(Console.ReadLine());
                Random random = new Random();
            }
            int randomNumber = random.Next(min, max);
            Console.Write("Enter a guess: ");
            if (int.Parse(Console.ReadLine()) == randomNumber)
            {
                Console.WriteLine("Congrats! You won!");
                Console.ReadKey();
                return;
            }
            else
                Console.WriteLine("Hmm, give it another guess!"); return;
        }
    }
}

Answered   2023-09-20 20:32:07

Try these simple steps to create random numbers:

Create function:

private int randomnumber(int min, int max)
{
    Random rnum = new Random();
    return rnum.Next(min, max);
}

Use the above function in a location where you want to use random numbers. Suppose you want to use it in a text box.

textBox1.Text = randomnumber(0, 999).ToString();

0 is min and 999 is max. You can change the values to whatever you want.

Answered   2023-09-20 20:32:07

  • This will return the same number when called multiple times closely together as it uses System time as a seed... - anyone
  • randomnumber(0, 999) will never return 999. Max Value is not inclusive. This is common misunderstanding (feature) of Random.Next max value. - anyone

I always have methods that generate random numbers which help for various purposes. I hope this may help you too:

public class RandomGenerator  
{  
    public int RandomNumber(int min, int max)  
    {  
        var random = new Random();  
        return random.Next(min, max);  
    }  

    public string RandomString(int size, bool lowerCase)  
    {  
        var builder = new StringBuilder();  
        var random  = new Random();  
        char ch;  

        for (int i = 0; i < size; i++)  
        {  
            ch = Convert.ToChar(Convert.ToInt32(Math.Floor(26 * random.NextDouble() + 65)));  
            builder.Append(ch);  
        }  

        if (lowerCase)  
            return builder.ToString().ToLower();  
        return builder.ToString();  
    }  
}

Answered   2023-09-20 20:32:07