Related
I have the following function:
//Function to get random number
public static int RandomNumber(int min, int max)
{
Random random = new Random();
return random.Next(min, max);
}
How I call it:
byte[] mac = new byte[6];
for (int x = 0; x < 6; ++x)
mac[x] = (byte)(Misc.RandomNumber((int)0xFFFF, (int)0xFFFFFF) % 256);
If I step that loop with the debugger during runtime I get different values (which is what I want).
However, if I put a breakpoint two lines below that code, all members of the mac array have equal value.
Why does that happen?
Every time you do new Random() it is initialized using the clock. 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 a random number
private static readonly Random random = new Random();
private static readonly object syncLock = new object();
public static int RandomNumber(int min, int max)
{
lock(syncLock) { // synchronize
return random.Next(min, max);
}
}
Edit (see comments): why do we need a lock here?
Basically, Next is going to change the internal state of the Random instance. If we do that at the same time from multiple threads, you could argue "we've just made the outcome even more random", but what we are actually doing is potentially breaking the internal implementation, and we could also start getting the same numbers from different threads, which might be a problem - and might not. The guarantee of what happens internally is the bigger issue, though; since Random does not make any guarantees of thread-safety. Thus there are two valid approaches:
Synchronize so that we don't access it at the same time from different threads
Use different Random instances per thread
Either can be fine; but mutexing a single instance from multiple callers at the same time is just asking for trouble.
The lock achieves the first (and simpler) of these approaches; however, another approach might be:
private static readonly ThreadLocal<Random> appRandom
= new ThreadLocal<Random>(() => new Random());
this is then per-thread, so you don't need to synchronize.
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);
Starting from .NET 6, the Random class is now equipped with a static property named Shared:
Provides a thread-safe Random instance that may be used concurrently from any thread.
You could use it like this:
// Function to get random number
public static int RandomNumber(int min, int max)
{
return Random.Shared.Next(min, max);
}
Accessing a thread-safe object has a small overhead, so if you are planning to
generate millions of random numbers on a single thread as fast as possible, it might be preferable to create a dedicated Random instance instead of relying on the Shared.
Why does that happen?
As was answered before, every time you call new Random() you get new copy of Random class initialized with the same clocks (so it returns the same values).
Now, starting from .NET 6, there is easy to use and thread-safe alternative: Random.Shared
In your example you can remove at all function RandomNumber and then use following code (with the same logic, but now it works correct):
byte[] mac = new byte[6];
for (int x = 0; x < 6; ++x)
mac[x] = (byte)(Random.Shared.Next(0, 255));
You can use code like this:
public static class ThreadSafeRandom
{
private static readonly Random _global = new Random();
private static readonly ThreadLocal<Random> _local = new ThreadLocal<Random>(() =>
{
int seed;
lock (_global)
{
seed = _global.Next();
}
return new Random(seed);
});
public static Random Instance => _local.Value;
}
This code can be used as is or via the NuGet package ThreadSafeRandomizer.
EDIT: Since .NET 6.0 you can use Random.Shared.Next() instead. You can still use the above package which chooses between the above code or Random.Shared with preprocessor directives.
I use this:
int randomNumber = int.Parse(Guid.NewGuid().ToString().FirstOrDefault(Char.IsDigit).ToString().Replace("\0", "0"));
Performance: Generating 1 million random number on my PC: 711 ms.
If the Guid not contains any number (i don't know that's possible or not) then 0 will be used as the result.
I solved the problem by using the Rnd() function:
Function RollD6() As UInteger
RollD6 = (Math.Floor(6 * Rnd())) + 1
Return RollD6
End Function
When the form loads, I use the Randomize() method to make sure I don't always get the same sequence of random numbers from run to run.
In Visual Basic this works (probably can be translated to C#, if not a DLL reference can be a solution):
Private Function GetRandomInt(ByVal Min As Integer, ByVal Max As Integer) As Integer
Static Generator As System.Random = New System.Random()
Return Generator.Next(Min, Max)
End Function
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);
}
Always get a positive random number.
var nexnumber = Guid.NewGuid().GetHashCode();
if (nexnumber < 0)
{
nexnumber *= -1;
}
I want to make 2 different Random objects in 2 consecutive lines of code. The parameterless constructer of the Random class is like this:
public Random()
: this(Environment.TickCount) {
}
It uses Environment.TickCount as the seed. TickCount represents the amount of time that has passed since the OS is switched on, right?
I tried the following:
Random r1 = new Random ();
Random r2 = new Random ();
And I found out that the 2 Random objects had the same seed because their Next methods return the same number each time. I was surprised by how fast a line of code can be executed. Then I tried:
long tick1 = Environment.TickCount;
for (int i = 0 ; i < 100000 ; i++) {
}
long tick2 = Environment.TickCount;
Console.WriteLine (tick2 - tick1);
And I get 0. So I iterated 100000 times and still, not even 1 millisecond has passed?
I just want to ask how can I create 2 different Random objects or is there another way to generate random numbers?
Base on #PankajMishra's answer, try this one:
//Function to get random number
private static readonly Random getrandom = new Random();
private static readonly object syncLock = new object();
public static int GetRandomNumber(int min, int max)
{
lock(syncLock) { // synchronize
return getrandom.Next(min, max);
}
}
lock block is effective when you use it in a multi-threading program, if you sure just one thread use it, so you can prevent lock to increase your code performance.
To me, it seems like an XY problem, because you don't need two separate Random instances - you can use the same one to generate all your random number, can't you? Just call Next again and that's it:
var rnd = new Random();
int firstRandomInt = rnd.Next();
int secondRandomInt = rnd.Next();
However, you really need 2 Random instances, you can use the first one to seed the second one:
var rnd = new Random();
var rnd2 = new Random(rnd.Next());
This question already has answers here:
Random number generator only generating one random number
(15 answers)
Closed 7 years ago.
Consider this method:
private static int GenerateRandomNumber(int seed, int max)
{
return new Random(seed).Next(max);
}
On my machine, executing this loop yields the same number through 1500 iterations:
for (int i = 0; i < 1501; i++)
{
int random = GenerateRandomNumber(100000000, 999999999);
Console.WriteLine(random.ToString());
Console.ReadKey();
}
I get 145156561, for every single iteration.
I don't have a pressing issue, I was just curious about this behavior because .Next(max) says "Returns a Non Negative random number less than the specified maximum. Perhaps I am not understanding something basic.
You're always seeding a new instance with the same seed, and then grabbing the first max. By using a Seed, you're guaranteeing the same results.
If you want to have a static, random number generation that does different results, you should rework this a bit. However, since Random is not threadsafe, it requires some synchronization when used statically. Something like:
private static Random random;
private static object syncObj = new object();
private static void InitRandomNumber(int seed)
{
random = new Random(seed);
}
private static int GenerateRandomNumber(int max)
{
lock(syncObj)
{
if (random == null)
random = new Random(); // Or exception...
return random.Next(max);
}
}
Dilbert has encountered the same problem back in 2001:
http://dilbert.com/strips/comic/2001-10-25/
Coincidence?
I don't think so.
And random.org agrees : http://www.random.org/analysis/
The problem is that you are creating a new Random instance with the same seed number each time. You should create a single Random instance (store it in a static if necessary) and simply call the next method on that same instance.
Random number generation is not truly random, see this Wikipedia entry for more details.
Salam to All,
Well it drove me crazy as well. The answer is simple. Change the seed before you generate random.
Example:
I want to generate random number between 1 to 10
Random rnd = new Random(DateTime.Now.Second);
int random_number = rnd.Next(10);
Put it inside a loop and run it three times. It will give out random numbers below 10.
Pseudo-random number generator usually work by choosing a seed, and then generating a deterministic sequence based on that seed. Choosing the same seed every time, you generate the same sequence.
There are "only" 2^32 different random sequences in .NET.
Not sure how the internals work.. check wiki for it, but it's very simple.
public class MathCalculations
{
private Random rnd = new Random();
public Int32 getRandom(Int32 iMin, Int32 iMax)
{
return rnd.Next(iMin, iMax);
}
}
public class Main
{
MathCalculations mathCalculations = new MathCalculations();
for (int i = 0; i < 6; i++)
{
getRandom(0,1000);
}
}
will generate Number1, Number2, Number3, Number4, Number5, Number6 (1 seed, 1 sequence of many numbers, random*not really, but approx.*)
if you however do this:
public class MathCalculations
{
public Int32 getRandom(Int32 iMin, Int32 iMax)
{
Random rnd = new Random();
return rnd.Next(iMin, iMax);
}
}
public class Main
{
MathCalculations mathCalculations = new MathCalculations();
for (int i = 0; i < 6; i++)
{
getRandom(0,1000);
}
}
You will now get Number1, Number1, Number1, Number1, Number1, Number1 (1 seed, 6 equal sequences of many numbers, always pick the same starting number from each equal sequence).. At some point Number1 will be different, because the seed changes over time.. but you need to wait some time for this, nonetheless, you never pick number2 from the sequence.
The reason is, each time you generate a new sequence with the same seed, hence the sequence is the same over and over again, and each time your random generated will pick the first number in it's sequence, which, with the same seed, is of course always the same.
Not sure if this is technically correct by the underlying methods of the random generator, but that's how it behaves.
In the event that anyone is looking for a "quick and dirty" "solution" (and I use that term with caution) then this will suffice for most.
int secondsSinceMidnight = Convert.ToInt32(DateTime.Now.Subtract(DateTime.Today).TotalSeconds);
Random rand = new Random(secondsSinceMidnight);
var usuallyRandomId = rand.Next();
Please note my use of usually random. I agree that the item marked as the answer is a more correct way of doing this.
This question already has answers here:
Random String Generator Returning Same String [duplicate]
(30 answers)
Closed 8 years ago.
First off I have my "Deck" class here. I've just put in the some basic methods, for testing purposes. It's my first go at creating a "card" program.
public class Deck
{
private int deckCounter = 0;
private List<Card> deckSize = new List<Card>();
private List<Card> shuffledDeck = new List<Card>();
private Random random = new Random();
public Deck()
{
}
public void Build()
{
for (int i = 1; i < 5; i++)
{
for (int k = 1; k < 14; k++)
{
deckSize.Add(new Card(k.ToString(), i));
}
}
}
public void Add(Card card)
{
deckSize.Add(card);
deckCounter++;
}
public Card RemoveCard()
{
Card cardToRemove = deckSize.First();
deckSize.RemoveAt(0);
return cardToRemove;
}
public void ShowContainedCards()
{
int cardCount = 0;
foreach (Card c in deckSize)
{
Console.WriteLine(c.ReturnCardInfo());
cardCount++;
}
Console.WriteLine(cardCount);
}
public void Shuffle()
{
while (deckSize.Count != 0)
{
int i = random.Next(deckSize.Count);
shuffledDeck.Add(deckSize[i]);
deckSize.RemoveAt(i);
}
deckSize = shuffledDeck;
}
public bool IsEmpty()
{
if (deckSize.Any())
{
return false;
}
else return true;
}
public List<Card> GetCardList()
{
return deckSize;
}
}
Basicly, what I do is, this:
Deck deck1 = new Deck();
Deck deck2 = new Deck();
deck1.Build();
deck1.Shuffle();
deck2.Build();
deck2.Shuffle();
After that, I get the exact same shuffle, for deck1 and deck2. Why is that? Also, I'm a newb at this, if you couldn't tell :)
Use the same Random class instance in both deck instances:
Random random = new Random();
Deck deck1 = new Deck(random);
Deck deck2 = new Deck(random);
So, in the constructor:
public class Deck
{
private int deckCounter = 0;
private List<Card> deckSize = new List<Card>();
private List<Card> shuffledDeck = new List<Card>();
private Random random;
public Deck(Random random)
{
this.random = random;
}
The current problem with your code, is that the two instances of Random that are created are seeded the same. This causes them to produce the same results. Using the same instance of Random means the second shuffle will build on top of the seeded results of the first shuffle.
From the docs:
The default seed value is derived from the system clock and has finite resolution. As a result, different Random objects that are created in close succession by a call to the default constructor will have identical default seed values and, therefore, will produce identical sets of random numbers.
The same docs also suggest a solution:
This problem can be avoided by using a single Random object to generate all random numbers.
Hence, one possible solution would be to make your random generator static, so all of your Deck instances share the same Random instance:
private static Random random = new Random();
That way, you would even avoid changing any part of the public interface of your Deck class.
Computers are inherently not random, so any random number generator will actually be using an algorithm to produce output that looks random. The thing with this is that there's always a starting point, and if you know where it' starting from, you can predict the outcome. Random number generators therefore have a "seed" which tells it where to start. The same seed will always give the same sequence of "random" numbers.
Both times, you're using new Random(), which uses the default seed. In some languages, you'd be advised to pass the current time as a seed, but C# does that for you. However, if you create two Random objects close together, they're likely to get the same time, which is what's happening here.
If you made your Random static, then all your random numbers would come from the same source, so the two decks would get successive random numbers, not the same ones in parallel.
All I want is a pragmatic random number generator in C# so I can say e.g.
int dummyAge = MathHelpers.GetRandomNumber(20,70);
and have it seem quasi random, e.g. to generate dummy data.
Most stack overflow questions on this topic and on the web get into a philosophical discussions on true randomness which is not what I'm interested at the moment, e.g. I did one in PHP a long time ago which uses milliseconds/sleep which is fine for dummy data, I'm just trying to do this in C# quick.
Does anyone have a quick half-decent C# random number generator based on some time seed, etc. or, how could I change the following code so that it always doesn't generate the same 5 number in a row?
using System;
namespace TestRandom23874
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("the random number is: {0}", MathHelpers.GetRandomNumber(1, 10));
Console.WriteLine("the random number is: {0}", MathHelpers.GetRandomNumber(1, 10));
Console.WriteLine("the random number is: {0}", MathHelpers.GetRandomNumber(1, 10));
Console.WriteLine("the random number is: {0}", MathHelpers.GetRandomNumber(1, 10));
Console.WriteLine("the random number is: {0}", MathHelpers.GetRandomNumber(1, 10));
Console.ReadLine();
}
}
public class MathHelpers
{
public static int GetRandomNumber(int min, int max)
{
Random random = new Random();
return random.Next(min, max);
}
}
}
public class MathHelpers
{
private static Random random = new Random();
public static int GetRandomNumber(int min, int max)
{
return random.Next(min, max);
}
}
This way, you're not creating a new Random object every time, rather you're reusing the same one. When you recreate a new one quickly enough, they will yield the same results. If however, you reuse an existing one, you'll get randomness.
BFree's answer is fine, but I think it's also worth mentioning a slightly different pattern - passing the Random instance into anything that needs it, rather than always using a single instance via a static variable. The downside of the latter approach is that Random isn't thread-safe. You either need some locking, or thread-local variables, or avoiding using multiple threads to start with. So I would adjust the original code in the question to:
using System;
namespace TestRandom23874
{
class Program
{
static void Main(string[] args)
{
Random rng = new Random();
Console.WriteLine("the random number is: {0}",
MathHelpers.GetRandomNumber(rng, 1, 10));
Console.WriteLine("the random number is: {0}",
MathHelpers.GetRandomNumber(rng, 1, 10));
Console.WriteLine("the random number is: {0}",
MathHelpers.GetRandomNumber(rng, 1, 10));
Console.WriteLine("the random number is: {0}",
MathHelpers.GetRandomNumber(rng, 1, 10));
Console.WriteLine("the random number is: {0}",
MathHelpers.GetRandomNumber(rng, 1, 10));
}
}
public class MathHelpers
{
public static int GetRandomNumber(Random random, int min, int max)
{
return random.Next(min, max);
}
}
}
It's just basic inversion of control, really. You might have one static RNG with locking round it, used to generate a new instance of Random in a thread-safe way when you need it (by randomly generating a seed and then using that to create the instance) then reusing the Random throughout a particular single-threaded set of operations.