Random.Next returns always the same values

Question

I use the method to generate unique number but I always get the same number -2147483648. Even if I stop the program, recompile it and run again I still see the same number.

  public static int GetRandomInt(int length)
    {           
        var min = Math.Pow(10, length - 1);
        var max = Math.Pow(10, length) - 1;
        var random = new Random();
        return random.Next((int)min, (int)max);
    }

Answer 1

Try externalizing the random instance:

private readonly Random _random = new Random();

public static int GetRandomInt(int length)
{           
    var min = Math.Pow(10, length - 1);
    var max = Math.Pow(10, length) - 1;
    return _random.Next((int)min, (int)max);
}

Answer 2

This is not an issue of not reusing Random instance, the results he gets should be random on multiple starts, not always being -(2^32)

This is the issue with length being too big, and casting powers of length to int. If you break the code into following lines:

        var min = Math.Pow(10, length - 1);
        var max = Math.Pow(10, length) - 1;
        var random = new Random();
        var a = (int)min;
        var b = (int)max;
        return random.Next(a, b);

You'll see that a and b are -2147483648, making that the only possible result of Next(min, max) (the doc specifies if min==max, return min).

The largest length you can safely use with this method is 9. For a length of 10 you'll get System.ArgumentOutOfRangeException, for length > 10 you'll get the -2147483648 result.

Answer 3

You should keep an instance of Random and not new() it up all the time, that should give you better results.

Also check for what length actually is. It may be giving you funny results as to the limits.

Answer 4

You have three problems with your code.

1. You should externalize your random variable.
2. You have a problem with truncation error.
3. The range between min and max is way to large.

The first problem is because you may not have enough time to advance the seed when reinitializing your random variable. The second error comes from truncating your (what would b very large) numbers down to ints. Finally, your biggest problem is your range between your min and your max. Consider finding the range between min and max (as defined in your code) with inputs 1->20:

length  max-min        
1       8
2       89
3       899
4       8999
5       89999
6       899999
7       8999999
8       89999999
9       899999999
10      8,999,999,999
11      89999999999
12      899999999999
13      8999999999999
14      89999999999999
15      899999999999999
16      9E+15
17      9E+16
18      9E+17
19      9E+18

And keep in mind that the maximum integer is 2,147,483,647, which is passed on any number greater than 9.

Answer 5

I think the problem is the calculation of min and max. They will be greater than Int32.MaxValue pretty fast...

Answer 6

In your class, have one instance of Random, e.g.:

public class MyClass
{
private readonly Random random = new Random();

public static int GetRandomInt(int length)
{
  var min = Math.Pow(10, length - 1);
  var max = Math.Pow(10, length) - 1;
  return random.Next((int)min, (int)max);
}

}

The fact that random always returns the same values only exists for testing purposes.

Answer 7

Random classes usually use a seed to initialize themselves, and will usually return the same sequence provided the seed is the same one :

• Always reuse the same Random() instance instead of recreating one over and over again
• if you want unpredictable results, use a time-dependent seed rather than an hard-coded one

It's very difficult to code a truly random number generator. Most methods use external entropy generators (such as mouse movement, cpu temperature, or even complex physical mechanisms such as helium balloons colliding one another...).

Answer 8

The Random instance should be created only once and then reused. The reason for this is that the RNG is by default seeded with the current system time. If you rapidly create new Random instances (and pull one value from it) then many of them will be seeded with the same timestamp, because the loop probably executes faster than the system clock advances.

Remember, a RNG initialized by seed A will always return sequence B. So if you create three Random instances all seeded with for example 123, these three instances will always return the same number on the same iteration.