# RandomRandomRandomRandom Class

## Definition

Stellt einen Generator für Pseudozufallszahlen dar, d. h. ein Gerät, das eine Zahlenfolge erzeugt, die bestimmte statistische Anforderungen hinsichtlich ihrer Zufälligkeit erfüllt. Represents a pseudo-random number generator, which is a device that produces a sequence of numbers that meet certain statistical requirements for randomness.

``public ref class Random``
``````[System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public class Random``````
``type Random = class``
``Public Class Random``
Vererbung
RandomRandomRandomRandom
Attribute
ComVisibleAttribute SerializableAttribute

## Beispiele

Das folgende Beispiel erstellt einen einzelnen Zufallszahlen-Generator und ruft seine NextBytes, Next, und NextDouble Methoden zum Generieren von Sequenzen von Zufallszahlen in verschiedenen Bereichen.The following example creates a single random number generator and calls its NextBytes, Next, and NextDouble methods to generate sequences of random numbers within different ranges.

``````using namespace System;

void main()
{
// Instantiate random number generator using system-supplied value as seed.
Random^ rand = gcnew Random();
// Generate and display 5 random byte (integer) values.
array<Byte>^ bytes = gcnew array<Byte>(4);
rand->NextBytes(bytes);
Console::WriteLine("Five random byte values:");
for each (Byte byteValue in bytes)
Console::Write("{0, 5}", byteValue);
Console::WriteLine();
// Generate and display 5 random integers.
Console::WriteLine("Five random integer values:");
for (int ctr = 0; ctr <= 4; ctr++)
Console::Write("{0,15:N0}", rand->Next());
Console::WriteLine();
// Generate and display 5 random integers between 0 and 100.//
Console::WriteLine("Five random integers between 0 and 100:");
for (int ctr = 0; ctr <= 4; ctr++)
Console::Write("{0,8:N0}", rand->Next(101));
Console::WriteLine();
// Generate and display 5 random integers from 50 to 100.
Console::WriteLine("Five random integers between 50 and 100:");
for (int ctr = 0; ctr <= 4; ctr++)
Console::Write("{0,8:N0}", rand->Next(50, 101));
Console::WriteLine();
// Generate and display 5 random floating point values from 0 to 1.
Console::WriteLine("Five Doubles.");
for (int ctr = 0; ctr <= 4; ctr++)
Console::Write("{0,8:N3}", rand->NextDouble());
Console::WriteLine();
// Generate and display 5 random floating point values from 0 to 5.
Console::WriteLine("Five Doubles between 0 and 5.");
for (int ctr = 0; ctr <= 4; ctr++)
Console::Write("{0,8:N3}", rand->NextDouble() * 5);
}
// The example displays output like the following:
//    Five random byte values:
//      194  185  239   54  116
//    Five random integer values:
//        507,353,531  1,509,532,693  2,125,074,958  1,409,512,757    652,767,128
//    Five random integers between 0 and 100:
//          16      78      94      79      52
//    Five random integers between 50 and 100:
//          56      66      96      60      65
//    Five Doubles.
//       0.943   0.108   0.744   0.563   0.415
//    Five Doubles between 0 and 5.
//       2.934   3.130   0.292   1.432   4.369
``````
``````using System;

public class Class1
{
public static void Main()
{
// Instantiate random number generator using system-supplied value as seed.
Random rand = new Random();
// Generate and display 5 random byte (integer) values.
byte[] bytes = new byte[5];
rand.NextBytes(bytes);
Console.WriteLine("Five random byte values:");
foreach (byte byteValue in bytes)
Console.Write("{0, 5}", byteValue);
Console.WriteLine();
// Generate and display 5 random integers.
Console.WriteLine("Five random integer values:");
for (int ctr = 0; ctr <= 4; ctr++)
Console.Write("{0,15:N0}", rand.Next());
Console.WriteLine();
// Generate and display 5 random integers between 0 and 100.//
Console.WriteLine("Five random integers between 0 and 100:");
for (int ctr = 0; ctr <= 4; ctr++)
Console.Write("{0,8:N0}", rand.Next(101));
Console.WriteLine();
// Generate and display 5 random integers from 50 to 100.
Console.WriteLine("Five random integers between 50 and 100:");
for (int ctr = 0; ctr <= 4; ctr++)
Console.Write("{0,8:N0}", rand.Next(50, 101));
Console.WriteLine();
// Generate and display 5 random floating point values from 0 to 1.
Console.WriteLine("Five Doubles.");
for (int ctr = 0; ctr <= 4; ctr++)
Console.Write("{0,8:N3}", rand.NextDouble());
Console.WriteLine();
// Generate and display 5 random floating point values from 0 to 5.
Console.WriteLine("Five Doubles between 0 and 5.");
for (int ctr = 0; ctr <= 4; ctr++)
Console.Write("{0,8:N3}", rand.NextDouble() * 5);
}
}
// The example displays output like the following:
//    Five random byte values:
//      194  185  239   54  116
//    Five random integer values:
//        507,353,531  1,509,532,693  2,125,074,958  1,409,512,757    652,767,128
//    Five random integers between 0 and 100:
//          16      78      94      79      52
//    Five random integers between 50 and 100:
//          56      66      96      60      65
//    Five Doubles.
//       0.943   0.108   0.744   0.563   0.415
//    Five Doubles between 0 and 5.
//       2.934   3.130   0.292   1.432   4.369
``````
``````Module Example
Public Sub Main()
' Instantiate random number generator using system-supplied value as seed.
Dim rand As New Random()
' Generate and display 5 random byte (integer) values.
Dim bytes(4) As Byte
rand.NextBytes(bytes)
Console.WriteLine("Five random byte values:")
For Each byteValue As Byte In bytes
Console.Write("{0, 5}", byteValue)
Next
Console.WriteLine()
' Generate and display 5 random integers.
Console.WriteLine("Five random integer values:")
For ctr As Integer = 0 To 4
Console.Write("{0,15:N0}", rand.Next)
Next
Console.WriteLine()
' Generate and display 5 random integers between 0 and 100.'
Console.WriteLine("Five random integers between 0 and 100:")
For ctr As Integer = 0 To 4
Console.Write("{0,8:N0}", rand.Next(101))
Next
Console.WriteLine()
' Generate and display 5 random integers from 50 to 100.
Console.WriteLine("Five random integers between 50 and 100:")
For ctr As Integer = 0 To 4
Console.Write("{0,8:N0}", rand.Next(50, 101))
Next
Console.WriteLine()
' Generate and display 5 random floating point values from 0 to 1.
Console.WriteLine("Five Doubles.")
For ctr As Integer = 0 To 4
Console.Write("{0,8:N3}", rand.NextDouble())
Next
Console.WriteLine()
' Generate and display 5 random floating point values from 0 to 5.
Console.WriteLine("Five Doubles between 0 and 5.")
For ctr As Integer = 0 To 4
Console.Write("{0,8:N3}", rand.NextDouble() * 5)
Next
End Sub
End Module
' The example displays output like the following:
'    Five random byte values:
'      194  185  239   54  116
'    Five random integer values:
'        507,353,531  1,509,532,693  2,125,074,958  1,409,512,757    652,767,128
'    Five random integers between 0 and 100:
'          16      78      94      79      52
'    Five random integers between 50 and 100:
'          56      66      96      60      65
'    Five Doubles.
'       0.943   0.108   0.744   0.563   0.415
'    Five Doubles between 0 and 5.
'       2.934   3.130   0.292   1.432   4.369
``````

Im folgenden Beispiel wird eine zufällige ganze Zahl, die sie als Index verwendet. um einen Zeichenfolgenwert aus einem Array abzurufen.The following example generates a random integer that it uses as an index to retrieve a string value from an array.

``````using namespace System;

void main()
{
Random^ rnd = gcnew Random();
array<String^>^ malePetNames = { "Rufus", "Bear", "Dakota", "Fido",
"Vanya", "Samuel", "Koani", "Volodya",
"Prince", "Yiska" };
array<String^>^ femalePetNames = { "Maggie", "Penny", "Saya", "Princess",
"Starlight", "Talla" };

// Generate random indexes for pet names.
int mIndex = rnd->Next(malePetNames->Length);
int fIndex = rnd->Next(femalePetNames->Length);

// Display the result.
Console::WriteLine("Suggested pet name of the day: ");
Console::WriteLine("   For a male:     {0}", malePetNames[mIndex]);
Console::WriteLine("   For a female:   {0}", femalePetNames[fIndex]);
}
// The example displays the following output:
//       Suggested pet name of the day:
//          For a male:     Koani
//          For a female:   Maggie
``````
``````using System;

public class Example
{
public static void Main()
{
Random rnd = new Random();
string[] malePetNames = { "Rufus", "Bear", "Dakota", "Fido",
"Vanya", "Samuel", "Koani", "Volodya",
"Prince", "Yiska" };
string[] femalePetNames = { "Maggie", "Penny", "Saya", "Princess",
"Starlight", "Talla" };

// Generate random indexes for pet names.
int mIndex = rnd.Next(malePetNames.Length);
int fIndex = rnd.Next(femalePetNames.Length);

// Display the result.
Console.WriteLine("Suggested pet name of the day: ");
Console.WriteLine("   For a male:     {0}", malePetNames[mIndex]);
Console.WriteLine("   For a female:   {0}", femalePetNames[fIndex]);
}
}
// The example displays the following output:
//       Suggested pet name of the day:
//          For a male:     Koani
//          For a female:   Maggie
``````
``````Module Example
Public Sub Main()
Dim rnd As New Random()
Dim malePetNames() As String = { "Rufus", "Bear", "Dakota", "Fido",
"Vanya", "Samuel", "Koani", "Volodya",
"Prince", "Yiska" }
Dim femalePetNames() As String = { "Maggie", "Penny", "Saya", "Princess",
"Starlight", "Talla" }

' Generate random indexes for pet names.
Dim mIndex As Integer = rnd.Next(malePetNames.Length)
Dim fIndex As Integer = rnd.Next(femalePetNames.Length)

' Display the result.
Console.WriteLine("Suggested pet name of the day: ")
Console.WriteLine("   For a male:     {0}", malePetNames(mIndex))
Console.WriteLine("   For a female:   {0}", femalePetNames(fIndex))
End Sub
End Module
' The example displays output like the following:
'       Suggested pet name of the day:
'          For a male:     Koani
'          For a female:   Maggie
``````

## Hinweise

Pseudozufallszahlen werden von einer begrenzten Menge von Zahlen mit gleicher Wahrscheinlichkeit ausgewählt.Pseudo-random numbers are chosen with equal probability from a finite set of numbers. Die gewählten Zahlen sind nicht vollständig wahlfreien, da ein mathematischer Algorithmus verwendet wird, um sie auszuwählen, aber sie für praktische Zwecke ausreichend zufälligen sind.The chosen numbers are not completely random because a mathematical algorithm is used to select them, but they are sufficiently random for practical purposes. Die aktuelle Implementierung von der Random Klasse basiert darauf, dass eine geänderte Version des Donald E. Knuths Subtraktive Algorithmus mit Zufallszahlengenerator.The current implementation of the Random class is based on a modified version of Donald E. Knuth's subtractive random number generator algorithm. Weitere Informationen finden Sie unter d E.For more information, see D. E. Knuth.Knuth. The Art of Computer Programming "," Volume 2: Seminumerical Algorithms.The Art of Computer Programming, Volume 2: Seminumerical Algorithms. Addison-Wesley, lesen, MA, 3. Auflage, 1997.Addison-Wesley, Reading, MA, third edition, 1997.

Verwenden Sie eine kryptografisch sichere Zufallszahl, z. B. ein generieren, die für Sie erstellen ein zufälliges Kennwort, geeignet ist die RNGCryptoServiceProvider Klasse oder leiten eine Klasse von System.Security.Cryptography.RandomNumberGenerator.To generate a cryptographically secure random number, such as one that's suitable for creating a random password, use the RNGCryptoServiceProvider class or derive a class from System.Security.Cryptography.RandomNumberGenerator.

In diesem Thema:In this topic:

### Instanziieren den ZufallszahlengeneratorInstantiating the random number generator

Instanziieren Sie den Zufallszahlen-Generator durch Angeben eines Ausgangswert-Werts (ein Startwert für den Algorithmus von Pseudozufallszahlen Generation) zu einem Random Klassenkonstruktor.You instantiate the random number generator by providing a seed value (a starting value for the pseudo-random number generation algorithm) to a Random class constructor. Sie können den Ausgangswert entweder explizit oder implizit bereitstellen:You can supply the seed value either explicitly or implicitly:

• Die Random(Int32) Konstruktor verwendet einen expliziten Seed-Wert, den Sie angeben.The Random(Int32) constructor uses an explicit seed value that you supply.

• Die Random() Konstruktor verwendet die Systemuhr, um einen Ausgangswert angeben.The Random() constructor uses the system clock to provide a seed value. Dies ist die gängigste Methode instanziieren Sie den Zufallszahlengenerator an.This is the most common way of instantiating the random number generator.

Wenn der gleiche Ausgangswert, für einzelne verwendet wird Random Objekten, die sie die gleiche Reihe von Zufallszahlen generiert.If the same seed is used for separate Random objects, they will generate the same series of random numbers. Dies kann nützlich für das Erstellen einer Testsammlung aus, die zufällige Werte verarbeitet oder für die Wiedergabe von Spielen, die ihre Daten von Zufallszahlen abgeleitet sein.This can be useful for creating a test suite that processes random values, or for replaying games that derive their data from random numbers. Beachten Sie jedoch, dass Random Objekte in Prozesse, die unter unterschiedlichen Versionen von .NET Framework ausgeführt werden. möglicherweise verschiedene Folge von Zufallszahlen zurück, selbst wenn sie mit dem identischen Startwerten instanziiert werden.However, note that Random objects in processes running under different versions of the .NET Framework may return different series of random numbers even if they're instantiated with identical seed values.

Um verschiedene Sequenzen von Zufallszahlen zu generieren, können Sie vornehmen den Ausgangswert zeitabhängige, und erzeugt eine andere Datenreihe mit jeder neuen Instanz von Random.To produce different sequences of random numbers, you can make the seed value time-dependent, thereby producing a different series with each new instance of Random. Die parametrisierte Random(Int32) Konstruktor dauert ein Int32 -Wert auf Grundlage der Anzahl der Ticks in der aktuellen Zeit, während die parameterlose Random() Konstruktor verwendet die Systemuhr zum Generieren des Startwerts.The parameterized Random(Int32) constructor can take an Int32 value based on the number of ticks in the current time, whereas the parameterless Random() constructor uses the system clock to generate its seed value. Aber da die Uhr endliche Auflösung verfügt, mithilfe des Konstruktors unterschiedlichen Random Objekte unmittelbar nacheinander erstellt random Number-Generatoren, die identische Sequenzen von Zufallszahlen zu generieren.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. Im folgende Beispiel wird veranschaulicht, wie zwei Random Objekte, die unmittelbar nacheinander instanziiert werden, generieren eine identische Folge von Zufallszahlen.The following example illustrates how two Random objects that are instantiated in close succession generate an identical series of random numbers. In den meisten Windows-Systemen Random innerhalb von 15 Millisekunden voneinander erstellten Objekte haben wahrscheinlich identische Ausgangswerte.On most Windows systems, Random objects created within 15 milliseconds of one another are likely to have identical seed values.

``````using namespace System;

void main()
{
array<Byte>^ bytes1 = gcnew array<Byte>(100);
array<Byte>^ bytes2 = gcnew array<Byte>(100);
Random^ rnd1 = gcnew Random();
Random^ rnd2 = gcnew Random();

rnd1->NextBytes(bytes1);
rnd2->NextBytes(bytes2);

Console::WriteLine("First Series:");
for (int ctr = bytes1->GetLowerBound(0);
ctr <= bytes1->GetUpperBound(0);
ctr++) {
Console::Write("{0, 5}", bytes1[ctr]);
if ((ctr + 1) % 10 == 0) Console::WriteLine();
}
Console::WriteLine();
Console::WriteLine("Second Series:");
for (int ctr = bytes2->GetLowerBound(0);
ctr <= bytes2->GetUpperBound(0);
ctr++) {
Console::Write("{0, 5}", bytes2[ctr]);
if ((ctr + 1) % 10 == 0) Console::WriteLine();
}
}
// The example displays output like the following:
//       First Series:
//          97  129  149   54   22  208  120  105   68  177
//         113  214   30  172   74  218  116  230   89   18
//          12  112  130  105  116  180  190  200  187  120
//           7  198  233  158   58   51   50  170   98   23
//          21    1  113   74  146  245   34  255   96   24
//         232  255   23    9  167  240  255   44  194   98
//          18  175  173  204  169  171  236  127  114   23
//         167  202  132   65  253   11  254   56  214  127
//         145  191  104  163  143    7  174  224  247   73
//          52    6  231  255    5  101   83  165  160  231
//
//       Second Series:
//          97  129  149   54   22  208  120  105   68  177
//         113  214   30  172   74  218  116  230   89   18
//          12  112  130  105  116  180  190  200  187  120
//           7  198  233  158   58   51   50  170   98   23
//          21    1  113   74  146  245   34  255   96   24
//         232  255   23    9  167  240  255   44  194   98
//          18  175  173  204  169  171  236  127  114   23
//         167  202  132   65  253   11  254   56  214  127
//         145  191  104  163  143    7  174  224  247   73
//          52    6  231  255    5  101   83  165  160  231
``````
``````using System;

public class Class1
{
public static void Main()
{
byte[] bytes1 = new byte[100];
byte[] bytes2 = new byte[100];
Random rnd1 = new Random();
Random rnd2 = new Random();

rnd1.NextBytes(bytes1);
rnd2.NextBytes(bytes2);

Console.WriteLine("First Series:");
for (int ctr = bytes1.GetLowerBound(0);
ctr <= bytes1.GetUpperBound(0);
ctr++) {
Console.Write("{0, 5}", bytes1[ctr]);
if ((ctr + 1) % 10 == 0) Console.WriteLine();
}
Console.WriteLine();
Console.WriteLine("Second Series:");
for (int ctr = bytes2.GetLowerBound(0);
ctr <= bytes2.GetUpperBound(0);
ctr++) {
Console.Write("{0, 5}", bytes2[ctr]);
if ((ctr + 1) % 10 == 0) Console.WriteLine();
}
}
}
// The example displays output like the following:
//       First Series:
//          97  129  149   54   22  208  120  105   68  177
//         113  214   30  172   74  218  116  230   89   18
//          12  112  130  105  116  180  190  200  187  120
//           7  198  233  158   58   51   50  170   98   23
//          21    1  113   74  146  245   34  255   96   24
//         232  255   23    9  167  240  255   44  194   98
//          18  175  173  204  169  171  236  127  114   23
//         167  202  132   65  253   11  254   56  214  127
//         145  191  104  163  143    7  174  224  247   73
//          52    6  231  255    5  101   83  165  160  231
//
//       Second Series:
//          97  129  149   54   22  208  120  105   68  177
//         113  214   30  172   74  218  116  230   89   18
//          12  112  130  105  116  180  190  200  187  120
//           7  198  233  158   58   51   50  170   98   23
//          21    1  113   74  146  245   34  255   96   24
//         232  255   23    9  167  240  255   44  194   98
//          18  175  173  204  169  171  236  127  114   23
//         167  202  132   65  253   11  254   56  214  127
//         145  191  104  163  143    7  174  224  247   73
//          52    6  231  255    5  101   83  165  160  231
``````
``````Module modMain

Public Sub Main()
Dim bytes1(99), bytes2(99) As Byte
Dim rnd1 As New Random()
Dim rnd2 As New Random()

rnd1.NextBytes(bytes1)
rnd2.NextBytes(bytes2)

Console.WriteLine("First Series:")
For ctr As Integer = bytes1.GetLowerBound(0) to bytes1.GetUpperBound(0)
Console.Write("{0, 5}", bytes1(ctr))
If (ctr + 1) Mod 10 = 0 Then Console.WriteLine()
Next
Console.WriteLine()
Console.WriteLine("Second Series:")
For ctr As Integer = bytes2.GetLowerBound(0) to bytes2.GetUpperBound(0)
Console.Write("{0, 5}", bytes2(ctr))
If (ctr + 1) Mod 10 = 0 Then Console.WriteLine()
Next
End Sub
End Module
' The example displays output like the following:
'       First Series:
'          97  129  149   54   22  208  120  105   68  177
'         113  214   30  172   74  218  116  230   89   18
'          12  112  130  105  116  180  190  200  187  120
'           7  198  233  158   58   51   50  170   98   23
'          21    1  113   74  146  245   34  255   96   24
'         232  255   23    9  167  240  255   44  194   98
'          18  175  173  204  169  171  236  127  114   23
'         167  202  132   65  253   11  254   56  214  127
'         145  191  104  163  143    7  174  224  247   73
'          52    6  231  255    5  101   83  165  160  231
'
'       Second Series:
'          97  129  149   54   22  208  120  105   68  177
'         113  214   30  172   74  218  116  230   89   18
'          12  112  130  105  116  180  190  200  187  120
'           7  198  233  158   58   51   50  170   98   23
'          21    1  113   74  146  245   34  255   96   24
'         232  255   23    9  167  240  255   44  194   98
'          18  175  173  204  169  171  236  127  114   23
'         167  202  132   65  253   11  254   56  214  127
'         145  191  104  163  143    7  174  224  247   73
'          52    6  231  255    5  101   83  165  160  231
``````

Um dieses Problem zu vermeiden, erstellen Sie eine einzelne Random Objekt anstelle mehrerer Objekte.To avoid this problem, create a single Random object instead of multiple objects.

### Vermeiden Sie mehrere Instanziierungen vonAvoiding multiple instantiations

Initialisieren von zwei random Number-Generatoren in einer engen Schleife oder in rascher Folge erstellt zwei random Number-Generatoren, die identische Sequenzen von Zufallszahlen erzeugen können.Initializing two random number generators in a tight loop or in rapid succession creates two random number generators that can produce identical sequences of random numbers. In den meisten Fällen Dies ist nicht der Entwickler den Zweck und kann zu Leistungseinbußen zu vermeiden, führen, da instanziieren und Initialisieren eines Zufallszahlen-Generators ein relativ teurer Vorgang ist.In most cases, this is not the developer's intent and can lead to performance issues, because instantiating and initializing a random number generator is a relatively expensive process.

Sowohl zum Verbessern der Leistung und verhindern, dass versehentlich erstellt separate random Number-Generatoren, die identische numerische Sequenzen zu generieren, es wird empfohlen, dass Sie eine erstellen Random Objekt, das viele zufällige Zahlen im Laufe der Zeit, statt zu generieren. neue Random Objekte, die eine Zufallszahl zu generieren.Both to improve performance and to avoid inadvertently creating separate random number generators that generate identical numeric sequences, we recommend that you create one Random object to generate many random numbers over time, instead of creating new Random objects to generate one random number.

Allerdings die Random Klasse nicht threadsicher.However, the Random class isn't thread safe. Wenn Sie aufrufen Random Methoden von mehreren Threads, befolgen Sie die Richtlinien, die im nächsten Abschnitt erläutert.If you call Random methods from multiple threads, follow the guidelines discussed in the next section.

Im folgenden Beispiel wird der C#- lock-Anweisung und die Visual Basic SyncLock-Anweisung um sicherzustellen, dass ein einzelnes Zufallszahlen-Generators von 11 Threads auf threadsichere Weise zugegriffen wird.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. Jeder Thread 2 Millionen Zufallszahlen generiert, zählt die Anzahl von Zufallszahlen generiert, deren Summe berechnet und aktualisiert dann die Gesamtwerte für alle Threads aus, wenn sie mit der Ausführung beendet ist.Each thread generates 2 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.

``````using namespace System;

ref class Example
{
private:
[ThreadStatic] static double previous = 0.0;
static CancellationTokenSource^ source;
static CountdownEvent^ countdown;
static Object^ randLock;
static Object^ numericLock;
static Random^ rand;
double totalValue = 0.0;
int totalCount = 0;

public:
Example()
{
rand = gcnew Random();
randLock = gcnew Object();
numericLock = gcnew Object();
countdown = gcnew CountdownEvent(1);
source = gcnew CancellationTokenSource();
}

void Execute()
{
CancellationToken^ token = source->Token;

{
}
this->GetRandomNumbers(token);

countdown->Signal();
// Make sure all threads have finished.
countdown->Wait();

Console::WriteLine("\nTotal random numbers generated: {0:N0}", totalCount);
Console::WriteLine("Total sum of all random numbers: {0:N2}", totalValue);
Console::WriteLine("Random number mean: {0:N4}", totalValue/totalCount);
}

private:
void GetRandomNumbers(Object^ o)
{
CancellationToken^ token = (CancellationToken) o;
double result = 0.0;

try {
for (int ctr = 0; ctr < 2000000; ctr++)
{
// Make sure there's no corruption of Random.
token->ThrowIfCancellationRequested();

Monitor::Enter(randLock);
result = rand->NextDouble();
Monitor::Exit(randLock);
// Check for corruption of Random instance.
if ((result == previous) && result == 0) {
source->Cancel();
}
else {
previous = result;
}
}

Console::WriteLine("Sum of random numbers: {0:N2}", perThreadTotal);

// Update overall totals.
Monitor::Enter(numericLock);
Monitor::Exit(numericLock);
}
catch (OperationCanceledException^ e) {
}
finally {
countdown->Signal();
}
}
};

void main()
{
Example^ ex = gcnew Example();
ex->Execute();
}
// The example displays output like the following:
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 1,000,491.05
//       Random number mean: 0.5002
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,329.64
//       Random number mean: 0.4997
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 1,000,166.89
//       Random number mean: 0.5001
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,628.37
//       Random number mean: 0.4998
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,920.89
//       Random number mean: 0.5000
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,370.45
//       Random number mean: 0.4997
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,330.92
//       Random number mean: 0.4997
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 1,000,172.79
//       Random number mean: 0.5001
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 1,000,079.43
//       Random number mean: 0.5000
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,817.91
//       Random number mean: 0.4999
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,930.63
//       Random number mean: 0.5000
//
//
//       Total random numbers generated: 22,000,000
//       Total sum of all random numbers: 10,998,238.98
//       Random number mean: 0.4999
``````
``````using System;

public class Example
{
[ThreadStatic] static double previous = 0.0;
static CancellationTokenSource source;
static CountdownEvent countdown;
static Object randLock, numericLock;
static Random rand;
double totalValue = 0.0;
int totalCount = 0;

public Example()
{
rand = new Random();
randLock = new Object();
numericLock = new Object();
countdown = new CountdownEvent(1);
source = new CancellationTokenSource();
}

public static void Main()
{
Example ex = new Example();
ex.Execute();
}

private void Execute()
{
CancellationToken token = source.Token;

{
}
this.GetRandomNumbers(token);

countdown.Signal();
// Make sure all threads have finished.
countdown.Wait();
source.Dispose();

Console.WriteLine("\nTotal random numbers generated: {0:N0}", totalCount);
Console.WriteLine("Total sum of all random numbers: {0:N2}", totalValue);
Console.WriteLine("Random number mean: {0:N4}", totalValue/totalCount);
}

private void GetRandomNumbers(Object o)
{
CancellationToken token = (CancellationToken) o;
double result = 0.0;

try {
for (int ctr = 0; ctr < 2000000; ctr++)
{
// Make sure there's no corruption of Random.
token.ThrowIfCancellationRequested();

lock (randLock) {
result = rand.NextDouble();
}
// Check for corruption of Random instance.
if ((result == previous) && result == 0) {
source.Cancel();
}
else {
previous = result;
}
}

Console.WriteLine("Sum of random numbers: {0:N2}", perThreadTotal);

// Update overall totals.
lock (numericLock) {
}
}
catch (OperationCanceledException e) {
}
finally {
countdown.Signal();
}
}
}
// The example displays output like the following:
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 1,000,491.05
//       Random number mean: 0.5002
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,329.64
//       Random number mean: 0.4997
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 1,000,166.89
//       Random number mean: 0.5001
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,628.37
//       Random number mean: 0.4998
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,920.89
//       Random number mean: 0.5000
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,370.45
//       Random number mean: 0.4997
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,330.92
//       Random number mean: 0.4997
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 1,000,172.79
//       Random number mean: 0.5001
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 1,000,079.43
//       Random number mean: 0.5000
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,817.91
//       Random number mean: 0.4999
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,930.63
//       Random number mean: 0.5000
//
//
//       Total random numbers generated: 22,000,000
//       Total sum of all random numbers: 10,998,238.98
//       Random number mean: 0.4999
``````
``````Imports System.Threading

Module Example
<ThreadStatic> Dim previous As Double = 0.0
Dim source As New CancellationTokenSource()
Dim countdown As New CountdownEvent(1)
Dim randLock As New Object()
Dim numericLock As New Object()
Dim rand As New Random()
Dim totalValue As Double = 0.0
Dim totalCount As Integer = 0

Public Sub Main()

Dim token As CancellationToken = source.Token
For threads As Integer = 1 To 10
Next
GetRandomNumbers(token)

countdown.Signal()
' Make sure all threads have finished.
countdown.Wait()

Console.WriteLine()
Console.WriteLine("Total random numbers generated: {0:N0}", totalCount)
Console.WriteLine("Total sum of all random numbers: {0:N2}", totalValue)
Console.WriteLine("Random number mean: {0:N4}", totalValue/totalCount)
End Sub

Private Sub GetRandomNumbers(o As Object)
Dim token As CancellationToken = CType(o, CancellationToken)
Dim result As Double = 0.0

Try
For ctr As Integer = 1 To 2000000
' Make sure there's no corruption of Random.
token.ThrowIfCancellationRequested()

SyncLock randLock
result = rand.NextDouble()
End SyncLock
' Check for corruption of Random instance.
If result = previous AndAlso result = 0 Then
source.Cancel()
Else
previous = result
End If
Next

Console.WriteLine("Sum of random numbers: {0:N2}", perThreadTotal)
Console.WriteLine()

' Update overall totals.
SyncLock numericLock
End SyncLock
Catch e As OperationCanceledException
Finally
countdown.Signal()
source.Dispose()
End Try
End Sub
End Module
' The example displays output like the following:
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 1,000,491.05
'       Random number mean: 0.5002
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 999,329.64
'       Random number mean: 0.4997
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 1,000,166.89
'       Random number mean: 0.5001
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 999,628.37
'       Random number mean: 0.4998
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 999,920.89
'       Random number mean: 0.5000
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 999,370.45
'       Random number mean: 0.4997
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 999,330.92
'       Random number mean: 0.4997
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 1,000,172.79
'       Random number mean: 0.5001
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 1,000,079.43
'       Random number mean: 0.5000
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 999,817.91
'       Random number mean: 0.4999
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 999,930.63
'       Random number mean: 0.5000
'
'
'       Total random numbers generated: 22,000,000
'       Total sum of all random numbers: 10,998,238.98
'       Random number mean: 0.4999
``````

Im Beispiel wird Threadsicherheit sichergestellt, es gibt folgende Möglichkeiten:The example ensures thread-safety in the following ways:

• Die ThreadStaticAttribute Attribut wird verwendet, um die Thread-lokalen Variablen zu definieren, die die Gesamtzahl der Zufallszahlen generiert und die Summe für jeden Thread nachverfolgen.The ThreadStaticAttribute attribute is used to define thread-local variables that track the total number of random numbers generated and their sum for each thread.

• Eine Sperre (die `lock` -Anweisung in c# und die `SyncLock` -Anweisung in Visual Basic) schützt den Zugriff auf die Variablen für die Gesamtanzahl und die Summe aller zufälligen Zahlen, die auf alle Threads generiert.A lock (the `lock` statement in C# and the `SyncLock` statement in Visual Basic) protects access to the variables for the total count and sum of all random numbers generated on all threads.

• Ein Semaphor (die CountdownEvent Objekt) wird verwendet, um sicherzustellen, dass der Hauptthread blockiert, bis alle anderen Threads vollständig ausgeführt.A semaphore (the CountdownEvent object) is used to ensure that the main thread blocks until all other threads complete execution.

• Im Beispiel wird überprüft, ob für der Zufallszahlengenerator durch bestimmen beschädigt wurde, ob zwei aufeinander folgende Aufrufe von Zufallszahlen generieren, Methoden 0 zurückgegeben.The example checks whether the random number generator has become corrupted by determining whether two consecutive calls to random number generation methods return 0. Wenn eine Beschädigung erkannt wird, wird im Beispiel wird die CancellationTokenSource -Objekt signalisiert, dass es sich bei allen Threads abgebrochen werden soll.If corruption is detected, the example uses the CancellationTokenSource object to signal that all threads should be canceled.

• Vor dem Generieren von jeder Zufallszahl jeder Thread überprüft den Status der CancellationToken Objekt.Before generating each random number, each thread checks the state of the CancellationToken object. Wenn der Abbruch angefordert wird, wird im Beispiel wird die CancellationToken.ThrowIfCancellationRequested Methode, um den Thread abzubrechen.If cancellation is requested, the example calls the CancellationToken.ThrowIfCancellationRequested method to cancel the thread.

Im folgende Beispiel wird mit dem ersten identisch, außer dass mithilfe einer Task -Objekt und ein Lambda-Ausdruck anstelle von Thread Objekte.The following example is identical to the first, except that it uses a Task object and a lambda expression instead of Thread objects.

``````using System;
using System.Collections.Generic;

public class Example
{
static Object randLock, numericLock;
static Random rand;
static CancellationTokenSource source;
double totalValue = 0.0;
int totalCount = 0;

public Example()
{
rand = new Random();
randLock = new Object();
numericLock = new Object();
source = new CancellationTokenSource();
}

{
Example ex = new Example();
await ex.Execute();
}

{

for (int ctr = 0; ctr <= 10; ctr++)
{
CancellationToken token = source.Token;
{
double previous = 0.0;
double result = 0.0;

for (int n = 0; n < 2000000; n++)
{
// Make sure there's no corruption of Random.
token.ThrowIfCancellationRequested();

lock (randLock) {
result = rand.NextDouble();
}
// Check for corruption of Random instance.
if ((result == previous) && result == 0) {
source.Cancel();
}
else {
previous = result;
}
}

// Show result.
Console.WriteLine("Sum of random numbers: {0:N2}", taskTotal);

// Update overall totals.
lock (numericLock) {
}
},
token));
}
try {
Console.WriteLine("\nTotal random numbers generated: {0:N0}", totalCount);
Console.WriteLine("Total sum of all random numbers: {0:N2}", totalValue);
Console.WriteLine("Random number mean: {0:N4}", totalValue/totalCount);
}
catch (AggregateException e) {
foreach (Exception inner in e.InnerExceptions) {
if (canc != null)
else
Console.WriteLine("Exception: {0}", inner.GetType().Name);
}
}
finally {
source.Dispose();
}
}
}
// The example displays output like the following:
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 1,000,502.47
//       Random number mean: 0.5003
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 1,000,445.63
//       Random number mean: 0.5002
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 1,000,556.04
//       Random number mean: 0.5003
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 1,000,178.87
//       Random number mean: 0.5001
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,819.17
//       Random number mean: 0.4999
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 1,000,190.58
//       Random number mean: 0.5001
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,720.21
//       Random number mean: 0.4999
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,000.96
//       Random number mean: 0.4995
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,499.33
//       Random number mean: 0.4997
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 1,000,193.25
//       Random number mean: 0.5001
//
//       Random numbers generated: 2,000,000
//       Sum of random numbers: 999,960.82
//       Random number mean: 0.5000
//
//
//       Total random numbers generated: 22,000,000
//       Total sum of all random numbers: 11,000,067.33
//       Random number mean: 0.5000
``````
``````Imports System.Collections.Generic

Module Example
Dim source As New CancellationTokenSource()
Dim randLock As New Object()
Dim numericLock As New Object()
Dim rand As New Random()
Dim totalValue As Double = 0.0
Dim totalCount As Integer = 0

Public Sub Main()

For ctr As Integer = 1 To 10
Dim token As CancellationToken = source.Token
Dim taskNo As Integer = ctr
Sub()
Dim previous As Double = 0.0
Dim taskCtr As Integer = 0
Dim taskTotal As Double = 0.0
Dim result As Double = 0.0

For n As Integer = 1 To 2000000
' Make sure there's no corruption of Random.
token.ThrowIfCancellationRequested()

SyncLock randLock
result = rand.NextDouble()
End SyncLock
' Check for corruption of Random instance.
If result = previous AndAlso result = 0 Then
source.Cancel()
Else
previous = result
End If
Next

' Show result.
Console.WriteLine("Sum of random numbers: {0:N2}", taskTotal)
Console.WriteLine()

' Update overall totals.
SyncLock numericLock
End SyncLock
End Sub, token))
Next

Try
Console.WriteLine()
Console.WriteLine("Total random numbers generated: {0:N0}", totalCount)
Console.WriteLine("Total sum of all random numbers: {0:N2}", totalValue)
Console.WriteLine("Random number mean: {0:N4}", totalValue/totalCount)
Catch e As AggregateException
For Each inner As Exception In e.InnerExceptions
If canc IsNot Nothing Then
Else
Console.WriteLine("Exception: {0}", inner.GetType().Name)
End If
Next
Finally
source.Dispose()
End Try
End Sub
End Module
' The example displays output like the following:
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 1,000,502.47
'       Random number mean: 0.5003
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 1,000,445.63
'       Random number mean: 0.5002
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 1,000,556.04
'       Random number mean: 0.5003
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 1,000,178.87
'       Random number mean: 0.5001
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 999,819.17
'       Random number mean: 0.4999
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 1,000,190.58
'       Random number mean: 0.5001
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 999,720.21
'       Random number mean: 0.4999
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 999,000.96
'       Random number mean: 0.4995
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 999,499.33
'       Random number mean: 0.4997
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 1,000,193.25
'       Random number mean: 0.5001
'
'       Random numbers generated: 2,000,000
'       Sum of random numbers: 999,960.82
'       Random number mean: 0.5000
'
'
'       Total random numbers generated: 22,000,000
'       Total sum of all random numbers: 11,000,067.33
'       Random number mean: 0.5000
``````

Es unterscheidet sich von dem ersten Beispiel gibt folgenden Möglichkeiten:It differs from the first example in the following ways:

• Die Variablen zum Nachverfolgen der Anzahl von Zufallszahlen generiert und die Summe in jeder Aufgabe gelten lokal in der Aufgabe, daher keine Notwendigkeit besteht, verwenden Sie die ThreadStaticAttribute Attribut.The variables to keep track of the number of random numbers generated and their sum in each task are local to the task, so there is no need to use the ThreadStaticAttribute attribute.

• Die statische Task.WaitAll Methode wird verwendet, um sicherzustellen, dass der Hauptthread nicht abgeschlossen, bevor alle Aufgaben beendet wurden.The static Task.WaitAll method is used to ensure that the main thread doesn't complete before all tasks have finished. Besteht keine Notwendigkeit für die CountdownEvent Objekt.There is no need for the CountdownEvent object.

• Die Ausnahme, die aus den Aufgabenabbruch wird angezeigt, der Task.WaitAll Methode.The exception that results from task cancellation is surfaced in the Task.WaitAll method. Im vorherigen Beispiel wird sie von jedem Thread behandelt.In the previous example, it is handled by each thread.

### Generieren von anderen Typen von ZufallszahlenGenerating different types of random numbers

Der Zufallszahlengenerator bietet Methoden, mit denen Sie die folgenden Arten von Zufallszahlen zu generieren:The random number generator provides methods that let you generate the following kinds of random numbers:

• Eine Reihe von Byte Werte.A series of Byte values. Sie bestimmen die Anzahl der Bytewerte durch Übergeben eines Arrays initialisiert, um die Anzahl der Elemente, die Sie möchten, dass die Methode zurückgibt, die NextBytes Methode.You determine the number of byte values by passing an array initialized to the number of elements you want the method to return to the NextBytes method. Im folgende Beispiel werden 20 Byte an Daten generiert.The following example generates 20 bytes.

``````using namespace System;

void main()
{
Random^ rnd = gcnew Random();
array<Byte>^ bytes = gcnew array<Byte>(20);
rnd->NextBytes(bytes);
for (int ctr = 1; ctr <= bytes->Length; ctr++) {
Console::Write("{0,3}   ", bytes[ctr - 1]);
if (ctr % 10 == 0) Console::WriteLine();
}
}
// The example displays output like the following:
//       141    48   189    66   134   212   211    71   161    56
//       181   166   220   133     9   252   222    57    62    62
``````
``````using System;

public class Example
{
public static void Main()
{
Random rnd = new Random();
Byte[] bytes = new Byte[20];
rnd.NextBytes(bytes);
for (int ctr = 1; ctr <= bytes.Length; ctr++) {
Console.Write("{0,3}   ", bytes[ctr - 1]);
if (ctr % 10 == 0) Console.WriteLine();
}
}
}
// The example displays output like the following:
//       141    48   189    66   134   212   211    71   161    56
//       181   166   220   133     9   252   222    57    62    62
``````
``````Module Example
Public Sub Main()
Dim rnd As New Random()
Dim bytes(19) As Byte
rnd.NextBytes(bytes)
For ctr As Integer = 1 To bytes.Length
Console.Write("{0,3}   ", bytes(ctr - 1))
If ctr Mod 10 = 0 Then Console.WriteLine()
Next
End Sub
End Module
' The example displays output like the following:
'       141    48   189    66   134   212   211    71   161    56
'       181   166   220   133     9   252   222    57    62    62
``````
• Eine einzelne ganze Zahl.A single integer. Sie können auswählen, ob Sie einen Integer zwischen 0 und einen maximalen Wert (Int32.MaxValue – 1) durch Aufrufen der Next() -Methode, eine ganze Zahl zwischen 0 und einen bestimmten Wert durch Aufrufen der Next(Int32) Methode oder eine ganze Zahl in einen Bereich von Werten durch Aufrufen der Next(Int32, Int32)Methode.You can choose whether you want an integer from 0 to a maximum value (Int32.MaxValue – 1) by calling the Next() method, an integer between 0 and a specific value by calling the Next(Int32) method, or an integer within a range of values by calling the Next(Int32, Int32) method. In parametrisierten Überladungen ist der angegebene Wert für die maximale exklusive; die aktuelle maximale Anzahl generiert, ist eine kleiner als der angegebene Wert.In the parameterized overloads, the specified maximum value is exclusive; that is, the actual maximum number generated is one less than the specified value.

Im folgenden Beispiel wird die Next(Int32, Int32) Methode, um 10 zufällige Zahlen zwischen-10 und 10 zu generieren.The following example calls the Next(Int32, Int32) method to generate 10 random numbers between -10 and 10. Beachten Sie, dass das zweite Argument für die Methode gibt an, die exklusive obere Grenze des Bereichs von zufälligen Werten, die von der Methode zurückgegeben.Note that the second argument to the method specifies the exclusive upper bound of the range of random values returned by the method. Das heißt, die größte ganze Zahl, die die Methode zurückgeben kann eine ist kleiner als dieser Wert.In other words, the largest integer that the method can return is one less than this value.

``````using namespace System;

void main()
{
Random^ rnd = gcnew Random();
for (int ctr = 0; ctr < 10; ctr++) {
Console::Write("{0,3}   ", rnd->Next(-10, 11));
}
}
// The example displays output like the following:
//    2     9    -3     2     4    -7    -3    -8    -8     5
``````
``````using System;

public class Example
{
public static void Main()
{
Random rnd = new Random();
for (int ctr = 0; ctr < 10; ctr++) {
Console.Write("{0,3}   ", rnd.Next(-10, 11));
}
}
}
// The example displays output like the following:
//    2     9    -3     2     4    -7    -3    -8    -8     5
``````
``````Module Example
Public Sub Main()
Dim rnd As New Random()
For ctr As Integer = 0 To 9
Console.Write("{0,3}   ", rnd.Next(-10, 11))
Next
End Sub
End Module
' The example displays output like the following:
'    2     9    -3     2     4    -7    -3    -8    -8     5
``````
• Ein einzelner Gleitkommawert Wert von 0,0 kleiner als 1,0 durch Aufrufen der NextDouble Methode.A single floating-point value from 0.0 to less than 1.0 by calling the NextDouble method. Die exklusive obere Grenze der Zufallszahl, die von der Methode zurückgegebenen ist 1, damit die tatsächliche Obergrenze 0.99999999999999978 ist.The exclusive upper bound of the random number returned by the method is 1, so its actual upper bound is 0.99999999999999978. Im folgende Beispiel wird 10 zufällige Gleitkommazahlen generiert.The following example generates 10 random floating-point numbers.

``````using namespace System;

void main()
{
Random^ rnd = gcnew Random();
for (int ctr = 0; ctr < 10; ctr++) {
Console::Write("{0,-19:R}   ", rnd->NextDouble());
if ((ctr + 1) % 3 == 0) Console::WriteLine();
}
}
// The example displays output like the following:
//    0.7911680553998649    0.0903414949264105    0.79776258291572455
//    0.615568345233597     0.652644504165577     0.84023809378977776
//    0.099662564741290441   0.91341467383942321  0.96018602045261581
//    0.74772306473354022
``````
``````using System;

public class Example
{
public static void Main()
{
Random rnd = new Random();
for (int ctr = 0; ctr < 10; ctr++) {
Console.Write("{0,-19:R}   ", rnd.NextDouble());
if ((ctr + 1) % 3 == 0) Console.WriteLine();
}
}
}
// The example displays output like the following:
//    0.7911680553998649    0.0903414949264105    0.79776258291572455
//    0.615568345233597     0.652644504165577     0.84023809378977776
//    0.099662564741290441   0.91341467383942321  0.96018602045261581
//    0.74772306473354022
``````
``````Module Example
Public Sub Main()
Dim rnd As New Random()
For ctr As Integer = 0 To 9
Console.Write("{0,-19:R}   ", rnd.NextDouble())
If (ctr + 1) Mod 3 = 0 Then Console.WriteLine()
Next
End Sub
End Module
' The example displays output like the following:
'    0.7911680553998649    0.0903414949264105    0.79776258291572455
'    0.615568345233597     0.652644504165577     0.84023809378977776
'    0.099662564741290441  0.91341467383942321   0.96018602045261581
'    0.74772306473354022
``````

Wichtig

Die Next(Int32, Int32) Methode können Sie den Bereich der zurückgegebenen Zufallszahl an.The Next(Int32, Int32) method allows you to specify the range of the returned random number. Allerdings die `maxValue` Parameter gibt an, der obere Bereich Anzahl zurückgegeben wird, wird eine exklusive, keiner inklusiven Wert.However, the `maxValue` parameter, which specifies the upper range returned number, is an exclusive, not an inclusive, value. Dies bedeutet, dass den Methodenaufruf `Next(0, 100)` gibt einen Wert zwischen 0 und 99 und nicht zwischen 0 und 100 zurück.This means that the method call `Next(0, 100)` returns a value between 0 and 99, and not between 0 and 100.

Können Sie auch die Random -Klasse für Aufgaben wie das Generieren von Zufallswerte t: System.Boolean, Generieren von zufällige Gleitkommazahl Werte mit einer Reihe außer 0 bis 1, Generieren von zufälligen 64-Bit-Ganzzahlen, und nach dem Zufallsprinzip ein eindeutiges Element aus einem Array oder einer Auflistung abrufen.You can also use the Random class for such tasks as generating random T:System.Boolean values, generating random floating point values with a range other than 0 to 1, generating random 64-bit integers, and randomly retrieving a unique element from an array or collection. Diese und andere häufige Aufgaben finden Sie in der wie verwenden Sie "System.Random", um...For these and other common tasks, see the How do you use System.Random to… Abschnitt.section.

### Ersetzen einen eigenen AlgorithmusSubstituting your own algorithm

Sie können Ihre eigenen Zufallszahlengenerator implementieren, durch Erben von der Random -Klasse und Ihre random Number-generierungsalgorithmus angeben.You can implement your own random number generator by inheriting from the Random class and supplying your random number generation algorithm. Um einen eigenen Algorithmus angeben, müssen Sie überschreiben die Sample Methode, die die random Number-generierungsalgorithmus implementiert.To supply your own algorithm, you must override the Sample method, which implements the random number generation algorithm. Sie sollten auch überschreiben, die Next(), Next(Int32, Int32), und NextBytes Methoden, um sicherzustellen, dass sie die überschriebene Aufrufen Sample Methode.You should also override the Next(), Next(Int32, Int32), and NextBytes methods to ensure that they call your overridden Sample method. Sie müssen keine außer Kraft setzen der Next(Int32) und NextDouble Methoden.You don't have to override the Next(Int32) and NextDouble methods.

Ein Beispiel für die abgeleitet der Random Klasse und ändert dessen Standardwert Zufallszahlengenerator, finden Sie unter den Sample Referenzseite.For an example that derives from the Random class and modifies its default pseudo-random number generator, see the Sample reference page.

### Wie verwenden Sie "System.Random", um...How do you use System.Random to…

In den folgenden Abschnitten erörtern und stellen entsprechenden Beispielcode für einige der Möglichkeiten, die Zufallszahlen in Ihrer app verwenden möchten.The following sections discuss and provide sample code for some of the ways you might want to use random numbers in your app.

#### Rufen Sie die gleiche Sequenz von zufälligen WertenRetrieve the same sequence of random values

Manchmal möchten Sie die gleiche Sequenz von Zufallszahlen zu generieren, in Testszenarien und Spiele zu spielen.Sometimes you want to generate the same sequence of random numbers in software test scenarios and in game playing. Mit derselben Sequenz von Zufallszahlen testen, können Sie Regressionen erkennen und Fehlerbehebungen zu bestätigen.Testing with the same sequence of random numbers allows you to detect regressions and confirm bug fixes. Verwenden die gleiche Sequenz von Zufallszahl bei Spielen, können Sie vorherigen Spiele wiedergeben.Using the same sequence of random number in games allows you to replay previous games.

Sie können die gleiche Sequenz von Zufallszahlen generieren, indem Sie den gleichen Ausgangswert zum Bereitstellen der Random(Int32) Konstruktor.You can generate the same sequence of random numbers by providing the same seed value to the Random(Int32) constructor. Der Ausgangswert enthält einen Startwert für das Pseudo-random Number-generierungsalgorithmus.The seed value provides a starting value for the pseudo-random number generation algorithm. Im folgenden Beispiel wird 100100 als einen beliebigen Startwert zum Instanziieren der Random zeigt 20 zufällige Gleitkommazahlen-Punktwerte-Objekt, und die Seed-Wert beibehalten.The following example uses 100100 as an arbitrary seed value to instantiate the Random object, displays 20 random floating-point values, and persists the seed value. Anschließend wird den Startwert, instanziiert einen neuen Zufallszahlen-Generator, und zeigt die gleichen 20 zufällige Gleitkommazahlen-Punktwerte.It then restores the seed value, instantiates a new random number generator, and displays the same 20 random floating-point values. Beachten Sie, dass im Beispiel verschiedene Sequenzen der Zufallszahlen erzeugen kann, wenn unterschiedliche Versionen von .NET Framework ausgeführt.Note that the example may produce different sequences of random numbers if run on different versions of the .NET Framework.

``````using namespace System;
using namespace System::IO;

ref class RandomMethods
{
internal:
static void ShowRandomNumbers(int seed)
{
Random^ rnd = gcnew Random(seed);
for (int ctr = 0; ctr <= 20; ctr++)
Console::WriteLine(rnd->NextDouble());
}

static void PersistSeed(int seed)
{
FileStream^ fs = gcnew FileStream(".\\seed.dat", FileMode::Create);
BinaryWriter^ bin = gcnew BinaryWriter(fs);
bin->Write(seed);
bin->Close();
}

static void DisplayNewRandomNumbers()
{
FileStream^ fs = gcnew FileStream(".\\seed.dat", FileMode::Open);
bin->Close();

Random^ rnd = gcnew Random(seed);
for (int ctr = 0; ctr <= 20; ctr++)
Console::WriteLine(rnd->NextDouble());
}
};

void main()
{
int seed = 100100;
RandomMethods::ShowRandomNumbers(seed);
Console::WriteLine();

RandomMethods::PersistSeed(seed);

RandomMethods::DisplayNewRandomNumbers();
}
// The example displays output like the following:
//       0.500193602172748
//       0.0209461245783354
//       0.465869495396442
//       0.195512794514891
//       0.928583675496552
//       0.729333720509584
//       0.381455668891527
//       0.0508996467343064
//       0.019261200921266
//       0.258578445417145
//       0.0177532266908107
//       0.983277184415272
//       0.483650274334313
//       0.0219647376900375
//       0.165910115077118
//       0.572085966622497
//       0.805291457942357
//       0.927985211335116
//       0.4228545699375
//       0.523320379910674
//       0.157783938645285
//
//       0.500193602172748
//       0.0209461245783354
//       0.465869495396442
//       0.195512794514891
//       0.928583675496552
//       0.729333720509584
//       0.381455668891527
//       0.0508996467343064
//       0.019261200921266
//       0.258578445417145
//       0.0177532266908107
//       0.983277184415272
//       0.483650274334313
//       0.0219647376900375
//       0.165910115077118
//       0.572085966622497
//       0.805291457942357
//       0.927985211335116
//       0.4228545699375
//       0.523320379910674
//       0.157783938645285
``````
``````using System;
using System.IO;

public class Example
{
public static void Main()
{
int seed = 100100;
ShowRandomNumbers(seed);
Console.WriteLine();

PersistSeed(seed);

DisplayNewRandomNumbers();
}

private static void ShowRandomNumbers(int seed)
{
Random rnd = new Random(seed);
for (int ctr = 0; ctr <= 20; ctr++)
Console.WriteLine(rnd.NextDouble());
}

private static void PersistSeed(int seed)
{
FileStream fs = new FileStream(@".\seed.dat", FileMode.Create);
BinaryWriter bin = new BinaryWriter(fs);
bin.Write(seed);
bin.Close();
}

private static void DisplayNewRandomNumbers()
{
FileStream fs = new FileStream(@".\seed.dat", FileMode.Open);
bin.Close();

Random rnd = new Random(seed);
for (int ctr = 0; ctr <= 20; ctr++)
Console.WriteLine(rnd.NextDouble());
}
}
// The example displays output like the following:
//       0.500193602172748
//       0.0209461245783354
//       0.465869495396442
//       0.195512794514891
//       0.928583675496552
//       0.729333720509584
//       0.381455668891527
//       0.0508996467343064
//       0.019261200921266
//       0.258578445417145
//       0.0177532266908107
//       0.983277184415272
//       0.483650274334313
//       0.0219647376900375
//       0.165910115077118
//       0.572085966622497
//       0.805291457942357
//       0.927985211335116
//       0.4228545699375
//       0.523320379910674
//       0.157783938645285
//
//       0.500193602172748
//       0.0209461245783354
//       0.465869495396442
//       0.195512794514891
//       0.928583675496552
//       0.729333720509584
//       0.381455668891527
//       0.0508996467343064
//       0.019261200921266
//       0.258578445417145
//       0.0177532266908107
//       0.983277184415272
//       0.483650274334313
//       0.0219647376900375
//       0.165910115077118
//       0.572085966622497
//       0.805291457942357
//       0.927985211335116
//       0.4228545699375
//       0.523320379910674
//       0.157783938645285
``````
``````Imports System.IO

Module Example
Public Sub Main()
Dim seed As Integer = 100100
ShowRandomNumbers(seed)
Console.WriteLine()

PersistSeed(seed)

DisplayNewRandomNumbers()
End Sub

Private Sub ShowRandomNumbers(seed As Integer)
Dim rnd As New Random(seed)
For ctr As Integer = 0 To 20
Console.WriteLine(rnd.NextDouble())
Next
End Sub

Private Sub PersistSeed(seed As Integer)
Dim fs As New FileStream(".\seed.dat", FileMode.Create)
Dim bin As New BinaryWriter(fs)
bin.Write(seed)
bin.Close()
End Sub

Private Sub DisplayNewRandomNumbers()
Dim fs As New FileStream(".\seed.dat", FileMode.Open)
Dim seed As Integer = bin.ReadInt32()
bin.Close()

Dim rnd As New Random(seed)
For ctr As Integer = 0 To 20
Console.WriteLine(rnd.NextDouble())
Next
End Sub
End Module
' The example displays output like the following:
'       0.500193602172748
'       0.0209461245783354
'       0.465869495396442
'       0.195512794514891
'       0.928583675496552
'       0.729333720509584
'       0.381455668891527
'       0.0508996467343064
'       0.019261200921266
'       0.258578445417145
'       0.0177532266908107
'       0.983277184415272
'       0.483650274334313
'       0.0219647376900375
'       0.165910115077118
'       0.572085966622497
'       0.805291457942357
'       0.927985211335116
'       0.4228545699375
'       0.523320379910674
'       0.157783938645285
'
'       0.500193602172748
'       0.0209461245783354
'       0.465869495396442
'       0.195512794514891
'       0.928583675496552
'       0.729333720509584
'       0.381455668891527
'       0.0508996467343064
'       0.019261200921266
'       0.258578445417145
'       0.0177532266908107
'       0.983277184415272
'       0.483650274334313
'       0.0219647376900375
'       0.165910115077118
'       0.572085966622497
'       0.805291457942357
'       0.927985211335116
'       0.4228545699375
'       0.523320379910674
'       0.157783938645285
``````

#### Abrufen von eindeutige Sequenzen von ZufallszahlenRetrieve unique sequences of random numbers

Bereitstellen von Werten der anderen Startwert auf Instanzen von der Random Klasse bewirkt, dass jede Zufallszahlengenerator, um eine andere Sequenz von Werten zu erzeugen.Providing different seed values to instances of the Random class causes each random number generator to produce a different sequence of values. Sie können einem Ausgangswert angeben, entweder explizit durch Aufrufen der Random(Int32) Konstruktor oder implizit durch Aufrufen der Random() Konstruktor.You can provide a seed value either explicitly by calling the Random(Int32) constructor, or implicitly by calling the Random() constructor. Die meisten Entwickler rufen Sie den parameterlosen Konstruktor, der die Systemuhr verwendet.Most developers call the parameterless constructor, which uses the system clock. Im folgenden Beispiel wird dieser Ansatz zum Instanziieren zweier Random Instanzen.The following example uses this approach to instantiate two Random instances. Jede Instanz wird eine Reihe von 10 zufällige ganze Zahlen angezeigt.Each instance displays a series of 10 random integers.

``````using namespace System;

void main()
{
Console::WriteLine("Instantiating two random number generators...");
Random^ rnd1 = gcnew Random();
Random^ rnd2 = gcnew Random();

Console::WriteLine("\nThe first random number generator:");
for (int ctr = 1; ctr <= 10; ctr++)
Console::WriteLine("   {0}", rnd1->Next());

Console::WriteLine("\nThe second random number generator:");
for (int ctr = 1; ctr <= 10; ctr++)
Console::WriteLine("   {0}", rnd2->Next());
}
// The example displays output like the following:
//       Instantiating two random number generators...
//
//       The first random number generator:
//          643164361
//          1606571630
//          1725607587
//          2138048432
//          496874898
//          1969147632
//          2034533749
//          1840964542
//          412380298
//          47518930
//
//       The second random number generator:
//          1251659083
//          1514185439
//          1465798544
//          517841554
//          1821920222
//          195154223
//          1538948391
//          1548375095
//          546062716
//          897797880
``````
``````using System;

public class Example
{
public static void Main()
{
Console.WriteLine("Instantiating two random number generators...");
Random rnd1 = new Random();
Random rnd2 = new Random();

Console.WriteLine("\nThe first random number generator:");
for (int ctr = 1; ctr <= 10; ctr++)
Console.WriteLine("   {0}", rnd1.Next());

Console.WriteLine("\nThe second random number generator:");
for (int ctr = 1; ctr <= 10; ctr++)
Console.WriteLine("   {0}", rnd2.Next());
}
}
// The example displays output like the following:
//       Instantiating two random number generators...
//
//       The first random number generator:
//          643164361
//          1606571630
//          1725607587
//          2138048432
//          496874898
//          1969147632
//          2034533749
//          1840964542
//          412380298
//          47518930
//
//       The second random number generator:
//          1251659083
//          1514185439
//          1465798544
//          517841554
//          1821920222
//          195154223
//          1538948391
//          1548375095
//          546062716
//          897797880
``````
``````Imports System.Threading

Module Example
Public Sub Main()
Console.WriteLine("Instantiating two random number generators...")
Dim rnd1 As New Random()
Dim rnd2 As New Random()
Console.WriteLine()

Console.WriteLine("The first random number generator:")
For ctr As Integer = 1 To 10
Console.WriteLine("   {0}", rnd1.Next())
Next
Console.WriteLine()

Console.WriteLine("The second random number generator:")
For ctr As Integer = 1 To 10
Console.WriteLine("   {0}", rnd2.Next())
Next
End Sub
End Module
' The example displays output like the following:
'       Instantiating two random number generators...
'
'       The first random number generator:
'          643164361
'          1606571630
'          1725607587
'          2138048432
'          496874898
'          1969147632
'          2034533749
'          1840964542
'          412380298
'          47518930
'
'       The second random number generator:
'          1251659083
'          1514185439
'          1465798544
'          517841554
'          1821920222
'          195154223
'          1538948391
'          1548375095
'          546062716
'          897797880
``````

Jedoch aufgrund der begrenzten Auflösung erkennt die Systemuhr Zeitunterschiede nicht, die weniger als etwa 15 Millisekunden.However, because of its finite resolution, the system clock doesn't detect time differences that are less than approximately 15 milliseconds. Aus diesem Grund Wenn Ihr Code Ruft die Random() -Überladung verwenden, um zwei instanziieren Random Objekte nacheinander Sie versehentlich geleistet werden die Objekte mit dem Startwerten identisch.Therefore, if your code calls the Random() overload to instantiate two Random objects in succession, you might inadvertently be providing the objects with identical seed values. Um dies im vorherigen Beispiel zu sehen, kommentieren Sie die Thread.Sleep -Methodenaufruf, und kompilieren und führen Sie das Beispiel erneut aus.To see this in the previous example, comment out the Thread.Sleep method call, and compile and run the example again.

Um dies zu verhindern, wird empfohlen, Sie ein einzelnes instanziieren Random -Objekt statt mehrere.To prevent this from happening, we recommend that you instantiate a single Random object rather than multiple ones. Da jedoch Random ist nicht threadsicher ist, müssen Sie einige Synchronisierung-Gerät verwenden, wenn Sie Zugriff auf eine Random -Instanz; Weitere Informationen von mehreren Threads verwenden, finden Sie unter der Random-Klasse und Threadsicherheit weiter oben in diesem In diesem Thema.However, since Random isn't thread safe, you must use some synchronization device if you access a Random instance from multiple threads; for more information, see The Random class and thread safety earlier in this topic. Alternativ können Sie können einen verzögerungsmechanismus, z. B. die Sleep Methode, die im vorherigen Beispiel verwendet, um sicherzustellen, dass die Instanziierungen, mehr als 15 Millisekunden voneinander entfernt auftreten.Alternately, you can use a delay mechanism, such as the Sleep method used in the previous example, to ensure that the instantiations occur more than 15 millisecond apart.

#### Abrufen von ganzen Zahlen in einem angegebenen BereichRetrieve integers in a specified range

Sie können die ganzen Zahlen in einem angegebenen Bereich abrufen, durch den Aufruf der Next(Int32, Int32) -Methode, die können Sie angeben, sowohl für die untere als auch für die obere Grenze der Zahlen den Zufallszahlengenerator zurückgegeben werden sollen.You can retrieve integers in a specified range by calling the Next(Int32, Int32) method, which lets you specify both the lower and the upper bound of the numbers you'd like the random number generator to return. Die Obergrenze ist eine exklusive, keiner inklusiven Wert.The upper bound is an exclusive, not an inclusive, value. Es ist, also nicht in den Bereich der Werte, die von der Methode zurückgegebenen enthalten.That is, it isn't included in the range of values returned by the method. Im folgenden Beispiel wird diese Methode zum Generieren von zufälliger Zahlen zwischen-10 und 10.The following example uses this method to generate random integers between -10 and 10. Beachten Sie, dass es 11 gibt, der eins größer ist als der Wert den gewünschten Wert von der `maxValue` Argument im Aufruf Methode.Note that it specifies 11, which is one greater than the desired value, as the value of the `maxValue` argument in the method call.

``````using namespace System;

void main()
{
Random^ rnd = gcnew Random();
for (int ctr = 1; ctr <= 15; ctr++) {
Console::Write("{0,3}    ", rnd->Next(-10, 11));
if(ctr % 5 == 0) Console::WriteLine();
}
}
// The example displays output like the following:
//        -2     -5     -1     -2     10
//        -3      6     -4     -8      3
//        -7     10      5     -2      4
``````
``````using System;

public class Example
{
public static void Main()
{
Random rnd = new Random();
for (int ctr = 1; ctr <= 15; ctr++) {
Console.Write("{0,3}    ", rnd.Next(-10, 11));
if(ctr % 5 == 0) Console.WriteLine();
}
}
}
// The example displays output like the following:
//        -2     -5     -1     -2     10
//        -3      6     -4     -8      3
//        -7     10      5     -2      4
``````
``````Module Example
Public Sub Main()
Dim rnd As New Random()
For ctr As Integer = 1 To 15
Console.Write("{0,3}    ", rnd.Next(-10, 11))
If ctr Mod 5 = 0 Then Console.WriteLine()
Next
End Sub
End Module
' The example displays output like the following:
'        -2     -5     -1     -2     10
'        -3      6     -4     -8      3
'        -7     10      5     -2      4
``````

#### Abrufen von ganzen Zahlen mit einer angegebenen Anzahl von ZiffernRetrieve integers with a specified number of digits

Rufen Sie die Next(Int32, Int32) Methode zum Abrufen von Zahlen mit einer angegebenen Anzahl von Ziffern.You can call the Next(Int32, Int32) method to retrieve numbers with a specified number of digits. Beispielsweise zum Abrufen von Zahlen mit vier Ziffern (d. h. Zahlen, die zwischen 1000 und 9999 liegen), rufen Sie die Next(Int32, Int32) -Methode mit einer `minValue` Wert 1000 und ein `maxValue` Wert 10.000, wie im folgenden Beispiel gezeigt.For example, to retrieve numbers with four digits (that is, numbers that range from 1000 to 9999), you call the Next(Int32, Int32) method with a `minValue` value of 1000 and a `maxValue` value of 10000, as the following example shows.

``````using namespace System;

void main()
{
Random^ rnd = gcnew Random();
for (int ctr = 1; ctr <= 50; ctr++) {
Console::Write("{0,3}   ", rnd->Next(1000, 10000));
if(ctr % 10 == 0) Console::WriteLine();
}
}
// The example displays output like the following:
//    9570    8979    5770    1606    3818    4735    8495    7196    7070    2313
//    5279    6577    5104    5734    4227    3373    7376    6007    8193    5540
//    7558    3934    3819    7392    1113    7191    6947    4963    9179    7907
//    3391    6667    7269    1838    7317    1981    5154    7377    3297    5320
//    9869    8694    2684    4949    2999    3019    2357    5211    9604    2593
``````
``````using System;

public class Example
{
public static void Main()
{
Random rnd = new Random();
for (int ctr = 1; ctr <= 50; ctr++) {
Console.Write("{0,3}    ", rnd.Next(1000, 10000));
if(ctr % 10 == 0) Console.WriteLine();
}
}
}
// The example displays output like the following:
//    9570    8979    5770    1606    3818    4735    8495    7196    7070    2313
//    5279    6577    5104    5734    4227    3373    7376    6007    8193    5540
//    7558    3934    3819    7392    1113    7191    6947    4963    9179    7907
//    3391    6667    7269    1838    7317    1981    5154    7377    3297    5320
//    9869    8694    2684    4949    2999    3019    2357    5211    9604    2593
``````
``````Module Example
Public Sub Main()
Dim rnd As New Random()
For ctr As Integer = 1 To 50
Console.Write("{0,3}    ", rnd.Next(1000, 10000))
If ctr Mod 10 = 0 Then Console.WriteLine()
Next
End Sub
End Module
' The example displays output like the following:
'    9570    8979    5770    1606    3818    4735    8495    7196    7070    2313
'    5279    6577    5104    5734    4227    3373    7376    6007    8193    5540
'    7558    3934    3819    7392    1113    7191    6947    4963    9179    7907
'    3391    6667    7269    1838    7317    1981    5154    7377    3297    5320
'    9869    8694    2684    4949    2999    3019    2357    5211    9604    2593
``````

#### Gleitkommawerte in einem angegebenen Bereich abrufenRetrieve floating-point values in a specified range

Die NextDouble Methodenrückgabe zufällige Gleitkommazahlen-Punktwerte diesen Bereich von 0 auf weniger als 1.The NextDouble method returns random floating-point values that range from 0 to less than 1. Sie sollten jedoch häufig zum Generieren von zufälliger Werten in einigen anderen Bereich zu können.However, you'll often want to generate random values in some other range.

Wenn das Intervall zwischen den minimalen und maximalen Werten für den gewünschten 1 ist, können Sie den Unterschied zwischen den gewünschten ab Abstand und 0 hinzufügen, um die Anzahl von zurückgegebenen der NextDouble Methode.If the interval between the minimum and maximum desired values is 1, you can add the difference between the desired starting interval and 0 to the number returned by the NextDouble method. Im folgende Beispiel wird um 10 Zufallszahlen zwischen-1 und 0.The following example does this to generate 10 random numbers between -1 and 0.

``````using namespace System;

void main()
{
Random^ rnd = gcnew Random();
for (int ctr = 1; ctr <= 10; ctr++)
Console::WriteLine(rnd->NextDouble() - 1);
}
// The example displays output like the following:
//       -0.930412760437658
//       -0.164699016215605
//       -0.9851692803135
//       -0.43468508843085
//       -0.177202483255976
//       -0.776813320245972
//       -0.0713201854710096
//       -0.0912875561468711
//       -0.540621722368813
//       -0.232211863730201
``````
``````using System;

public class Example
{
public static void Main()
{
Random rnd = new Random();
for (int ctr = 1; ctr <= 10; ctr++)
Console.WriteLine(rnd.NextDouble() - 1);
}
}
// The example displays output like the following:
//       -0.930412760437658
//       -0.164699016215605
//       -0.9851692803135
//       -0.43468508843085
//       -0.177202483255976
//       -0.776813320245972
//       -0.0713201854710096
//       -0.0912875561468711
//       -0.540621722368813
//       -0.232211863730201
``````
``````Module Example
Public Sub Main()
Dim rnd As New Random()
For ctr As Integer = 1 To 10
Console.WriteLine(rnd.NextDouble() - 1)
Next
End Sub
End Module
' The example displays output like the following:
'       -0.930412760437658
'       -0.164699016215605
'       -0.9851692803135
'       -0.43468508843085
'       -0.177202483255976
'       -0.776813320245972
'       -0.0713201854710096
'       -0.0912875561468711
'       -0.540621722368813
'       -0.232211863730201
``````

Um zufällige Gleitkommazahlen generiert wird, dessen untere Grenze 0 aber Obergrenze ist größer als 1 (oder, bei negativen Zahlen, dessen untere Grenze ist kleiner als-1 und obere Grenze ist 0), Multiplizieren Sie die Zufallszahl an, mit der Grenze ungleich NULL.To generate random floating-point numbers whose lower bound is 0 but upper bound is greater than 1 (or, in the case of negative numbers, whose lower bound is less than -1 and upper bound is 0), multiply the random number by the non-zero bound. Im folgende Beispiel wird diese Option, um 20 Millionen zufällige Gleitkommazahlen generiert dieses Bereichs von 0 bis Int64.MaxValue.The following example does this to generate 20 million random floating-point numbers that range from 0 to Int64.MaxValue. In zeigt außerdem die Verteilung der zufälligen Werte von der Methode generiert.In also displays the distribution of the random values generated by the method.

``````using namespace System;

void main()
{
const Int64 ONE_TENTH = 922337203685477581;
Random^ rnd = gcnew Random();
double number;
array<int>^ count = gcnew array<int>(10);

// Generate 20 million integer values between.
for (int ctr = 1; ctr <= 20000000; ctr++) {
number = rnd->NextDouble() * Int64::MaxValue;
// Categorize random numbers into 10 groups.
int value = (int) (number / ONE_TENTH);
count[value]++;
}

// Display breakdown by range.
Console::WriteLine("{0,28} {1,32}   {2,7}\n", "Range", "Count", "Pct.");
for (int ctr = 0; ctr <= 9; ctr++)
Console::WriteLine("{0,25:N0}-{1,25:N0}  {2,8:N0}   {3,7:P2}", ctr * ONE_TENTH,
ctr < 9 ? ctr * ONE_TENTH + ONE_TENTH - 1 : Int64::MaxValue,
count[ctr], count[ctr]/20000000.0);
}
// The example displays output like the following:
//                           Range                            Count      Pct.
//
//                            0-  922,337,203,685,477,580  1,996,148    9.98 %
//      922,337,203,685,477,581-1,844,674,407,370,955,161  2,000,293   10.00 %
//    1,844,674,407,370,955,162-2,767,011,611,056,432,742  2,000,094   10.00 %
//    2,767,011,611,056,432,743-3,689,348,814,741,910,323  2,000,159   10.00 %
//    3,689,348,814,741,910,324-4,611,686,018,427,387,904  1,999,552   10.00 %
//    4,611,686,018,427,387,905-5,534,023,222,112,865,485  1,998,248    9.99 %
//    5,534,023,222,112,865,486-6,456,360,425,798,343,066  2,000,696   10.00 %
//    6,456,360,425,798,343,067-7,378,697,629,483,820,647  2,001,637   10.01 %
//    7,378,697,629,483,820,648-8,301,034,833,169,298,228  2,002,870   10.01 %
//    8,301,034,833,169,298,229-9,223,372,036,854,775,807  2,000,303   10.00 %
``````
``````using System;

public class Example
{
public static void Main()
{
const long ONE_TENTH = 922337203685477581;

Random rnd = new Random();
double number;
int[] count = new int[10];

// Generate 20 million integer values between.
for (int ctr = 1; ctr <= 20000000; ctr++) {
number = rnd.NextDouble() * Int64.MaxValue;
// Categorize random numbers into 10 groups.
count[(int) (number / ONE_TENTH)]++;
}
// Display breakdown by range.
Console.WriteLine("{0,28} {1,32}   {2,7}\n", "Range", "Count", "Pct.");
for (int ctr = 0; ctr <= 9; ctr++)
Console.WriteLine("{0,25:N0}-{1,25:N0}  {2,8:N0}   {3,7:P2}", ctr * ONE_TENTH,
ctr < 9 ? ctr * ONE_TENTH + ONE_TENTH - 1 : Int64.MaxValue,
count[ctr], count[ctr]/20000000.0);
}
}
// The example displays output like the following:
//                           Range                            Count      Pct.
//
//                            0-  922,337,203,685,477,580  1,996,148    9.98 %
//      922,337,203,685,477,581-1,844,674,407,370,955,161  2,000,293   10.00 %
//    1,844,674,407,370,955,162-2,767,011,611,056,432,742  2,000,094   10.00 %
//    2,767,011,611,056,432,743-3,689,348,814,741,910,323  2,000,159   10.00 %
//    3,689,348,814,741,910,324-4,611,686,018,427,387,904  1,999,552   10.00 %
//    4,611,686,018,427,387,905-5,534,023,222,112,865,485  1,998,248    9.99 %
//    5,534,023,222,112,865,486-6,456,360,425,798,343,066  2,000,696   10.00 %
//    6,456,360,425,798,343,067-7,378,697,629,483,820,647  2,001,637   10.01 %
//    7,378,697,629,483,820,648-8,301,034,833,169,298,228  2,002,870   10.01 %
//    8,301,034,833,169,298,229-9,223,372,036,854,775,807  2,000,303   10.00 %
``````
``````Module Example
Public Sub Main()
Const ONE_TENTH As Long = 922337203685477581

Dim rnd As New Random()
Dim number As Long
Dim count(9) As Integer

' Generate 20 million integer values.
For ctr As Integer = 1 To 20000000
number = CLng(rnd.NextDouble() * Int64.MaxValue)
' Categorize random numbers.
count(CInt(number \ ONE_TENTH)) += 1
Next
' Display breakdown by range.
Console.WriteLine("{0,28} {1,32}   {2,7}", "Range", "Count", "Pct.")
Console.WriteLine()
For ctr As Integer = 0 To 9
Console.WriteLine("{0,25:N0}-{1,25:N0}  {2,8:N0}   {3,7:P2}", ctr * ONE_TENTH,
If(ctr < 9, ctr * ONE_TENTH + ONE_TENTH - 1, Int64.MaxValue),
count(ctr), count(ctr)/20000000)
Next
End Sub
End Module
' The example displays output like the following:
'                           Range                            Count      Pct.
'
'                            0-  922,337,203,685,477,580  1,996,148    9.98 %
'      922,337,203,685,477,581-1,844,674,407,370,955,161  2,000,293   10.00 %
'    1,844,674,407,370,955,162-2,767,011,611,056,432,742  2,000,094   10.00 %
'    2,767,011,611,056,432,743-3,689,348,814,741,910,323  2,000,159   10.00 %
'    3,689,348,814,741,910,324-4,611,686,018,427,387,904  1,999,552   10.00 %
'    4,611,686,018,427,387,905-5,534,023,222,112,865,485  1,998,248    9.99 %
'    5,534,023,222,112,865,486-6,456,360,425,798,343,066  2,000,696   10.00 %
'    6,456,360,425,798,343,067-7,378,697,629,483,820,647  2,001,637   10.01 %
'    7,378,697,629,483,820,648-8,301,034,833,169,298,228  2,002,870   10.01 %
'    8,301,034,833,169,298,229-9,223,372,036,854,775,807  2,000,303   10.00 %
``````

Um zufällige Gleitkommazahlen zwischen zwei beliebigen Werten zu generieren, wie die Next(Int32, Int32) Methode für ganze Zahlen ist, verwenden Sie die folgende Formel:To generate random floating-point numbers between two arbitrary values, like the Next(Int32, Int32) method does for integers, use the following formula:

``````Random.NextDouble() * (maxValue – minValue) + minValue
``````

Das folgende Beispiel generiert von 1 Mio. Zufallszahlen, die den Bereich aus 10.0 auf 11.0 und zeigt die Verteilung.The following example generates 1 million random numbers that range from 10.0 to 11.0, and displays their distribution.

``````using namespace System;

void main()
{
Random^ rnd = gcnew Random();
int lowerBound = 10;
int upperBound = 11;
array<int>^ range = gcnew array<int>(10);
for (int ctr = 1; ctr <= 1000000; ctr++) {
Double value = rnd->NextDouble() * (upperBound - lowerBound) + lowerBound;
range[(int) Math::Truncate((value - lowerBound) * 10)]++;
}

for (int ctr = 0; ctr <= 9; ctr++) {
Double lowerRange = 10 + ctr * .1;
Console::WriteLine("{0:N1} to {1:N1}: {2,8:N0}  ({3,7:P2})",
lowerRange, lowerRange + .1, range[ctr],
range[ctr] / 1000000.0);
}
}
// The example displays output like the following:
//       10.0 to 10.1:   99,929  ( 9.99 %)
//       10.1 to 10.2:  100,189  (10.02 %)
//       10.2 to 10.3:   99,384  ( 9.94 %)
//       10.3 to 10.4:  100,240  (10.02 %)
//       10.4 to 10.5:   99,397  ( 9.94 %)
//       10.5 to 10.6:  100,580  (10.06 %)
//       10.6 to 10.7:  100,293  (10.03 %)
//       10.7 to 10.8:  100,135  (10.01 %)
//       10.8 to 10.9:   99,905  ( 9.99 %)
//       10.9 to 11.0:   99,948  ( 9.99 %)
``````
``````using System;

public class Example
{
public static void Main()
{
Random rnd = new Random();
int lowerBound = 10;
int upperBound = 11;
int[] range = new int[10];
for (int ctr = 1; ctr <= 1000000; ctr++) {
Double value = rnd.NextDouble() * (upperBound - lowerBound) + lowerBound;
range[(int) Math.Truncate((value - lowerBound) * 10)]++;
}

for (int ctr = 0; ctr <= 9; ctr++) {
Double lowerRange = 10 + ctr * .1;
Console.WriteLine("{0:N1} to {1:N1}: {2,8:N0}  ({3,7:P2})",
lowerRange, lowerRange + .1, range[ctr],
range[ctr] / 1000000.0);
}
}
}
// The example displays output like the following:
//       10.0 to 10.1:   99,929  ( 9.99 %)
//       10.1 to 10.2:  100,189  (10.02 %)
//       10.2 to 10.3:   99,384  ( 9.94 %)
//       10.3 to 10.4:  100,240  (10.02 %)
//       10.4 to 10.5:   99,397  ( 9.94 %)
//       10.5 to 10.6:  100,580  (10.06 %)
//       10.6 to 10.7:  100,293  (10.03 %)
//       10.7 to 10.8:  100,135  (10.01 %)
//       10.8 to 10.9:   99,905  ( 9.99 %)
//       10.9 to 11.0:   99,948  ( 9.99 %)
``````
``````Module Example
Public Sub Main()
Dim rnd As New Random()
Dim lowerBound As Integer = 10
Dim upperBound As Integer = 11
Dim range(9) As Integer
For ctr As Integer = 1 To 1000000
Dim value As Double = rnd.NextDouble() * (upperBound - lowerBound) + lowerBound
range(CInt(Math.Truncate((value - lowerBound) * 10))) += 1
Next

For ctr As Integer = 0 To 9
Dim lowerRange As Double = 10 + ctr * .1
Console.WriteLine("{0:N1} to {1:N1}: {2,8:N0}  ({3,7:P2})",
lowerRange, lowerRange + .1, range(ctr),
range(ctr) / 1000000.0)
Next
End Sub
End Module
' The example displays output like the following:
'       10.0 to 10.1:   99,929  ( 9.99 %)
'       10.1 to 10.2:  100,189  (10.02 %)
'       10.2 to 10.3:   99,384  ( 9.94 %)
'       10.3 to 10.4:  100,240  (10.02 %)
'       10.4 to 10.5:   99,397  ( 9.94 %)
'       10.5 to 10.6:  100,580  (10.06 %)
'       10.6 to 10.7:  100,293  (10.03 %)
'       10.7 to 10.8:  100,135  (10.01 %)
'       10.8 to 10.9:   99,905  ( 9.99 %)
'       10.9 to 11.0:   99,948  ( 9.99 %)
``````

#### Generieren von zufälligen boolesche WerteGenerate random Boolean values

Die Random Klasse nicht die Methoden zur Erstellung bereitstellen Boolean Werte.The Random class doesn't provide methods that generate Boolean values. Allerdings können Sie Ihre eigenen Klasse oder Methode dafür definieren.However, you can define your own class or method to do that. Das folgende Beispiel definiert eine Klasse, `BooleanGenerator`, mit einer einzelnen Methode, `NextBoolean`.The following example defines a class, `BooleanGenerator`, with a single method, `NextBoolean`. Die `BooleanGenerator` -Klasse speichert ein Random -Objekt als eine private Variable.The `BooleanGenerator` class stores a Random object as a private variable. Die `NextBoolean` Methodenaufrufe der Random.Next(Int32, Int32) Methode und übergibt das Ergebnis an die Convert.ToBoolean(Int32) Methode.The `NextBoolean` method calls the Random.Next(Int32, Int32) method and passes the result to the Convert.ToBoolean(Int32) method. Beachten Sie, dass 2 als Argument an die obere Grenze der Zufallszahl verwendet wird.Note that 2 is used as the argument to specify the upper bound of the random number. Da dies ein ausgeschlossener Wert ist, gibt der Aufruf der Methode zurück, 0 oder 1.Since this is an exclusive value, the method call returns either 0 or 1.

``````using namespace System;

public ref class BooleanGenerator
{
private:
Random^ rnd;

public:
BooleanGenerator()
{
rnd = gcnew Random();
}

bool NextBoolean()
{
return Convert::ToBoolean(rnd->Next(0, 2));
}
};

void main()
{
// Instantiate the Boolean generator.
BooleanGenerator^ boolGen = gcnew BooleanGenerator();
int totalTrue = 0, totalFalse = 0;

// Generate 1,0000 random Booleans, and keep a running total.
for (int ctr = 0; ctr < 1000000; ctr++) {
bool value = boolGen->NextBoolean();
if (value)
totalTrue++;
else
totalFalse++;
}
Console::WriteLine("Number of true values:  {0,7:N0} ({1:P3})",
totalTrue,
((double) totalTrue)/(totalTrue + totalFalse));
Console::WriteLine("Number of false values: {0,7:N0} ({1:P3})",
totalFalse,
((double) totalFalse)/(totalTrue + totalFalse));
}

// The example displays output like the following:
//       Number of true values:  500,004 (50.000 %)
//       Number of false values: 499,996 (50.000 %)
``````
``````using System;

public class Example
{
public static void Main()
{
// Instantiate the Boolean generator.
BooleanGenerator boolGen = new BooleanGenerator();
int totalTrue = 0, totalFalse = 0;

// Generate 1,0000 random Booleans, and keep a running total.
for (int ctr = 0; ctr < 1000000; ctr++) {
bool value = boolGen.NextBoolean();
if (value)
totalTrue++;
else
totalFalse++;
}
Console.WriteLine("Number of true values:  {0,7:N0} ({1:P3})",
totalTrue,
((double) totalTrue)/(totalTrue + totalFalse));
Console.WriteLine("Number of false values: {0,7:N0} ({1:P3})",
totalFalse,
((double) totalFalse)/(totalTrue + totalFalse));
}
}

public class BooleanGenerator
{
Random rnd;

public BooleanGenerator()
{
rnd = new Random();
}

public bool NextBoolean()
{
return Convert.ToBoolean(rnd.Next(0, 2));
}
}
// The example displays output like the following:
//       Number of true values:  500,004 (50.000 %)
//       Number of false values: 499,996 (50.000 %)
``````
``````Module Example
Public Sub Main()
' Instantiate the Boolean generator.
Dim boolGen As New BooleanGenerator()
Dim totalTrue, totalFalse As Integer

' Generate 1,0000 random Booleans, and keep a running total.
For ctr As Integer = 0 To 9999999
Dim value As Boolean = boolGen.NextBoolean()
If value Then
totalTrue += 1
Else
totalFalse += 1
End If
Next
Console.WriteLine("Number of true values:  {0,7:N0} ({1:P3})",
totalTrue,
totalTrue/(totalTrue + totalFalse))
Console.WriteLine("Number of false values: {0,7:N0} ({1:P3})",
totalFalse,
totalFalse/(totalTrue + totalFalse))
End Sub
End Module

Public Class BooleanGenerator
Dim rnd As Random

Public Sub New()
rnd = New Random()
End Sub

Public Function NextBoolean() As Boolean
Return Convert.ToBoolean(rnd.Next(0, 2))
End Function
End Class
' The example displays the following output:
'       Number of true values:  500,004 (50.000 %)
'       Number of false values: 499,996 (50.000 %)
``````

Statt eine separate Klasse für das Generieren von zufälligen Boolean Werte im Beispiel können einfach eine einzelne Methode definiert haben.Instead of creating a separate class to generate random Boolean values, the example could simply have defined a single method. In diesem Fall jedoch die Random Objekt sollte als eine Variable auf Klassenebene, um zu vermeiden, Instanziierung eines neuen definiert wurden Random -Instanz in jedem Methodenaufruf.In that case, however, the Random object should have been defined as a class-level variable to avoid instantiating a new Random instance in each method call. In Visual Basic die Random-Instanz definiert werden kann, als eine statische -Variable in der `NextBoolean` Methode.In Visual Basic, the Random instance can be defined as a Static variable in the `NextBoolean` method. Im folgende Beispiel stellt eine Implementierung bereit.The following example provides an implementation.

``````using namespace System;

ref class Example
{
private:
static Random^ rnd = gcnew Random();

public:
static void Execute()
{
int totalTrue = 0, totalFalse = 0;

// Generate 1,0000 random Booleans, and keep a running total.
for (int ctr = 0; ctr < 1000000; ctr++) {
bool value = NextBoolean();
if (value)
totalTrue++;
else
totalFalse++;
}
Console::WriteLine("Number of true values:  {0,7:N0} ({1:P3})",
totalTrue,
((double) totalTrue)/(totalTrue + totalFalse));
Console::WriteLine("Number of false values: {0,7:N0} ({1:P3})",
totalFalse,
((double) totalFalse)/(totalTrue + totalFalse));
}

static bool NextBoolean()
{
return Convert::ToBoolean(rnd->Next(0, 2));
}
};

void main()
{
Example::Execute();
}
// The example displays output like the following:
//       Number of true values:  499,777 (49.978 %)
//       Number of false values: 500,223 (50.022 %)
``````
``````using System;

public class Example
{
private static Random rnd = new Random();

public static void Main()
{
int totalTrue = 0, totalFalse = 0;

// Generate 1,0000 random Booleans, and keep a running total.
for (int ctr = 0; ctr < 1000000; ctr++) {
bool value = NextBoolean();
if (value)
totalTrue++;
else
totalFalse++;
}
Console.WriteLine("Number of true values:  {0,7:N0} ({1:P3})",
totalTrue,
((double) totalTrue)/(totalTrue + totalFalse));
Console.WriteLine("Number of false values: {0,7:N0} ({1:P3})",
totalFalse,
((double) totalFalse)/(totalTrue + totalFalse));
}

public static bool NextBoolean()
{
return Convert.ToBoolean(rnd.Next(0, 2));
}
}
// The example displays output like the following:
//       Number of true values:  499,777 (49.978 %)
//       Number of false values: 500,223 (50.022 %)
``````
``````Module Example
Public Sub Main()
Dim totalTrue, totalFalse As Integer

' Generate 1,0000 random Booleans, and keep a running total.
For ctr As Integer = 0 To 9999999
Dim value As Boolean = NextBoolean()
If value Then
totalTrue += 1
Else
totalFalse += 1
End If
Next
Console.WriteLine("Number of true values:  {0,7:N0} ({1:P3})",
totalTrue,
totalTrue/(totalTrue + totalFalse))
Console.WriteLine("Number of false values: {0,7:N0} ({1:P3})",
totalFalse,
totalFalse/(totalTrue + totalFalse))
End Sub

Public Function NextBoolean() As Boolean
Static rnd As New Random()
Return Convert.ToBoolean(rnd.Next(0, 2))
End Function
End Module
' The example displays the following output:
'       Number of true values:  499,777 (49.978 %)
'       Number of false values: 500,223 (50.022 %)
``````

#### Generieren von zufälligen 64-Bit-GanzzahlenGenerate random 64-bit integers

Die Überladungen der Next Methodenrückgabewert 32-Bit-Ganzzahlen.The overloads of the Next method return 32-bit integers. In einigen Fällen möchten jedoch möglicherweise arbeiten mit der 64-Bit-Ganzzahlen.However, in some cases, you might want to work with 64-bit integers. Sie können dies wie folgt tun:You can do this as follows:

1. Rufen Sie die NextDouble Datenpunkt Methode zum Abrufen der Gleitkommazahl mit doppelter Genauigkeit.Call the NextDouble method to retrieve a double-precision floating point value.

2. Multiplizieren Sie diesen Wert durch Int64.MaxValue.Multiply that value by Int64.MaxValue.

Im folgende Beispiel verwendet dieses Verfahren zum Generieren von 20 Millionen zufälliger ganzer lange Zahlen und stuft sie in 10 gleich große Gruppen.The following example uses this technique to generate 20 million random long integers and categorizes them in 10 equal groups. Er wertet dann die Verteilung der zufälligen Zahlen durch zählen der Anzahl in jeder Gruppe von 0 bis Int64.MaxValue.It then evaluates the distribution of the random numbers by counting the number in each group from 0 to Int64.MaxValue. Wie die Ausgabe des Beispiels zeigt, werden die Zahlen über den Bereich einer langen ganzen Zahl mehr oder weniger gleichmäßig verteilt.As the output from the example shows, the numbers are distributed more or less equally through the range of a long integer.

``````using namespace System;

void main()
{
const Int64 ONE_TENTH = 922337203685477581;

Random^ rnd = gcnew Random();
Int64 number;
array<int>^ count = gcnew array<int>(10);

// Generate 20 million long integers.
for (int ctr = 1; ctr <= 20000000; ctr++) {
number = (Int64) (rnd->NextDouble() * Int64::MaxValue);
// Categorize random numbers.
count[(int) (number / ONE_TENTH)]++;
}
// Display breakdown by range.
Console::WriteLine("{0,28} {1,32}   {2,7}\n", "Range", "Count", "Pct.");
for (int ctr = 0; ctr <= 9; ctr++)
Console::WriteLine("{0,25:N0}-{1,25:N0}  {2,8:N0}   {3,7:P2}", ctr * ONE_TENTH,
ctr < 9 ? ctr * ONE_TENTH + ONE_TENTH - 1 : Int64::MaxValue,
count[ctr], count[ctr]/20000000.0);
}
// The example displays output like the following:
//                           Range                            Count      Pct.
//
//                            0-  922,337,203,685,477,580  1,996,148    9.98 %
//      922,337,203,685,477,581-1,844,674,407,370,955,161  2,000,293   10.00 %
//    1,844,674,407,370,955,162-2,767,011,611,056,432,742  2,000,094   10.00 %
//    2,767,011,611,056,432,743-3,689,348,814,741,910,323  2,000,159   10.00 %
//    3,689,348,814,741,910,324-4,611,686,018,427,387,904  1,999,552   10.00 %
//    4,611,686,018,427,387,905-5,534,023,222,112,865,485  1,998,248    9.99 %
//    5,534,023,222,112,865,486-6,456,360,425,798,343,066  2,000,696   10.00 %
//    6,456,360,425,798,343,067-7,378,697,629,483,820,647  2,001,637   10.01 %
//    7,378,697,629,483,820,648-8,301,034,833,169,298,228  2,002,870   10.01 %
//    8,301,034,833,169,298,229-9,223,372,036,854,775,807  2,000,303   10.00 %
``````
``````using System;

public class Example
{
public static void Main()
{
const long ONE_TENTH = 922337203685477581;

Random rnd = new Random();
long number;
int[] count = new int[10];

// Generate 20 million long integers.
for (int ctr = 1; ctr <= 20000000; ctr++) {
number = (long) (rnd.NextDouble() * Int64.MaxValue);
// Categorize random numbers.
count[(int) (number / ONE_TENTH)]++;
}
// Display breakdown by range.
Console.WriteLine("{0,28} {1,32}   {2,7}\n", "Range", "Count", "Pct.");
for (int ctr = 0; ctr <= 9; ctr++)
Console.WriteLine("{0,25:N0}-{1,25:N0}  {2,8:N0}   {3,7:P2}", ctr * ONE_TENTH,
ctr < 9 ? ctr * ONE_TENTH + ONE_TENTH - 1 : Int64.MaxValue,
count[ctr], count[ctr]/20000000.0);
}
}
// The example displays output like the following:
//                           Range                            Count      Pct.
//
//                            0-  922,337,203,685,477,580  1,996,148    9.98 %
//      922,337,203,685,477,581-1,844,674,407,370,955,161  2,000,293   10.00 %
//    1,844,674,407,370,955,162-2,767,011,611,056,432,742  2,000,094   10.00 %
//    2,767,011,611,056,432,743-3,689,348,814,741,910,323  2,000,159   10.00 %
//    3,689,348,814,741,910,324-4,611,686,018,427,387,904  1,999,552   10.00 %
//    4,611,686,018,427,387,905-5,534,023,222,112,865,485  1,998,248    9.99 %
//    5,534,023,222,112,865,486-6,456,360,425,798,343,066  2,000,696   10.00 %
//    6,456,360,425,798,343,067-7,378,697,629,483,820,647  2,001,637   10.01 %
//    7,378,697,629,483,820,648-8,301,034,833,169,298,228  2,002,870   10.01 %
//    8,301,034,833,169,298,229-9,223,372,036,854,775,807  2,000,303   10.00 %
``````
``````Module Example
Public Sub Main()
Const ONE_TENTH As Long = 922337203685477581

Dim rnd As New Random()
Dim number As Long
Dim count(9) As Integer

' Generate 20 million long integers.
For ctr As Integer = 1 To 20000000
number = CLng(rnd.NextDouble() * Int64.MaxValue)
' Categorize random numbers.
count(CInt(number \ ONE_TENTH)) += 1
Next
' Display breakdown by range.
Console.WriteLine("{0,28} {1,32}   {2,7}", "Range", "Count", "Pct.")
Console.WriteLine()
For ctr As Integer = 0 To 9
Console.WriteLine("{0,25:N0}-{1,25:N0}  {2,8:N0}   {3,7:P2}", ctr * ONE_TENTH,
If(ctr < 9, ctr * ONE_TENTH + ONE_TENTH - 1, Int64.MaxValue),
count(ctr), count(ctr)/20000000)
Next
End Sub
End Module
' The example displays output like the following:
'                           Range                            Count      Pct.
'
'                            0-  922,337,203,685,477,580  1,996,148    9.98 %
'      922,337,203,685,477,581-1,844,674,407,370,955,161  2,000,293   10.00 %
'    1,844,674,407,370,955,162-2,767,011,611,056,432,742  2,000,094   10.00 %
'    2,767,011,611,056,432,743-3,689,348,814,741,910,323  2,000,159   10.00 %
'    3,689,348,814,741,910,324-4,611,686,018,427,387,904  1,999,552   10.00 %
'    4,611,686,018,427,387,905-5,534,023,222,112,865,485  1,998,248    9.99 %
'    5,534,023,222,112,865,486-6,456,360,425,798,343,066  2,000,696   10.00 %
'    6,456,360,425,798,343,067-7,378,697,629,483,820,647  2,001,637   10.01 %
'    7,378,697,629,483,820,648-8,301,034,833,169,298,228  2,002,870   10.01 %
'    8,301,034,833,169,298,229-9,223,372,036,854,775,807  2,000,303   10.00 %
``````

Alternatives Verfahren, dass Bitmanipulation verwendet keine echten Zufallszahlen generiert.An alternative technique that uses bit manipulation does not generate truly random numbers. Diese Methode ruft Next() zum Generieren von zwei ganzen Zahlen, links verschiebt eine von 32 Bits und OR werden zusammen.This technique calls Next() to generate two integers, left-shifts one by 32 bits, and ORs them together. Diese Technik bietet zwei Einschränkungen:This technique has two limitations:

1. Da Bit 31 das signierte Bit ist, ist der Wert in 31 Bit, das sich ergebende langen ganzen Zahl immer 0.Because bit 31 is the sign bit, the value in bit 31 of the resulting long integer is always 0. Dies kann behoben werden, durch Generieren einer zufälligen 0 oder 1, es links-Verschiebung, 31 Bits und oder-Verknüpfung mit der ursprünglichen zufällige lange ganze Zahl.This can be addressed by generating a random 0 or 1, left-shifting it 31 bits, and ORing it with the original random long integer.

2. Doch Spaß beiseite, da die Wahrscheinlichkeit, die den Rückgabewert von Next() 0, wird ggf. einige zufällig gewählte Zahlen im Bereich von 0 x 0 – 0x00000000FFFFFFFF.More seriously, because the probability that the value returned by Next() will be 0, there will be few if any random numbers in the range 0x0-0x00000000FFFFFFFF.

#### Abrufen der Bytes in einem angegebenen BereichRetrieve bytes in a specified range

Die Überladungen von der Next Methode ermöglichen Ihnen die Angabe des Bereichs von Zufallszahlen, aber die NextBytes Methode nicht.The overloads of the Next method allow you to specify the range of random numbers, but the NextBytes method does not. Das folgende Beispiel implementiert eine `NextBytes` -Methode, die Sie den Bereich der zurückgegebenen Bytes angeben kann.The following example implements a `NextBytes` method that lets you specify the range of the returned bytes. Definiert eine `Random2` abgeleitete Klasse Random und überlädt die `NextBytes` Methode.It defines a `Random2` class that derives from Random and overloads its `NextBytes` method.

``````using namespace System;

ref class Random2 : Random
{
public:
Random2()
{}

Random2(int seed) : Random(seed)
{}

void NextBytes(array<Byte>^ bytes, Byte minValue, Byte maxValue)
{
for (int ctr = bytes->GetLowerBound(0); ctr <= bytes->GetUpperBound(0); ctr++)
bytes[ctr] = (Byte) Next(minValue, maxValue);
}
};

void main()
{
Random2^ rnd = gcnew Random2();
array<Byte>^ bytes = gcnew array<Byte>(10000);
array<int>^ total = gcnew array<int>(101);
rnd->NextBytes(bytes, 0, 101);

// Calculate how many of each value we have.
for each (Byte value in bytes)
total[value]++;

// Display the results.
for (int ctr = 0; ctr < total->Length; ctr++) {
Console::Write("{0,3}: {1,-3}   ", ctr, total[ctr]);
if ((ctr + 1) % 5 == 0) Console::WriteLine();
}
}
// The example displays output like the following:
//         0: 115     1: 119     2: 92      3: 98      4: 92
//         5: 102     6: 103     7: 84      8: 93      9: 116
//        10: 91     11: 98     12: 106    13: 91     14: 92
//        15: 101    16: 100    17: 96     18: 97     19: 100
//        20: 101    21: 106    22: 112    23: 82     24: 85
//        25: 102    26: 107    27: 98     28: 106    29: 102
//        30: 109    31: 108    32: 94     33: 101    34: 107
//        35: 101    36: 86     37: 100    38: 101    39: 102
//        40: 113    41: 95     42: 96     43: 89     44: 99
//        45: 81     46: 89     47: 105    48: 100    49: 85
//        50: 103    51: 103    52: 93     53: 89     54: 91
//        55: 97     56: 105    57: 97     58: 110    59: 86
//        60: 116    61: 94     62: 117    63: 98     64: 110
//        65: 93     66: 102    67: 100    68: 105    69: 83
//        70: 81     71: 97     72: 85     73: 70     74: 98
//        75: 100    76: 110    77: 114    78: 83     79: 90
//        80: 96     81: 112    82: 102    83: 102    84: 99
//        85: 81     86: 100    87: 93     88: 99     89: 118
//        90: 95     91: 124    92: 108    93: 96     94: 104
//        95: 106    96: 99     97: 99     98: 92     99: 99
//       100: 108
``````
``````using System;

public class Example
{
public static void Main()
{
Random2 rnd = new Random2();
Byte[] bytes = new Byte[10000];
int[] total = new int[101];
rnd.NextBytes(bytes, 0, 101);

// Calculate how many of each value we have.
foreach (var value in bytes)
total[value]++;

// Display the results.
for (int ctr = 0; ctr < total.Length; ctr++) {
Console.Write("{0,3}: {1,-3}   ", ctr, total[ctr]);
if ((ctr + 1) % 5 == 0) Console.WriteLine();
}
}
}

public class Random2 : Random
{
public Random2() : base()
{}

public Random2(int seed) : base(seed)
{}

public void NextBytes(byte[] bytes, byte minValue, byte maxValue)
{
for (int ctr = bytes.GetLowerBound(0); ctr <= bytes.GetUpperBound(0); ctr++)
bytes[ctr] = (byte) Next(minValue, maxValue);
}
}
// The example displays output like the following:
//         0: 115     1: 119     2: 92      3: 98      4: 92
//         5: 102     6: 103     7: 84      8: 93      9: 116
//        10: 91     11: 98     12: 106    13: 91     14: 92
//        15: 101    16: 100    17: 96     18: 97     19: 100
//        20: 101    21: 106    22: 112    23: 82     24: 85
//        25: 102    26: 107    27: 98     28: 106    29: 102
//        30: 109    31: 108    32: 94     33: 101    34: 107
//        35: 101    36: 86     37: 100    38: 101    39: 102
//        40: 113    41: 95     42: 96     43: 89     44: 99
//        45: 81     46: 89     47: 105    48: 100    49: 85
//        50: 103    51: 103    52: 93     53: 89     54: 91
//        55: 97     56: 105    57: 97     58: 110    59: 86
//        60: 116    61: 94     62: 117    63: 98     64: 110
//        65: 93     66: 102    67: 100    68: 105    69: 83
//        70: 81     71: 97     72: 85     73: 70     74: 98
//        75: 100    76: 110    77: 114    78: 83     79: 90
//        80: 96     81: 112    82: 102    83: 102    84: 99
//        85: 81     86: 100    87: 93     88: 99     89: 118
//        90: 95     91: 124    92: 108    93: 96     94: 104
//        95: 106    96: 99     97: 99     98: 92     99: 99
//       100: 108
``````
``````Module Example
Public Sub Main()
Dim rnd As New Random2()
Dim bytes(9999) As Byte
Dim total(100) As Integer
rnd.NextBytes(bytes, 0, 101)

' Calculate how many of each value we have.
For Each value In bytes
total(value) += 1
Next

' Display the results.
For ctr As Integer = 0 To total.Length - 1
Console.Write("{0,3}: {1,-3}   ", ctr, total(ctr))
If (ctr + 1) Mod 5 = 0 Then Console.WriteLine()
Next
End Sub
End Module

Public Class Random2 : Inherits Random
Public Sub New()
MyBase.New()
End Sub

Public Sub New(seed As Integer)
MyBase.New(seed)
End Sub

Public Overloads Sub NextBytes(bytes() As Byte,
minValue As Byte, maxValue As Byte)
For ctr As Integer = bytes.GetLowerbound(0) To bytes.GetUpperBound(0)
bytes(ctr) = CByte(MyBase.Next(minValue, maxValue))
Next
End Sub
End Class
' The example displays output like the following:
'         0: 115     1: 119     2: 92      3: 98      4: 92
'         5: 102     6: 103     7: 84      8: 93      9: 116
'        10: 91     11: 98     12: 106    13: 91     14: 92
'        15: 101    16: 100    17: 96     18: 97     19: 100
'        20: 101    21: 106    22: 112    23: 82     24: 85
'        25: 102    26: 107    27: 98     28: 106    29: 102
'        30: 109    31: 108    32: 94     33: 101    34: 107
'        35: 101    36: 86     37: 100    38: 101    39: 102
'        40: 113    41: 95     42: 96     43: 89     44: 99
'        45: 81     46: 89     47: 105    48: 100    49: 85
'        50: 103    51: 103    52: 93     53: 89     54: 91
'        55: 97     56: 105    57: 97     58: 110    59: 86
'        60: 116    61: 94     62: 117    63: 98     64: 110
'        65: 93     66: 102    67: 100    68: 105    69: 83
'        70: 81     71: 97     72: 85     73: 70     74: 98
'        75: 100    76: 110    77: 114    78: 83     79: 90
'        80: 96     81: 112    82: 102    83: 102    84: 99
'        85: 81     86: 100    87: 93     88: 99     89: 118
'        90: 95     91: 124    92: 108    93: 96     94: 104
'        95: 106    96: 99     97: 99     98: 92     99: 99
'       100: 108
``````

Die `NextBytes(Byte[], Byte, Byte)` Methode umschließt einen Aufruf der Next(Int32, Int32) Methode und gibt den minimalen Wert und eine, die größer als der maximale Wert (in diesem Fall 0 und 101), dass wir in das Bytearray zurückgegeben werden sollen.The `NextBytes(Byte[], Byte, Byte)` method wraps a call to the Next(Int32, Int32) method and specifies the minimum value and one greater than the maximum value (in this case, 0 and 101) that we want returned in the byte array. Da wir Sie sicher sind, dass die ganzzahligen Werte von zurückgegeben. die Next Methode werden innerhalb des Bereichs von der Byte -Datentyp, wir können sicher umgewandelt werden (in c#) oder konvertieren Sie sie (in Visual Basic) von ganzen Zahlen, in Byte.Because we are sure that the integer values returned by the Next method are within the range of the Byte data type, we can safely cast them (in C#) or convert them (in Visual Basic) from integers to bytes.

#### Ein Element nach dem Zufallsprinzip aus einem Array oder einer Auflistung abrufenRetrieve an element from an array or collection at random

Zufallszahlen dienen häufig als Indizes, um Werte aus Arrays oder Auflistungen abzurufen.Random numbers often serve as indexes to retrieve values from arrays or collections. Um einen zufälligen Indexwert abzurufen, können Sie Aufrufen der Next(Int32, Int32) -Methode, und verwenden Sie die untere Grenze des Arrays als Wert für die `minValue` Argument und eins größer ist als die obere Grenze des Arrays als Wert für die `maxValue` Argument.To retrieve a random index value, you can call the Next(Int32, Int32) method, and use the lower bound of the array as the value of its `minValue` argument and one greater than the upper bound of the array as the value of its `maxValue` argument. Für ein nullbasiertes Array, dies entspricht der Length Eigenschaft oder eins größer ist als der Rückgabewert von der Array.GetUpperBound Methode.For a zero-based array, this is equivalent to its Length property, or one greater than the value returned by the Array.GetUpperBound method. Im folgende Beispiel ruft den Namen einer Stadt in den Vereinigten Staaten nach dem Zufallsprinzip aus einem Array aus Städten ab.The following example randomly retrieves the name of a city in the United States from an array of cities.

``````using namespace System;

void main()
{
array<String^>^ cities = { "Atlanta", "Boston", "Chicago", "Detroit",
"Fort Wayne", "Greensboro", "Honolulu", "Indianapolis",
"Jersey City", "Kansas City", "Los Angeles",
"Raleigh", "San Francisco", "Tulsa", "Washington" };
Random^ rnd = gcnew Random();
int index = rnd->Next(0, cities->Length);
Console::WriteLine("Today's city of the day: {0}",
cities[index]);
}
// The example displays output like the following:
//   Today's city of the day: Honolulu
``````
``````using System;

public class Example
{
public static void Main()
{
String[] cities = { "Atlanta", "Boston", "Chicago", "Detroit",
"Fort Wayne", "Greensboro", "Honolulu", "Indianapolis",
"Jersey City", "Kansas City", "Los Angeles",
"Raleigh", "San Francisco", "Tulsa", "Washington" };
Random rnd = new Random();
int index = rnd.Next(0, cities.Length);
Console.WriteLine("Today's city of the day: {0}",
cities[index]);
}
}
// The example displays output like the following:
//   Today's city of the day: Honolulu
``````
``````Module Example
Public Sub Main()
Dim cities() As String = { "Atlanta", "Boston", "Chicago", "Detroit",
"Fort Wayne", "Greensboro", "Honolulu", "Indianapolis",
"Jersey City", "Kansas City", "Los Angeles",
"Raleigh", "San Francisco", "Tulsa", "Washington" }
Dim rnd As New Random()
Dim index As Integer = rnd.Next(0, cities.Length)
Console.WriteLine("Today's city of the day: {0}",
cities(index))
End Sub
End Module
' The example displays output like the following:
'   Today's city of the day: Honolulu
``````

#### Ein eindeutiges Element aus einem Array oder einer Auflistung abrufenRetrieve a unique element from an array or collection

Eine Zufallszahlen-Generators kann doppelte Werte immer zurück.A random number generator can always return duplicate values. Der Bereich der Werte kleiner wird, oder die Anzahl der Werte, die generiert wird, größer, steigt die Wahrscheinlichkeit von Duplikaten.As the range of numbers becomes smaller or the number of values generated becomes larger, the probability of duplicates grows. Wenn zufällige Werte eindeutig sein müssen, werden weitere Zahlen generiert, um Duplikate zu kompensieren zunehmend eine schlechte Leistung.If random values must be unique, more numbers are generated to compensate for duplicates, resulting in increasingly poor performance.

Es gibt eine Reihe von Techniken zum Behandeln dieses Szenarios.There are a number of techniques to handle this scenario. Eine gängige Lösung ist ein Array oder -Auflistung, die die Werte enthält, abgerufen werden sollen, und ein paralleles Array, das zufällige Gleitkommazahlen enthält zu erstellen.One common solution is to create an array or collection that contains the values to be retrieved, and a parallel array that contains random floating-point numbers. Das zweite Array wird mit Zufallszahlen gefüllt, die zum Zeitpunkt der erste Array erstellt, und die Array.Sort(Array, Array) Methode wird verwendet, um das erste Array zu sortieren, indem Sie mithilfe der Werte in den parallelen Arrays.The second array is populated with random numbers at the time the first array is created, and the Array.Sort(Array, Array) method is used to sort the first array by using the values in the parallel array.

Z. B. Wenn Sie ein Spiel Solitaire entwickeln, möchten Sie sicherstellen, dass jede Karte nur einmal verwendet wird.For example, if you're developing a Solitaire game, you want to ensure that each card is used only once. Anstatt Zufallszahlen zum Abrufen einer Karte und nachverfolgt, ob die Karte bereits behandelt wurde, können Sie ein paralleles Array von Zufallszahlen erstellen, die verwendet werden können, um den Stapel zu sortieren.Instead of generating random numbers to retrieve a card and tracking whether that card has already been dealt, you can create a parallel array of random numbers that can be used to sort the deck. Nach der Kartenstapel sortiert ist, kann Ihre app einen Zeiger, um anzugeben, den Index der nächsten Karte des Kartenstapels beibehalten.Once the deck is sorted, your app can maintain a pointer to indicate the index of the next card on the deck.

Dieser Ansatz wird anhand des folgenden Beispiels veranschaulicht.The following example illustrates this approach. Definiert eine `Card` Klasse die darstellt, die eine Spielkarte und einen `Dealer` -Klasse, die einen Satz mischenden Karten behandelt.It defines a `Card` class that represents a playing card and a `Dealer` class that deals a deck of shuffled cards. Die `Dealer` Klassenkonstruktor füllt zwei Arrays: eine `deck` Array, das über einen Klassenbereich und, das alle Karten des Kartenstapels; und einem lokalen darstellt `order` Array, das die gleiche von Elementen wie Anzahl die `deck` array und aufgefüllt mit nach dem Zufallsprinzip generiert Double Werte.The `Dealer` class constructor populates two arrays: a `deck` array that has class scope and that represents all the cards in the deck; and a local `order` array that has the same number of elements as the `deck` array and is populated with randomly generated Double values. Die Array.Sort(Array, Array) Methode wird aufgerufen, um das Sortieren der `deck` Array basierend auf den Werten in der `order` Array.The Array.Sort(Array, Array) method is then called to sort the `deck` array based on the values in the `order` array.

``````using namespace System;

public enum class Suit { Hearts, Diamonds, Spades, Clubs };

public enum class FaceValue  { Ace = 1, Two, Three, Four, Five, Six,
Seven, Eight, Nine, Ten, Jack, Queen,
King };

// A class that represents an individual card in a playing deck.
ref class Card
{
public:
Suit Suit;
FaceValue FaceValue;

String^ ToString() override
{
return String::Format("{0:F} of {1:F}", this->FaceValue, this->Suit);
}
};

ref class Dealer
{
private:
Random^ rnd;
// A deck of cards, without Jokers.
array<Card^>^ deck = gcnew array<Card^>(52);
// Parallel array for sorting cards.
array<Double>^ order = gcnew array<Double>(52);
// A pointer to the next card to deal.
int ptr = 0;
// A flag to indicate the deck is used.
bool mustReshuffle = false;

public:
Dealer()
{
rnd = gcnew Random();
// Initialize the deck.
int deckCtr = 0;
for each (auto suit in Enum::GetValues(Suit::typeid)) {
for each (FaceValue faceValue in Enum::GetValues(FaceValue::typeid)) {
Card^ card = gcnew Card();
card->Suit = (Suit) suit;
card->FaceValue = (FaceValue) faceValue;
deck[deckCtr] = card;
deckCtr++;
}
}

for (int ctr = 0; ctr < order->Length; ctr++)
order[ctr] = rnd->NextDouble();

Array::Sort(order, deck);
}

array<Card^>^ Deal(int numberToDeal)
{
if (mustReshuffle) {
Console::WriteLine("There are no cards left in the deck");
return nullptr;
}

array<Card^>^ cardsDealt = gcnew array<Card^>(numberToDeal);
for (int ctr = 0; ctr < numberToDeal; ctr++) {
cardsDealt[ctr] = deck[ptr];
ptr++;
if (ptr == deck->Length)
mustReshuffle = true;

if (mustReshuffle & ctr < numberToDeal - 1) {
Console::WriteLine("Can only deal the {0} cards remaining on the deck.",
ctr + 1);
return cardsDealt;
}
}
return cardsDealt;
}
};

void ShowCards(array<Card^>^ cards)
{
for each (Card^ card in cards)
if (card != nullptr)
Console::WriteLine("{0} of {1}", card->FaceValue, card->Suit);
};

void main()
{
Dealer^ dealer = gcnew Dealer();
ShowCards(dealer->Deal(20));
}

// The example displays output like the following:
//       Six of Diamonds
//       King of Clubs
//       Eight of Clubs
//       Seven of Clubs
//       Queen of Clubs
//       King of Hearts
//       Ace of Clubs
//       Four of Hearts
//       Three of Diamonds
//       Nine of Diamonds
//       Two of Hearts
//       Ace of Hearts
//       Three of Hearts
//       Eight of Hearts
//       Queen of Diamonds
//       Two of Clubs
//       Four of Diamonds
//       Jack of Hearts
``````
``````using System;

// A class that represents an individual card in a playing deck.
public class Card
{
public Suit Suit;
public FaceValue FaceValue;

public override String ToString()
{
return String.Format("{0:F} of {1:F}", this.FaceValue, this.Suit);
}
}

public enum Suit { Hearts, Diamonds, Spades, Clubs };

public enum FaceValue  { Ace = 1, Two, Three, Four, Five, Six,
Seven, Eight, Nine, Ten, Jack, Queen,
King };

public class Dealer
{
Random rnd;
// A deck of cards, without Jokers.
Card[] deck = new Card[52];
// Parallel array for sorting cards.
Double[] order = new Double[52];
// A pointer to the next card to deal.
int ptr = 0;
// A flag to indicate the deck is used.
bool mustReshuffle = false;

public Dealer()
{
rnd = new Random();
// Initialize the deck.
int deckCtr = 0;
foreach (var suit in Enum.GetValues(typeof(Suit))) {
foreach (var faceValue in Enum.GetValues(typeof(FaceValue))) {
Card card = new Card();
card.Suit = (Suit) suit;
card.FaceValue = (FaceValue) faceValue;
deck[deckCtr] = card;
deckCtr++;
}
}

for (int ctr = 0; ctr < order.Length; ctr++)
order[ctr] = rnd.NextDouble();

Array.Sort(order, deck);
}

public Card[] Deal(int numberToDeal)
{
if (mustReshuffle) {
Console.WriteLine("There are no cards left in the deck");
return null;
}

Card[] cardsDealt = new Card[numberToDeal];
for (int ctr = 0; ctr < numberToDeal; ctr++) {
cardsDealt[ctr] = deck[ptr];
ptr++;
if (ptr == deck.Length)
mustReshuffle = true;

if (mustReshuffle & ctr < numberToDeal - 1) {
Console.WriteLine("Can only deal the {0} cards remaining on the deck.",
ctr + 1);
return cardsDealt;
}
}
return cardsDealt;
}
}

public class Example
{
public static void Main()
{
Dealer dealer = new Dealer();
ShowCards(dealer.Deal(20));
}

private static void ShowCards(Card[] cards)
{
foreach (var card in cards)
if (card != null)
Console.WriteLine("{0} of {1}", card.FaceValue, card.Suit);
}
}
// The example displays output like the following:
//       Six of Diamonds
//       King of Clubs
//       Eight of Clubs
//       Seven of Clubs
//       Queen of Clubs
//       King of Hearts
//       Ace of Clubs
//       Four of Hearts
//       Three of Diamonds
//       Nine of Diamonds
//       Two of Hearts
//       Ace of Hearts
//       Three of Hearts
//       Eight of Hearts
//       Queen of Diamonds
//       Two of Clubs
//       Four of Diamonds
//       Jack of Hearts
``````
``````' A class that represents an individual card in a playing deck.
Public Class Card
Public Suit As Suit
Public FaceValue As FaceValue

Public Overrides Function ToString() As String
Return String.Format("{0:F} of {1:F}", Me.FaceValue, Me.Suit)
End Function
End Class

Public Enum Suit As Integer
Hearts = 0
Diamonds = 1
Clubs = 3
End Enum

Public Enum FaceValue As Integer
Ace = 1
Two = 2
Three = 3
Four = 4
Five = 5
Six = 6
Seven = 7
Eight = 8
Nine = 9
Ten = 10
Jack = 11
Queen = 12
King = 13
End Enum

Public Class Dealer
Dim rnd As Random
' A deck of cards, without Jokers.
Dim deck(51) As Card
' Parallel array for sorting cards.
Dim order(51) As Double
' A pointer to the next card to deal.
Dim ptr As Integer = 0
' A flag to indicate the deck is used.
Dim mustReshuffle As Boolean

Public Sub New()
rnd = New Random()
' Initialize the deck.
Dim deckCtr As Integer = 0
For Each Suit In [Enum].GetValues(GetType(Suit))
For Each faceValue In [Enum].GetValues(GetType(FaceValue))
Dim card As New Card()
card.Suit = CType(Suit, Suit)
card.FaceValue = CType(faceValue, FaceValue)
deck(deckCtr) = card
deckCtr += 1
Next
Next
For ctr As Integer = 0 To order.Length - 1
order(ctr) = rnd.NextDouble()
Next
Array.Sort(order, deck)
End Sub

Public Function Deal(numberToDeal As Integer) As Card()
If mustReshuffle Then
Console.WriteLine("There are no cards left in the deck")
Return Nothing
End If

Dim cardsDealt(numberToDeal - 1) As Card
For ctr As Integer = 0 To numberToDeal - 1
cardsDealt(ctr) = deck(ptr)
ptr += 1
If ptr = deck.Length Then
mustReshuffle = True
End If
If mustReshuffle And ctr < numberToDeal - 1
Console.WriteLine("Can only deal the {0} cards remaining on the deck.",
ctr + 1)
Return cardsDealt
End If
Next
Return cardsDealt
End Function
End Class

Public Module Example
Public Sub Main()
Dim dealer As New Dealer()
ShowCards(dealer.Deal(20))
End Sub

Private Sub ShowCards(cards() As Card)
For Each card In cards
If card IsNot Nothing Then _
Console.WriteLine("{0} of {1}", card.FaceValue, card.Suit)
Next
End Sub
End Module
' The example displays output like the following:
'       Six of Diamonds
'       King of Clubs
'       Eight of Clubs
'       Seven of Clubs
'       Queen of Clubs
'       King of Hearts
'       Ace of Clubs
'       Four of Hearts
'       Three of Diamonds
'       Nine of Diamonds
'       Two of Hearts
'       Ace of Hearts
'       Three of Hearts
'       Eight of Hearts
'       Queen of Diamonds
'       Two of Clubs
'       Four of Diamonds
'       Jack of Hearts
``````

## Hinweise für Vererber

In .NET Framework 1.0 und 1.1, eine minimale Implementierung einer Klasse abgeleitet Random erforderlich sind, überschreiben die Sample() Methode, um einen neuen oder geänderten Algorithmus zum Generieren von Zufallszahlen zu definieren. In the .NET Framework 1.0 and 1.1, a minimum implementation of a class derived from Random required overriding the Sample() method to define a new or modified algorithm for generating random numbers. Die abgeleitete Klasse kann anschließend die basisklassenimplementierung von kommen die Next(), Next(Int32), Next(Int32, Int32), NextBytes(Byte[]), und NextDouble() Methoden zum Aufrufen der Implementierung der abgeleiteten Klasse die Sample() Methode. The derived class could then rely on the base class implementation of the Next(), Next(Int32), Next(Int32, Int32), NextBytes(Byte[]), and NextDouble() methods to call the derived class implementation of the Sample() method. In .NET Framework 2.0 und höher wird das Verhalten der Next(), Next(Int32, Int32), und NextBytes(Byte[]) Methoden wurden geändert, sodass diese Methoden nicht unbedingt Implementierung der abgeleiteten Klasse Aufrufen der Sample() Methode. In the .NET Framework 2.0 and later, the behavior of the Next(), Next(Int32, Int32), and NextBytes(Byte[]) methods have changed so that these methods do not necessarily call the derived class implementation of the Sample() method. Daher von abgeleiteten Klassen Random , die als Ziel .NET Framework 2.0 und höher sollten auch diese drei Methoden überschreiben. As a result, classes derived from Random that target the .NET Framework 2.0 and later should also override these three methods.

## Hinweise für Aufrufer

Die Implementierung der vom Zufallszahlen-Generator in der Random Klasse ist nicht zwingend von Hauptversionen von .NET Framework unverändert. The implementation of the random number generator in the Random class isn't guaranteed to remain the same across major versions of the .NET Framework. Daher sollte nicht Sie davon ausgehen, dass der gleiche Ausgangswert in der gleichen pseudozufällige Sequenz in verschiedenen Versionen von .NET Framework führt. 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.

## Konstruktoren

 Random() Random() Random() Random() Initialisiert eine neue Instanz der Random-Klasse unter Verwendung eines zeitabhängigen Standardstartwerts. Initializes a new instance of the Random class, using a time-dependent default seed value. Random(Int32) Random(Int32) Random(Int32) Random(Int32) Initialisiert eine neue Instanz der Random-Klasse unter Verwendung des angegebenen Startwerts. Initializes a new instance of the Random class, using the specified seed value.

## Methoden

 Equals(Object) Equals(Object) Equals(Object) Equals(Object) Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist. Determines whether the specified object is equal to the current object. (Inherited from Object) GetHashCode() GetHashCode() GetHashCode() GetHashCode() Fungiert als die Standardhashfunktion. Serves as the default hash function. (Inherited from Object) GetType() GetType() GetType() GetType() Ruft den Type der aktuellen Instanz ab. Gets the Type of the current instance. (Inherited from Object) MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone() Erstellt eine flache Kopie des aktuellen Object. Creates a shallow copy of the current Object. (Inherited from Object) Next() Next() Next() Next() Gibt eine nicht negative Zufallsganzzahl zurück. Returns a non-negative random integer. Next(Int32) Next(Int32) Next(Int32) Next(Int32) Gibt eine nicht negative Zufallsganzzahl zurück, die kleiner als das angegebene Maximum ist. Returns a non-negative random integer that is less than the specified maximum. Next(Int32, Int32) Next(Int32, Int32) Next(Int32, Int32) Next(Int32, Int32) Gibt eine Zufallsganzzahl zurück, die in einem angegebenen Bereich liegt. Returns a random integer that is within a specified range. NextBytes(Byte[]) NextBytes(Byte[]) NextBytes(Byte[]) NextBytes(Byte[]) Füllt die Elemente eines angegebenen Bytearrays mit Zufallszahlen. Fills the elements of a specified array of bytes with random numbers. NextBytes(Span) NextBytes(Span) NextBytes(Span) NextBytes(Span) NextDouble() NextDouble() NextDouble() NextDouble() Gibt eine zufällige Gleitkommazahl zurück, die größer oder gleich 0,0 und kleiner als 1,0 ist. Returns a random floating-point number that is greater than or equal to 0.0, and less than 1.0. Sample() Sample() Sample() Sample() Gibt eine zufällige Gleitkommazahl zwischen 0,0 und 1,0 zurück. Returns a random floating-point number between 0.0 and 1.0. ToString() ToString() ToString() ToString() Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. Returns a string that represents the current object. (Inherited from Object)