Represents a pseudo-random number generator, a device that produces a sequence of numbers that meet certain statistical requirements for randomness.
To browse the .NET Framework source code for this type, see the Reference Source.
Assembly: mscorlib (in mscorlib.dll)
Thetype exposes the following members.
|Equals(Object)||Determines whether the specified object is equal to the current object. (Inherited from Object.)|
|Finalize||Allows an object to try to free resources and perform other cleanup operations before it is reclaimed by garbage collection. (Inherited from Object.)|
|GetHashCode||Serves as the default hash function. (Inherited from Object.)|
|GetType||Gets the Type of the current instance. (Inherited from Object.)|
|MemberwiseClone||Creates a shallow copy of the current Object. (Inherited from Object.)|
|Next()||Returns a nonnegative random integer.|
|Next(Int32)||Returns a nonnegative random integer that is less than the specified maximum.|
|Next(Int32, Int32)||Returns a random integer that is within a specified range.|
|NextBytes||Fills the elements of a specified array of bytes with random numbers.|
|NextDouble||Returns a random floating-point number between 0.0 and 1.0.|
|Sample||Returns a random floating-point number between 0.0 and 1.0.|
|ToString||Returns a string that represents the current object. (Inherited from Object.)|
To view the .NET Framework source code for this type, see the Reference Source. You can browse through the source code online, download the reference for offline viewing, and step through the sources (including patches and updates) during debugging; see instructions.
Pseudo-random numbers are chosen with equal probability from a finite set of numbers. The chosen numbers are not completely random because a definite mathematical algorithm is used to select them, but they are sufficiently random for practical purposes. The current implementation of the class is based on Donald E. Knuth's subtractive random number generator algorithm. For more information, see D. E. Knuth. "The Art of Computer Programming, volume 2: Seminumerical Algorithms". Addison-Wesley, Reading, MA, second edition, 1981.
The random number generation starts from a seed value. If the same seed is used repeatedly, the same series of numbers is generated. One way to produce different sequences is to make the seed value time-dependent, thereby producing a different series with each new instance of . By default, the parameterless constructor of the class uses the system clock to generate its seed value, while its parameterized constructor can take an Int32 value based on the number of ticks in the current time. However, because the clock has finite resolution, using the parameterless constructor to create different objects in close succession creates random number generators that produce identical sequences of random numbers. The following example illustrates that two objects that are instantiated in close succession generate an identical series of random numbers.
This problem can be avoided by creating a single Random object rather than multiple ones.
To improve performance, create one object to generate many random numbers over time, instead of repeatedly creating a new objects to generate one random number.
To generate a cryptographically secure random number suitable for creating a random password, for example, use a class derived from System.Security.Cryptography::RandomNumberGenerator such as System.Security.Cryptography::RNGCryptoServiceProvider.
The Random class and thread safety
Instead of instantiating individual objects, we recommend that you create a single instance to generate all the random numbers needed by your app. However, objects are not thread safe. If your app calls methods from multiple threads, you must use a synchronization object to ensure that only one thread can access the random number generator at a time. If you don't ensure that the object is accessed in a thread-safe way, calls to methods that return random numbers return 0.
The following example uses the C# lock Statement and the Visual Basic SyncLock statement to ensure that a single random number generator is accessed by 11 threads in a thread-safe manner. Each thread generates two million random numbers, counts the number of random numbers generated and calculates their sum, and then updates the totals for all threads when it finishes executing.
The example ensures thread-safety in the following ways:
The ThreadStaticAttribute attribute is used to define thread-local variables for the total of random numbers generated and their sum for each thread.
A lock protects access to the variables for the total count and sum of all random numbers generated on all threads.
A semaphore (the CountdownEvent object) is used to ensure that the main thread blocks until all other threads complete execution.
The example checks whether the random number generator has become corrupted by determining whether two consecutive calls to random number generation methods return 0. If corruption is detected, the example uses the CancellationTokenSource object to signal that all threads should be canceled.
Before generating each random number, each thread checks the state of the CancellationToken object. If cancellation is requested, the example calls the CancellationToken::ThrowIfCancellationRequested method to cancel the thread.
It differs from the first example in the following ways:
Because the variables to keep track of the number of random numbers generated and their sum in each task are local to the task, there is no need to use the ThreadStaticAttribute attribute.
The exception that results from task cancellation is surfaced in the Task::WaitAll method. In the previous example, it is handled by each thread.
The implementation of the random number generator in the class isn't guaranteed to remain the same across major versions of the .NET Framework. As a result, you shouldn't assume that the same seed will result in the same pseudo-random sequence in different versions of the .NET Framework.Notes to Inheritors
In the .NET Framework versions 1.0 and 1.1, a minimum implementation of a class derived from required overriding the Sample method to define a new or modified algorithm for generating random numbers. The derived class could then rely on the base class implementation of the Random::Next(), Random::Next(Int32), Random::Next(Int32, Int32), NextBytes, and NextDouble methods to call the derived class implementation of the Sample method.
In the .NET Framework version 2.0 and later, the behavior of the Random::Next(), Random::Next(Int32, Int32), and NextBytes methods have changed so that these methods do not necessarily call the derived class implementation of the Sample method. As a result, classes derived from that target the .NET Framework 2.0 and later should also override these three methods.
The following example generates a random integer that it uses as an index to retrieve a string value from an array.