# RandomRandomRandomRandom Class

## Definición

Representa un generador de números pseudoaleatorios, que es un dispositivo que produce una secuencia de números que cumplen determinados requisitos estadísticos de aleatoriedad.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)]
[System.Serializable]
public class Random``````
``type Random = class``
``Public Class Random``
Herencia
RandomRandomRandomRandom
Atributos

## Ejemplos

En el ejemplo siguiente se crea un único generador de números aleatorios Nexty se NextDouble llama a sus NextBytesmétodos, y para generar secuencias de números aleatorios dentro de intervalos diferentes.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
``````
``````// Instantiate random number generator using system-supplied value as seed.
var rand = new Random();

// Generate and display 5 random byte (integer) values.
var 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
``````

En el ejemplo siguiente se genera un entero aleatorio que se usa como índice para recuperar un valor de cadena de una matriz.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
``````
``````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
``````

## Comentarios

Los números pseudoaleatorios se eligen con la misma probabilidad de un conjunto finito de números.Pseudo-random numbers are chosen with equal probability from a finite set of numbers. Los números elegidos no son completamente aleatorios porque se usa un algoritmo matemático para seleccionarlos, pero son lo suficientemente aleatorios para fines prácticos.The chosen numbers are not completely random because a mathematical algorithm is used to select them, but they are sufficiently random for practical purposes. La implementación actual de la Random clase se basa en una versión modificada del algoritmo del generador de números aleatorios restados de Donald E. Knuth.The current implementation of the Random class is based on a modified version of Donald E. Knuth's subtractive random number generator algorithm. Para obtener más información, vea D. E.For more information, see D. E. Knuth.Knuth. El arte de la programación de equipos, volumen 2: Algoritmos seminuméricos.The Art of Computer Programming, Volume 2: Seminumerical Algorithms. Addison-Wesley, lectura, MA, tercera edición, 1997.Addison-Wesley, Reading, MA, third edition, 1997.

Para generar un número aleatorio criptográficamente seguro, como uno que sea adecuado para crear una contraseña aleatoria, use la RNGCryptoServiceProvider clase o derive una clase de. System.Security.Cryptography.RandomNumberGeneratorTo 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.

En este tema:In this topic:

### Crear instancias del generador de números aleatoriosInstantiating the random number generator

Para crear una instancia del generador de números aleatorios, proporcione un valor de inicialización (un valor inicial para el algoritmo de generación de Random números pseudoaleatorios) a un constructor de clase.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. Puede proporcionar el valor de inicialización de forma explícita o implícita:You can supply the seed value either explicitly or implicitly:

• El Random(Int32) constructor usa un valor de inicialización explícito proporcionado por el usuario.The Random(Int32) constructor uses an explicit seed value that you supply.

• El Random() constructor usa el reloj del sistema para proporcionar un valor de inicialización.The Random() constructor uses the system clock to provide a seed value. Esta es la forma más común de crear instancias del generador de números aleatorios.This is the most common way of instantiating the random number generator.

Si se utiliza la misma inicialización para Random objetos independientes, se generará la misma serie de números aleatorios.If the same seed is used for separate Random objects, they will generate the same series of random numbers. Esto puede ser útil para crear un conjunto de pruebas que procese valores aleatorios o para reproducir juegos que derivan sus datos de números aleatorios.This can be useful for creating a test suite that processes random values, or for replaying games that derive their data from random numbers. Sin embargo, tenga Random en cuenta que los objetos de procesos que se ejecutan en diferentes versiones del .NET Framework pueden devolver series diferentes de números aleatorios, incluso si se crean instancias con valores de inicialización idénticos.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.

Para generar diferentes secuencias de números aleatorios, puede hacer que el valor de inicialización dependa del tiempo, lo que genera una serie diferente Randomcon cada nueva instancia de.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. El Random(Int32) constructor con parámetros puede tomar un Int32 valor basado en el número de pasos en la hora actual Random() , mientras que el constructor sin parámetros usa el reloj del sistema para generar su valor de inicialización.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. Sin embargo, solo en el .NET Framework, dado que el reloj tiene una resolución finita, el uso del constructor sin Random parámetros para crear objetos diferentes en sucesión se crea generadores de números aleatorios que generan secuencias idénticas de forma aleatoria. los.However, on the .NET Framework only, 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. En el ejemplo siguiente se muestra cómo Random dos objetos con instancias consecutivas en una aplicación .NET Framework generan una serie idéntica de números aleatorios.The following example illustrates how two Random objects that are instantiated in close succession in a .NET Framework application generate an identical series of random numbers. En la mayoría de los Random sistemas de Windows, es probable que los objetos creados en un plazo de 15 milisegundos entre sí sean valores de inicialización idénticos.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
``````
``````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
``````

Para evitar este problema, cree un solo Random objeto en lugar de varios objetos.To avoid this problem, create a single Random object instead of multiple objects. Tenga en cuenta `Random` que la clase de .net Core no tiene esta limitación.Note that the `Random` class in .NET Core does not have this limitation.

### Evitar varias creaciones de instanciasAvoiding multiple instantiations

En el .NET Framework, al inicializar dos generadores de números aleatorios en un bucle estrecho o en una sucesión rápida, se crean dos generadores de números aleatorios que pueden generar secuencias idénticas de números aleatorios.On the .NET Framework, 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. En la mayoría de los casos, esto no es la intención del desarrollador y puede dar lugar a problemas de rendimiento, ya que la creación e inicialización de un generador de números aleatorios es un proceso relativamente costoso.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.

Para mejorar el rendimiento y evitar la creación accidental de generadores de números aleatorios independientes que generen secuencias numéricas idénticas, se Random recomienda crear un objeto para generar muchos números aleatorios con el tiempo, en lugar de crear nuevos Random objetos para generar un número aleatorio.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.

Sin embargo, Random la clase no es segura para subprocesos.However, the Random class isn't thread safe. Si llama a Random métodos desde varios subprocesos, siga las instrucciones que se describen en la sección siguiente.If you call Random methods from multiple threads, follow the guidelines discussed in the next section.

### La clase System. RANDOM y la seguridad para subprocesosThe System.Random class and thread safety

En lugar de crear instancias de Random objetos individuales, se recomienda crear una sola Random instancia de para generar todos los números aleatorios que necesita la aplicación.Instead of instantiating individual Random objects, we recommend that you create a single Random instance to generate all the random numbers needed by your app. Sin embargo Random , los objetos no son seguros para subprocesos.However, Random objects are not thread safe. Si la aplicación llama Random a métodos desde varios subprocesos, debe usar un objeto de sincronización para asegurarse de que solo un subproceso puede tener acceso al generador de números aleatorios cada vez.If your app calls Random methods from multiple threads, you must use a synchronization object to ensure that only one thread can access the random number generator at a time. Si no se asegura de que Random se tenga acceso al objeto de una manera segura para subprocesos, las llamadas a los métodos que devuelven números aleatorios devuelven 0.If you don't ensure that the Random object is accessed in a thread-safe way, calls to methods that return random numbers return 0.

En el ejemplo siguiente se C# usa la instrucción lock y la instrucción Visual Basic SyncLock para asegurarse de que 11 subprocesos tiene acceso a un único generador de números aleatorios de una manera segura para subprocesos.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. Cada subproceso genera 2 millones números aleatorios, cuenta el número de números aleatorios generados y calcula su suma y, a continuación, actualiza los totales de todos los subprocesos cuando termina de ejecutarse.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
``````

El ejemplo garantiza la seguridad para subprocesos de las siguientes maneras:The example ensures thread-safety in the following ways:

• El ThreadStaticAttribute atributo se usa para definir variables locales de subproceso que realizan el seguimiento del número total de números aleatorios generados y su suma para cada subproceso.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.

• Un bloqueo (la `lock` instrucción de C# y la `SyncLock` instrucción de Visual Basic) protege el acceso a las variables para el recuento total y la suma de todos los números aleatorios generados en todos los subprocesos.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.

• Se utiliza un semáforo ( CountdownEvent el objeto) para asegurarse de que el subproceso principal se bloquee hasta que todos los demás subprocesos completen la ejecución.A semaphore (the CountdownEvent object) is used to ensure that the main thread blocks until all other threads complete execution.

• En el ejemplo se comprueba si el generador de números aleatorios se ha dañado determinando si dos llamadas consecutivas a métodos de generación de números aleatorios devuelven 0.The example checks whether the random number generator has become corrupted by determining whether two consecutive calls to random number generation methods return 0. Si se detectan daños, en el ejemplo CancellationTokenSource se usa el objeto para indicar que se deben cancelar todos los subprocesos.If corruption is detected, the example uses the CancellationTokenSource object to signal that all threads should be canceled.

• Antes de generar cada número aleatorio, cada subproceso comprueba el estado CancellationToken del objeto.Before generating each random number, each thread checks the state of the CancellationToken object. Si se solicita la cancelación, el ejemplo llama CancellationToken.ThrowIfCancellationRequested al método para cancelar el subproceso.If cancellation is requested, the example calls the CancellationToken.ThrowIfCancellationRequested method to cancel the thread.

El ejemplo siguiente es idéntico al primero, salvo que usa un Task objeto y una expresión lambda en lugar de Thread objetos.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
``````

Difiere del primer ejemplo de las siguientes maneras:It differs from the first example in the following ways:

• Las variables para realizar el seguimiento del número de números aleatorios generados y su suma en cada tarea son locales para la tarea, por lo que no es necesario ThreadStaticAttribute usar el atributo.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.

• El método Task.WaitAll estático se usa para asegurarse de que el subproceso principal no se completa antes de que todas las tareas finalicen.The static Task.WaitAll method is used to ensure that the main thread doesn't complete before all tasks have finished. No es necesario el CountdownEvent objeto.There is no need for the CountdownEvent object.

• La excepción que se obtiene de la cancelación de la tarea aparece Task.WaitAll en el método.The exception that results from task cancellation is surfaced in the Task.WaitAll method. En el ejemplo anterior, cada subproceso lo controla.In the previous example, it is handled by each thread.

### Generar diferentes tipos de números aleatoriosGenerating different types of random numbers

El generador de números aleatorios proporciona métodos que permiten generar los siguientes tipos de números aleatorios:The random number generator provides methods that let you generate the following kinds of random numbers:

• Una serie de Byte valores.A series of Byte values. Puede determinar el número de valores de bytes pasando una matriz inicializada al número de elementos que desea que el método devuelva al NextBytes método.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. En el ejemplo siguiente se generan 20 bytes.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
``````
``````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
``````
• Un entero único.A single integer. Puede elegir si desea un entero de 0 a un valor máximo (Int32.MaxValue -1) llamando al Next() método, un entero comprendido entre 0 y un valor específico llamando al Next(Int32) método, o un entero dentro de un intervalo de valores mediante una llamada a la Next(Int32, Int32)método.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. En las sobrecargas con parámetros, el valor máximo especificado es exclusivo; es decir, el número máximo real generado es uno menos que el valor especificado.In the parameterized overloads, the specified maximum value is exclusive; that is, the actual maximum number generated is one less than the specified value.

En el ejemplo siguiente se Next(Int32, Int32) llama al método para generar 10 números aleatorios entre-10 y 10.The following example calls the Next(Int32, Int32) method to generate 10 random numbers between -10 and 10. Tenga en cuenta que el segundo argumento del método especifica el límite superior exclusivo del intervalo de valores aleatorios devueltos por el método.Note that the second argument to the method specifies the exclusive upper bound of the range of random values returned by the method. En otras palabras, el entero más grande que el método puede devolver es uno menos que este valor.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
``````
``````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
``````
• Un valor de punto flotante único de 0,0 a menor que 1,0 llamando al NextDouble método.A single floating-point value from 0.0 to less than 1.0 by calling the NextDouble method. El límite superior exclusivo del número aleatorio devuelto por el método es 1, por lo que su límite superior real es 0.99999999999999978.The exclusive upper bound of the random number returned by the method is 1, so its actual upper bound is 0.99999999999999978. En el ejemplo siguiente se generan 10 números de punto flotante aleatorios.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
``````
``````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
``````

Importante

El Next(Int32, Int32) método le permite especificar el intervalo del número aleatorio devuelto.The Next(Int32, Int32) method allows you to specify the range of the returned random number. Sin embargo, `maxValue` el parámetro, que especifica el número devuelto de rango superior, es un valor exclusivo, no un valor inclusivo.However, the `maxValue` parameter, which specifies the upper range returned number, is an exclusive, not an inclusive, value. Esto significa que la llamada `Next(0, 100)` al método devuelve un valor entre 0 y 99, y no entre 0 y 100.This means that the method call `Next(0, 100)` returns a value between 0 and 99, and not between 0 and 100.

También puede usar la clase Random para tareas como la generación de valores de tipo T:System.Boolean aleatorios, la generación de valores de punto flotante aleatorios con un intervalo distinto de 0 a 1, quegenera enteros aleatorios de 64 bitsy de forma aleatoria. recuperar un elemento único de una matriz o colección.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. Para estas y otras tareas comunes, consulte el procedimiento uso de System. RANDOM to...For these and other common tasks, see the How do you use System.Random to… transversal.section.

### Sustituir su propio algoritmoSubstituting your own algorithm

Puede implementar su propio generador de números aleatorios heredando de la Random clase y proporcionando el algoritmo de generación de números aleatorios.You can implement your own random number generator by inheriting from the Random class and supplying your random number generation algorithm. Para proporcionar su propio algoritmo, debe invalidar el Sample método, que implementa el algoritmo de generación de números aleatorios.To supply your own algorithm, you must override the Sample method, which implements the random number generation algorithm. También debe invalidar los Next()métodos Next(Int32, Int32), y NextBytes para asegurarse de que llaman al método invalidado Sample .You should also override the Next(), Next(Int32, Int32), and NextBytes methods to ensure that they call your overridden Sample method. No es necesario invalidar los Next(Int32) métodos NextDouble y.You don't have to override the Next(Int32) and NextDouble methods.

Para obtener un ejemplo que deriva de la Random clase y modifica su generador de números pseudoaleatorios predeterminados, vea la Sample página de referencia.For an example that derives from the Random class and modifies its default pseudo-random number generator, see the Sample reference page.

### ¿Cómo se usa System. RANDOM para...How do you use System.Random to…

En las siguientes secciones se analiza y se proporciona código de ejemplo para algunas de las maneras en que se pueden querer usar números aleatorios en la aplicación.The following sections discuss and provide sample code for some of the ways you might want to use random numbers in your app.

#### Recuperar la misma secuencia de valores aleatoriosRetrieve the same sequence of random values

A veces, desea generar la misma secuencia de números aleatorios en los escenarios de prueba de software y en la reproducción de juegos.Sometimes you want to generate the same sequence of random numbers in software test scenarios and in game playing. Las pruebas con la misma secuencia de números aleatorios le permiten detectar regresiones y confirmar correcciones de errores.Testing with the same sequence of random numbers allows you to detect regressions and confirm bug fixes. El uso de la misma secuencia de número aleatorio en juegos le permite reproducir juegos anteriores.Using the same sequence of random number in games allows you to replay previous games.

Puede generar la misma secuencia de números aleatorios proporcionando el mismo valor de inicialización al Random(Int32) constructor.You can generate the same sequence of random numbers by providing the same seed value to the Random(Int32) constructor. El valor de inicialización proporciona un valor inicial para el algoritmo de generación de números pseudoaleatorios.The seed value provides a starting value for the pseudo-random number generation algorithm. En el ejemplo siguiente se usa 100100 como valor de inicialización arbitrario para Random crear una instancia del objeto, se muestran 20 valores de punto flotante aleatorios y se conserva el valor de inicialización.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. A continuación, restaura el valor de inicialización, crea una instancia de un nuevo generador de números aleatorios y muestra los mismos valores de punto flotante de 20.It then restores the seed value, instantiates a new random number generator, and displays the same 20 random floating-point values. Tenga en cuenta que en el ejemplo se pueden generar diferentes secuencias de números aleatorios si se ejecutan en versiones diferentes del .NET Framework.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
``````

#### Recuperar secuencias únicas de números aleatoriosRetrieve unique sequences of random numbers

Proporcionar valores de inicialización diferentes a las Random instancias de la clase hace que cada generador de números aleatorios genere una secuencia diferente de valores.Providing different seed values to instances of the Random class causes each random number generator to produce a different sequence of values. Puede proporcionar un valor de inicialización explícitamente Random(Int32) llamando al constructor o implícitamente mediante una llamada al Random() constructor.You can provide a seed value either explicitly by calling the Random(Int32) constructor, or implicitly by calling the Random() constructor. La mayoría de los desarrolladores llaman al constructor sin parámetros, que usa el reloj del sistema.Most developers call the parameterless constructor, which uses the system clock. En el ejemplo siguiente se usa este enfoque para crear Random instancias de dos instancias de.The following example uses this approach to instantiate two Random instances. Cada instancia muestra una serie de 10 enteros aleatorios.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
``````

Sin embargo, debido a su resolución finita, el reloj del sistema no detecta diferencias horarias que son inferiores a 15 milisegundos aproximadamente.However, because of its finite resolution, the system clock doesn't detect time differences that are less than approximately 15 milliseconds. Por lo tanto, si el código Random() llama a la sobrecarga en el .NET Framework para Random crear instancias de dos objetos sucesivamente, podría estar proporcionando accidentalmente los objetos con valores de inicialización idénticos.Therefore, if your code calls the Random() overload on the .NET Framework to instantiate two Random objects in succession, you might inadvertently be providing the objects with identical seed values. (La Random clase de .net Core no tiene esta limitación). Para ver esto en el ejemplo anterior, convoque como Thread.Sleep comentario la llamada al método y compile y vuelva a ejecutar el ejemplo.(The Random class in .NET Core does not have this limitation.) To see this in the previous example, comment out the Thread.Sleep method call, and compile and run the example again.

Para evitar que esto suceda, se recomienda crear una instancia de un solo Random objeto en lugar de varios.To prevent this from happening, we recommend that you instantiate a single Random object rather than multiple ones. Sin embargo, Random puesto que no es seguro para subprocesos, debe usar algún dispositivo Random de sincronización si tiene acceso a una instancia de desde varios subprocesos; para obtener más información, vea la sección seguridad de subprocesos y clases aleatorias anteriormente en este tema.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. Como alternativa, puede usar un mecanismo de retraso, como el Sleep método utilizado en el ejemplo anterior, para asegurarse de que las instancias se producen más de 15 milisegundos de distancia.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.

#### Recuperar enteros en un intervalo especificadoRetrieve integers in a specified range

Puede recuperar enteros en un intervalo especificado llamando al Next(Int32, Int32) método, que le permite especificar el límite inferior y el superior de los números que desea que devuelva el generador de números aleatorios.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. El límite superior es un valor exclusivo, no un valor inclusivo.The upper bound is an exclusive, not an inclusive, value. Es decir, no se incluye en el intervalo de valores devueltos por el método.That is, it isn't included in the range of values returned by the method. En el ejemplo siguiente se usa este método para generar enteros aleatorios entre-10 y 10.The following example uses this method to generate random integers between -10 and 10. Tenga en cuenta que especifica 11, que es uno mayor que el valor deseado, como el valor del `maxValue` argumento en la llamada al método.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
``````
``````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
``````

#### Recuperar enteros con un número de dígitos especificadoRetrieve integers with a specified number of digits

Puede llamar Next(Int32, Int32) al método para recuperar números con un número especificado de dígitos.You can call the Next(Int32, Int32) method to retrieve numbers with a specified number of digits. Por ejemplo, para recuperar números con cuatro dígitos (es decir, números que van de 1000 a 9999), llame al Next(Int32, Int32) método con un `minValue` valor de 1000 y un `maxValue` valor de 10000, como se muestra en el ejemplo siguiente.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
``````
``````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
``````

#### Recuperar valores de punto flotante en un intervalo especificadoRetrieve floating-point values in a specified range

El NextDouble método devuelve valores de punto flotante aleatorios comprendidos entre 0 y menor que 1.The NextDouble method returns random floating-point values that range from 0 to less than 1. Sin embargo, a menudo querrá generar valores aleatorios en algún otro intervalo.However, you'll often want to generate random values in some other range.

Si el intervalo entre los valores mínimos y máximos deseados es 1, puede Agregar la diferencia entre el intervalo de inicio deseado y 0 al número devuelto NextDouble por el método.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. En el ejemplo siguiente se hace para generar 10 números aleatorios entre-1 y 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
``````
``````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
``````

Para generar números de punto flotante aleatorios cuyo límite inferior es 0 pero el límite superior es mayor que 1 (o, en el caso de números negativos, cuyo límite inferior es menor que-1 y el límite superior es 0), multiplique el número aleatorio por el límite distinto de cero.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. En el ejemplo siguiente se hace esto para generar 20 millones números de punto flotante aleatorios que van Int64.MaxValuede 0 a.The following example does this to generate 20 million random floating-point numbers that range from 0 to Int64.MaxValue. En también muestra la distribución de los valores aleatorios generados por el método.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 %
``````
``````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 %
``````

Para generar números de punto flotante aleatorios entre dos valores arbitrarios, Next(Int32, Int32) como sucede con el método para los enteros, utilice la siguiente fórmula: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
``````

En el ejemplo siguiente se generan 1 millón números aleatorios que van de 10,0 a 11,0 y se muestra su distribución.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 %)
``````
``````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 %)
``````

#### Generar valores booleanos aleatoriosGenerate random Boolean values

La Random clase no proporciona métodos que generen Boolean valores.The Random class doesn't provide methods that generate Boolean values. Sin embargo, puede definir su propia clase o método para hacerlo.However, you can define your own class or method to do that. En el ejemplo siguiente se define una `BooleanGenerator`clase,, con un único `NextBoolean`método,.The following example defines a class, `BooleanGenerator`, with a single method, `NextBoolean`. La `BooleanGenerator` clase almacena un Random objeto como una variable privada.The `BooleanGenerator` class stores a Random object as a private variable. El `NextBoolean` método llama al Random.Next(Int32, Int32) método y Convert.ToBoolean(Int32) pasa el resultado al método.The `NextBoolean` method calls the Random.Next(Int32, Int32) method and passes the result to the Convert.ToBoolean(Int32) method. Tenga en cuenta que 2 se utiliza como argumento para especificar el límite superior del número aleatorio.Note that 2 is used as the argument to specify the upper bound of the random number. Dado que se trata de un valor exclusivo, la llamada al método devuelve 0 o 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 %)
``````

En lugar de crear una clase independiente para generar valores Boolean aleatorios, el ejemplo podría simplemente haber definido un único método.Instead of creating a separate class to generate random Boolean values, the example could simply have defined a single method. Sin embargo, en ese caso, Random el objeto se debe haber definido como una variable de nivel de clase para evitar la creación Random de instancias de una nueva instancia en cada llamada al método.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. En Visual Basic, la instancia aleatoria se puede definir como una variable estática en el `NextBoolean` método.In Visual Basic, the Random instance can be defined as a Static variable in the `NextBoolean` method. En el ejemplo siguiente se proporciona una implementación de.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 %)
``````
``````Random rnd = new Random();

int totalTrue = 0, totalFalse = 0;

// Generate 1,000,000 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));

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 %)
``````

#### Generar enteros de 64 bits aleatoriosGenerate random 64-bit integers

Las sobrecargas del Next método devuelven enteros de 32 bits.The overloads of the Next method return 32-bit integers. Sin embargo, en algunos casos, puede que desee trabajar con enteros de 64 bits.However, in some cases, you might want to work with 64-bit integers. Puede hacerlo de la siguiente manera:You can do this as follows:

1. Llame al NextDouble método para recuperar un valor de punto flotante de precisión doble.Call the NextDouble method to retrieve a double-precision floating point value.

2. Multiplica ese valor por Int64.MaxValue.Multiply that value by Int64.MaxValue.

En el ejemplo siguiente se usa esta técnica para generar 20 millones enteros largos aleatorios y categorizarlos en 10 grupos iguales.The following example uses this technique to generate 20 million random long integers and categorizes them in 10 equal groups. A continuación, evalúa la distribución de los números aleatorios contando el número en cada grupo de 0 a Int64.MaxValue.It then evaluates the distribution of the random numbers by counting the number in each group from 0 to Int64.MaxValue. Como muestra la salida del ejemplo, los números se distribuyen de manera más o menos equitativa a través del intervalo de un entero largo.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 %
``````
``````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 %
``````

Una técnica alternativa que usa la manipulación de bits no genera números realmente aleatorios.An alternative technique that uses bit manipulation does not generate truly random numbers. Esta técnica llama Next() a para generar dos enteros, desplaza a la izquierda uno por 32 bits y los une.This technique calls Next() to generate two integers, left-shifts one by 32 bits, and ORs them together. Esta técnica tiene dos limitaciones:This technique has two limitations:

1. Dado que el bit 31 es el bit de signo, el valor en el bit 31 del entero largo resultante es siempre 0.Because bit 31 is the sign bit, the value in bit 31 of the resulting long integer is always 0. Esto se puede solucionar generando un valor aleatorio de 0 o 1, desplazando a la izquierda 31 bits y ORing con el entero largo aleatorio original.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. Más seriamente, dado que la probabilidad de que el valor Next() devuelto por sea 0, habrá pocos valores si los números aleatorios están en el intervalo 0X0-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.

#### Recuperar bytes en un intervalo especificadoRetrieve bytes in a specified range

Las sobrecargas del Next método permiten especificar el intervalo de números aleatorios, pero el método no NextBytes lo hace.The overloads of the Next method allow you to specify the range of random numbers, but the NextBytes method does not. En el ejemplo siguiente se implementa `NextBytes` un método que le permite especificar el intervalo de bytes devueltos.The following example implements a `NextBytes` method that lets you specify the range of the returned bytes. Define una `Random2` clase que deriva de Random y sobrecarga su `NextBytes` método.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
``````

El `NextBytes(Byte[], Byte, Byte)` método ajusta una llamada Next(Int32, Int32) al método y especifica el valor mínimo y uno mayor que el valor máximo (en este caso, 0 y 101) que queremos que se devuelva en la matriz de bytes.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. Dado que estamos seguros de que los valores enteros devueltos Next por el método están dentro del intervalo Byte del tipo de datos, podemos convertirlos de forma C#segura (en) o convertirlos (en Visual Basic) de enteros en bytes.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.

#### Recuperar un elemento de una matriz o colección de forma aleatoriaRetrieve an element from an array or collection at random

Los números aleatorios suelen servir como índices para recuperar valores de matrices o colecciones.Random numbers often serve as indexes to retrieve values from arrays or collections. Para recuperar un valor de índice aleatorio, puede llamar al Next(Int32, Int32) método y usar el límite inferior de la matriz como el valor de su `minValue` argumento y uno mayor que el límite superior de la matriz como el valor de su `maxValue` argumento.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. En el caso de una matriz de base cero, es equivalente Length a su propiedad o una mayor que el valor devuelto Array.GetUpperBound por el método.For a zero-based array, this is equivalent to its Length property, or one greater than the value returned by the Array.GetUpperBound method. En el ejemplo siguiente se recupera aleatoriamente el nombre de una ciudad en el Estados Unidos de una matriz de ciudades.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
``````
``````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
``````

#### Recuperar un elemento único de una matriz o colecciónRetrieve a unique element from an array or collection

Un generador de números aleatorios siempre puede devolver valores duplicados.A random number generator can always return duplicate values. A medida que el intervalo de números se vuelve más pequeño o el número de valores generados es mayor, aumenta la probabilidad de duplicados.As the range of numbers becomes smaller or the number of values generated becomes larger, the probability of duplicates grows. Si los valores aleatorios deben ser únicos, se generan más números para compensar duplicados, lo que da lugar a un rendimiento cada vez mayor.If random values must be unique, more numbers are generated to compensate for duplicates, resulting in increasingly poor performance.

Hay varias técnicas para controlar este escenario.There are a number of techniques to handle this scenario. Una solución común consiste en crear una matriz o una colección que contenga los valores que se van a recuperar y una matriz paralela que contiene números de punto flotante aleatorios.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. La segunda matriz se rellena con números aleatorios en el momento en que se crea la primera matriz Array.Sort(Array, Array) y el método se usa para ordenar la primera matriz usando los valores de la matriz paralela.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.

Por ejemplo, si está desarrollando un juego de solitario, desea asegurarse de que cada tarjeta se use solo una vez.For example, if you're developing a Solitaire game, you want to ensure that each card is used only once. En lugar de generar números aleatorios para recuperar una tarjeta y realizar un seguimiento de si esa tarjeta ya se ha tratado, puede crear una matriz paralela de números aleatorios que se pueden usar para ordenar la baraja.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. Una vez que la baraja está ordenada, la aplicación puede mantener un puntero para indicar el índice de la siguiente carta de la baraja.Once the deck is sorted, your app can maintain a pointer to indicate the index of the next card on the deck.

En el ejemplo siguiente se muestra este enfoque.The following example illustrates this approach. Define una `Card` clase que representa una tarjeta de juego y una `Dealer` clase que trata una baraja de cartas aleatorias.It defines a `Card` class that represents a playing card and a `Dealer` class that deals a deck of shuffled cards. El `Dealer` constructor de clase rellena dos matrices: una `deck` matriz que tiene ámbito de clase y que representa todas las tarjetas de la baraja; y una matriz `order` local que tiene el mismo número de elementos que la `deck` matriz y se rellena con valores generados Double de forma aleatoria.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. A continuación, se llama al `deck` `order` Array.Sort(Array, Array) método para ordenar la matriz en función de los valores de la matriz.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
``````

## Notas a los desarrolladores de herederos

En el .NET Framework 1,0 y 1,1, una implementación mínima de una clase derivada de Random required reemplaza Sample() el método para definir un algoritmo nuevo o modificado para generar números aleatorios.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. La clase derivada podría basarse en la implementación de la clase base Next()de Next(Int32)los Next(Int32, Int32)métodos NextBytes(Byte[]),, NextDouble() , y para llamar a la implementación de la Sample() clase derivada del método.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.

En el .NET Framework 2,0 y versiones posteriores, el comportamiento de Next()los Next(Int32, Int32)métodos, NextBytes(Byte[]) y ha cambiado para que estos métodos no llamen Sample() necesariamente a la implementación de la clase derivada del método.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. Como resultado, las clases derivadas Random de que tienen como destino el .NET Framework 2,0 y versiones posteriores también deberían invalidar estos tres métodos.As a result, classes derived from Random that target the .NET Framework 2.0 and later should also override these three methods.

## Notas a los autores de las llamadas

No se garantiza que la implementación del generador de Random números aleatorios de la clase siga siendo la misma en las versiones principales del .NET Framework.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. Como resultado, no debe suponer que el mismo inicialización dará lugar a la misma secuencia pseudoaleatorios en diferentes versiones del .NET Framework.As a result, you shouldn't assume that the same seed will result in the same pseudo-random sequence in different versions of the .NET Framework.

## Constructores

 Random() Random() Random() Random() Inicializa una nueva instancia de la clase Random mediante un valor de inicialización predeterminado que depende del tiempo.Initializes a new instance of the Random class, using a time-dependent default seed value. Random(Int32) Random(Int32) Random(Int32) Random(Int32) Inicializa una nueva instancia de la clase Random utilizando el valor de inicialización especificado.Initializes a new instance of the Random class, using the specified seed value.

## Métodos

 Equals(Object) Equals(Object) Equals(Object) Equals(Object) Determina si el objeto especificado es igual al objeto actual.Determines whether the specified object is equal to the current object. (Inherited from Object) GetHashCode() GetHashCode() GetHashCode() GetHashCode() Sirve como la función hash predeterminada.Serves as the default hash function. (Inherited from Object) GetType() GetType() GetType() GetType() Obtiene el Type de la instancia actual.Gets the Type of the current instance. (Inherited from Object) MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone() Crea una copia superficial del objeto Object actual.Creates a shallow copy of the current Object. (Inherited from Object) Next() Next() Next() Next() Devuelve un entero aleatorio no negativo.Returns a non-negative random integer. Next(Int32) Next(Int32) Next(Int32) Next(Int32) Devuelve un entero aleatorio no negativo que es inferior al máximo especificado.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) Devuelve un entero aleatorio que está dentro de un intervalo especificado.Returns a random integer that is within a specified range. NextBytes(Byte[]) NextBytes(Byte[]) NextBytes(Byte[]) NextBytes(Byte[]) Rellena con números aleatorios los elementos de una matriz de bytes especificada.Fills the elements of a specified array of bytes with random numbers. NextBytes(Span) NextBytes(Span) NextBytes(Span) NextBytes(Span) NextDouble() NextDouble() NextDouble() NextDouble() Devuelve un número de punto flotante aleatorio que es mayor o igual que 0,0 y menor que 1,0.Returns a random floating-point number that is greater than or equal to 0.0, and less than 1.0. Sample() Sample() Sample() Sample() Devuelve un número de punto flotante aleatorio entre 0,0 y 1,0.Returns a random floating-point number between 0.0 and 1.0. ToString() ToString() ToString() ToString() Devuelve una cadena que representa el objeto actual.Returns a string that represents the current object. (Inherited from Object)