# Random.NextRandom.NextRandom.NextRandom.Next Method

## Definición

Devuelve un entero aleatorio.Returns a random integer.

## Sobrecargas

 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.

## Next()Next()Next()Next()

Devuelve un entero aleatorio no negativo.Returns a non-negative random integer.

``````public:
virtual int Next();``````
``public virtual int Next ();``
``````abstract member Next : unit -> int
override this.Next : unit -> int``````
``Public Overridable Function Next () As Integer``

#### Devoluciones

Número entero de 32 bits con signo mayor o igual que 0 y menor que MaxValue.A 32-bit signed integer that is greater than or equal to 0 and less than MaxValue.

### Ejemplos

En el ejemplo siguiente se realizan llamadas repetidas al Next método para generar un número específico de números aleatorios solicitados por el usuario.The following example makes repeated calls to the Next method to generate a specific number of random numbers requested by the user. El Console.ReadLine método se usa para obtener la entrada del cliente.The Console.ReadLine method is used to get customer input.

``````using namespace System;

void main()
{
Console::Write("Number of random numbers to generate: ");
unsigned int numbers = 0;
Random^ rnd = gcnew Random();

if (! UInt32::TryParse(line, numbers))
numbers = 10;

for (unsigned int ctr = 1; ctr <= numbers; ctr++)
Console::WriteLine("{0,15:N0}", rnd->Next());
}
// The example displays output like the following when asked to generate
// 15 random numbers:
//       Number of random numbers to generate: 15
//         1,733,189,596
//           566,518,090
//         1,166,108,546
//         1,931,426,514
//         1,341,108,291
//         1,012,698,049
//           890,578,409
//         1,377,589,722
//         2,108,384,181
//         1,532,939,448
//           762,207,767
//           815,074,920
//         1,521,208,785
//         1,950,436,671
//         1,266,596,666
``````
``````using System;

public class Example
{
public static void Main()
{
Console.Write("Number of random numbers to generate: ");
uint numbers = 0;
Random rnd = new Random();

if (! UInt32.TryParse(line, out numbers))
numbers = 10;

for (uint ctr = 1; ctr <= numbers; ctr++)
Console.WriteLine("{0,15:N0}", rnd.Next());
}
}
// The example displays output like the following when asked to generate
// 15 random numbers:
//       Number of random numbers to generate: 15
//         1,733,189,596
//           566,518,090
//         1,166,108,546
//         1,931,426,514
//         1,341,108,291
//         1,012,698,049
//           890,578,409
//         1,377,589,722
//         2,108,384,181
//         1,532,939,448
//           762,207,767
//           815,074,920
//         1,521,208,785
//         1,950,436,671
//         1,266,596,666
``````
``````Module Example
Public Sub Main()
Console.Write("Number of random numbers to generate: ")
Dim line As String = Console.ReadLine()
Dim numbers As UInteger = 0
Dim rnd As New Random()

If Not UInt32.TryParse(line, numbers) Then numbers = 10

For ctr As UInteger = 1 To numbers
Console.WriteLine("{0,15:N0}", rnd.Next())
Next
End Sub
End Module
' The example displays output like the following when asked to generate
' 15 random numbers:
'       Number of random numbers to generate: 15
'         1,733,189,596
'           566,518,090
'         1,166,108,546
'         1,931,426,514
'         1,341,108,291
'         1,012,698,049
'           890,578,409
'         1,377,589,722
'         2,108,384,181
'         1,532,939,448
'           762,207,767
'           815,074,920
'         1,521,208,785
'         1,950,436,671
'         1,266,596,666
``````

En el ejemplo siguiente se deriva una clase Random de para generar una secuencia de números aleatorios cuya distribución difiere de la distribución uniforme generada por el Sample método de la clase base.The following example derives a class from Random to generate a sequence of random numbers whose distribution differs from the uniform distribution generated by the Sample method of the base class. Invalida el Sample método para proporcionar la distribución de números aleatorios e invalida el Random.Next método para utilizar series de números aleatorios.It overrides the Sample method to provide the distribution of random numbers, and overrides the Random.Next method to use series of random numbers.

``````using namespace System;

// This derived class converts the uniformly distributed random
// numbers generated by base.Sample( ) to another distribution.
public ref class RandomProportional : Random
{
// The Sample method generates a distribution proportional to the value
// of the random numbers, in the range [0.0, 1.0].
protected:
virtual double Sample() override
{
return Math::Sqrt(Random::Sample());
}

public:
RandomProportional()
{}

virtual int Next() override
{
return (int) (Sample() * Int32::MaxValue);
}
};

int main(array<System::String ^> ^args)
{
const int rows = 4, cols = 6;
const int runCount = 1000000;
const int distGroupCount = 10;
const double intGroupSize =
( (double) Int32::MaxValue + 1.0 ) / (double)distGroupCount;

RandomProportional ^randObj = gcnew RandomProportional();

array<int>^ intCounts = gcnew array<int>(distGroupCount);
array<int>^ realCounts = gcnew array<int>(distGroupCount);

Console::WriteLine(
"\nThe derived RandomProportional class overrides " +
"the Sample method to \ngenerate random numbers " +
"in the range [0.0, 1.0]. The distribution \nof " +
"the numbers is proportional to their numeric values. " +
"For example, \nnumbers are generated in the " +
"vicinity of 0.75 with three times the \n" +
"probability of those generated near 0.25." );
Console::WriteLine(
"\nRandom doubles generated with the NextDouble( ) " +
"method:\n" );

// Generate and display [rows * cols] random doubles.
for( int i = 0; i < rows; i++ )
{
for( int j = 0; j < cols; j++ )
Console::Write( "{0,12:F8}", randObj->NextDouble( ) );
Console::WriteLine( );
}

Console::WriteLine(
"\nRandom integers generated with the Next( ) " +
"method:\n" );

// Generate and display [rows * cols] random integers.
for( int i = 0; i < rows; i++ )
{
for( int j = 0; j < cols; j++ )
Console::Write( "{0,12}", randObj->Next( ) );
Console::WriteLine( );
}

Console::WriteLine(
"\nTo demonstrate the proportional distribution, " +
"{0:N0} random \nintegers and doubles are grouped " +
"into {1} equal value ranges. This \n" +
"is the count of values in each range:\n",
runCount, distGroupCount );
Console::WriteLine(
"{0,21}{1,10}{2,20}{3,10}", "Integer Range",
"Count", "Double Range", "Count" );
Console::WriteLine(
"{0,21}{1,10}{2,20}{3,10}", "-------------",
"-----", "------------", "-----" );

// Generate random integers and doubles, and then count
// them by group.
for( int i = 0; i < runCount; i++ )
{
intCounts[ (int)( (double)randObj->Next( ) /
intGroupSize ) ]++;
realCounts[ (int)( randObj->NextDouble( ) *
(double)distGroupCount ) ]++;
}

// Display the count of each group.
for( int i = 0; i < distGroupCount; i++ )
Console::WriteLine(
"{0,10}-{1,10}{2,10:N0}{3,12:N5}-{4,7:N5}{5,10:N0}",
(int)( (double)i * intGroupSize ),
(int)( (double)( i + 1 ) * intGroupSize - 1.0 ),
intCounts[ i ],
( (double)i ) / (double)distGroupCount,
( (double)( i + 1 ) ) / (double)distGroupCount,
realCounts[ i ] );
return 0;
}

/*
This example of Random.Sample() displays the following output:

The derived RandomProportional class overrides the Sample method to
generate random numbers in the range [0.0, 1.0). The distribution
of the numbers is proportional to the number values. For example,
numbers are generated in the vicinity of 0.75 with three times the
probability of those generated near 0.25.

Random doubles generated with the NextDouble( ) method:

0.59455719  0.17589882  0.83134398  0.35795862  0.91467727  0.54022658
0.93716947  0.54817519  0.94685080  0.93705478  0.18582318  0.71272428
0.77708682  0.95386216  0.70412393  0.86099417  0.08275804  0.79108316
0.71019941  0.84205103  0.41685082  0.58186880  0.89492302  0.73067715

Random integers generated with the Next( ) method:

1570755704  1279192549  1747627711  1705700211  1372759203  1849655615
2046235980  1210843924  1554274149  1307936697  1480207570  1057595022
337854215   844109928  2028310798  1386669369  2073517658  1291729809
1537248240  1454198019  1934863511  1640004334  2032620207   534654791

To demonstrate the proportional distribution, 1,000,000 random
integers and doubles are grouped into 10 equal value ranges. This
is the count of values in each range:

Integer Range     Count        Double Range     Count
-------------     -----        ------------     -----
0- 214748363    10,079     0.00000-0.10000    10,148
214748364- 429496728    29,835     0.10000-0.20000    29,849
429496729- 644245093    49,753     0.20000-0.30000    49,948
644245094- 858993458    70,325     0.30000-0.40000    69,656
858993459-1073741823    89,906     0.40000-0.50000    90,337
1073741824-1288490187   109,868     0.50000-0.60000   110,225
1288490188-1503238552   130,388     0.60000-0.70000   129,986
1503238553-1717986917   149,231     0.70000-0.80000   150,428
1717986918-1932735282   170,234     0.80000-0.90000   169,610
1932735283-2147483647   190,381     0.90000-1.00000   189,813
*/
``````
``````using System;

// This derived class converts the uniformly distributed random
// numbers generated by base.Sample( ) to another distribution.
public class RandomProportional : Random
{
// The Sample method generates a distribution proportional to the value
// of the random numbers, in the range [0.0, 1.0].
protected override double Sample( )
{
return Math.Sqrt( base.Sample( ) );
}

public override int Next()
{
return (int) (Sample() * int.MaxValue);
}
}

public class RandomSampleDemo
{
static void Main( )
{
const int rows = 4, cols = 6;
const int runCount = 1000000;
const int distGroupCount = 10;
const double intGroupSize =
( (double)int.MaxValue + 1.0 ) / (double)distGroupCount;

RandomProportional randObj = new RandomProportional( );

int[ ]      intCounts = new int[ distGroupCount ];
int[ ]      realCounts = new int[ distGroupCount ];

Console.WriteLine(
"\nThe derived RandomProportional class overrides " +
"the Sample method to \ngenerate random numbers " +
"in the range [0.0, 1.0]. The distribution \nof " +
"the numbers is proportional to their numeric values. " +
"For example, \nnumbers are generated in the " +
"vicinity of 0.75 with three times the \n" +
"probability of those generated near 0.25." );
Console.WriteLine(
"\nRandom doubles generated with the NextDouble( ) " +
"method:\n" );

// Generate and display [rows * cols] random doubles.
for( int i = 0; i < rows; i++ )
{
for( int j = 0; j < cols; j++ )
Console.Write( "{0,12:F8}", randObj.NextDouble( ) );
Console.WriteLine( );
}

Console.WriteLine(
"\nRandom integers generated with the Next( ) " +
"method:\n" );

// Generate and display [rows * cols] random integers.
for( int i = 0; i < rows; i++ )
{
for( int j = 0; j < cols; j++ )
Console.Write( "{0,12}", randObj.Next( ) );
Console.WriteLine( );
}

Console.WriteLine(
"\nTo demonstrate the proportional distribution, " +
"{0:N0} random \nintegers and doubles are grouped " +
"into {1} equal value ranges. This \n" +
"is the count of values in each range:\n",
runCount, distGroupCount );
Console.WriteLine(
"{0,21}{1,10}{2,20}{3,10}", "Integer Range",
"Count", "Double Range", "Count" );
Console.WriteLine(
"{0,21}{1,10}{2,20}{3,10}", "-------------",
"-----", "------------", "-----" );

// Generate random integers and doubles, and then count
// them by group.
for( int i = 0; i < runCount; i++ )
{
intCounts[ (int)( (double)randObj.Next( ) /
intGroupSize ) ]++;
realCounts[ (int)( randObj.NextDouble( ) *
(double)distGroupCount ) ]++;
}

// Display the count of each group.
for( int i = 0; i < distGroupCount; i++ )
Console.WriteLine(
"{0,10}-{1,10}{2,10:N0}{3,12:N5}-{4,7:N5}{5,10:N0}",
(int)( (double)i * intGroupSize ),
(int)( (double)( i + 1 ) * intGroupSize - 1.0 ),
intCounts[ i ],
( (double)i ) / (double)distGroupCount,
( (double)( i + 1 ) ) / (double)distGroupCount,
realCounts[ i ] );
}
}

/*
This example of Random.Sample() displays the following output:

The derived RandomProportional class overrides the Sample method to
generate random numbers in the range [0.0, 1.0). The distribution
of the numbers is proportional to the number values. For example,
numbers are generated in the vicinity of 0.75 with three times the
probability of those generated near 0.25.

Random doubles generated with the NextDouble( ) method:

0.59455719  0.17589882  0.83134398  0.35795862  0.91467727  0.54022658
0.93716947  0.54817519  0.94685080  0.93705478  0.18582318  0.71272428
0.77708682  0.95386216  0.70412393  0.86099417  0.08275804  0.79108316
0.71019941  0.84205103  0.41685082  0.58186880  0.89492302  0.73067715

Random integers generated with the Next( ) method:

1570755704  1279192549  1747627711  1705700211  1372759203  1849655615
2046235980  1210843924  1554274149  1307936697  1480207570  1057595022
337854215   844109928  2028310798  1386669369  2073517658  1291729809
1537248240  1454198019  1934863511  1640004334  2032620207   534654791

To demonstrate the proportional distribution, 1,000,000 random
integers and doubles are grouped into 10 equal value ranges. This
is the count of values in each range:

Integer Range     Count        Double Range     Count
-------------     -----        ------------     -----
0- 214748363    10,079     0.00000-0.10000    10,148
214748364- 429496728    29,835     0.10000-0.20000    29,849
429496729- 644245093    49,753     0.20000-0.30000    49,948
644245094- 858993458    70,325     0.30000-0.40000    69,656
858993459-1073741823    89,906     0.40000-0.50000    90,337
1073741824-1288490187   109,868     0.50000-0.60000   110,225
1288490188-1503238552   130,388     0.60000-0.70000   129,986
1503238553-1717986917   149,231     0.70000-0.80000   150,428
1717986918-1932735282   170,234     0.80000-0.90000   169,610
1932735283-2147483647   190,381     0.90000-1.00000   189,813
*/
``````
``````' This derived class converts the uniformly distributed random
' numbers generated by base.Sample( ) to another distribution.
Public Class RandomProportional
Inherits Random

' The Sample method generates a distribution proportional to the value
' of the random numbers, in the range [0.0, 1.0].
Protected Overrides Function Sample( ) As Double
Return Math.Sqrt( MyBase.Sample( ) )
End Function

Public Overrides Function [Next]() As Integer
Return Sample() * Integer.MaxValue
End Function
End Class

Module RandomSampleDemo
Sub Main( )
Const rows As Integer = 4, cols As Integer = 6
Const runCount As Integer = 1000000
Const distGroupCount As Integer = 10
Const intGroupSize As Double = _
( CDbl( Integer.MaxValue ) + 1.0 ) / _
CDbl( distGroupCount )

Dim randObj As New RandomProportional( )

Dim intCounts( distGroupCount ) As Integer
Dim realCounts( distGroupCount ) As Integer
Dim i As Integer, j As Integer

Console.WriteLine( vbCrLf & _
"The derived RandomProportional class overrides " & _
"the Sample method to " & vbCrLf & _
"generate random numbers in the range " & _
"[0.0, 1.0]. The distribution " & vbCrLf & _
"of the numbers is proportional to their numeric " & _
"values. For example, " & vbCrLf & _
"numbers are generated in the vicinity of 0.75 " & _
"with three times " & vbCrLf & "the " & _
"probability of those generated near 0.25." )
Console.WriteLine( vbCrLf & _
"Random doubles generated with the NextDouble( ) " & _
"method:" & vbCrLf )

' Generate and display [rows * cols] random doubles.
For i = 0 To rows - 1
For j = 0 To cols - 1
Console.Write( "{0,12:F8}", randObj.NextDouble( ) )
Next j
Console.WriteLine( )
Next i

Console.WriteLine( vbCrLf & _
"Random integers generated with the Next( ) " & _
"method:" & vbCrLf )

' Generate and display [rows * cols] random integers.
For i = 0 To rows - 1
For j = 0 To cols - 1
Console.Write( "{0,12}", randObj.Next( ) )
Next j
Console.WriteLine( )
Next i

Console.WriteLine( vbCrLf & _
"To demonstrate the proportional distribution, " & _
"{0:N0} random " & vbCrLf & _
"integers and doubles are grouped into {1} " & _
"equal value ranges. This " & vbCrLf & _
"is the count of values in each range:" & vbCrLf, _
runCount, distGroupCount )
Console.WriteLine( "{0,21}{1,10}{2,20}{3,10}", _
"Integer Range", "Count", "Double Range", "Count" )
Console.WriteLine( "{0,21}{1,10}{2,20}{3,10}", _
"-------------", "-----", "------------", "-----" )

' Generate random integers and doubles, and then count
' them by group.
For i = 0 To runCount - 1
intCounts( Fix( CDbl( randObj.Next( ) ) / _
intGroupSize ) ) += 1
realCounts( Fix( randObj.NextDouble( ) * _
CDbl( distGroupCount ) ) ) += 1
Next i

' Display the count of each group.
For i = 0 To distGroupCount - 1
Console.WriteLine( _
"{0,10}-{1,10}{2,10:N0}{3,12:N5}-{4,7:N5}{5,10:N0}", _
Fix( CDbl( i ) * intGroupSize ), _
Fix( CDbl( i + 1 ) * intGroupSize - 1.0 ), _
intCounts( i ), _
CDbl( i ) / CDbl( distGroupCount), _
CDbl( i + 1 ) / CDbl( distGroupCount ), _
realCounts( i ) )
Next i
End Sub
End Module
' This example of Random.Sample() generates the following output:
'    The derived RandomProportional class overrides the Sample method to
'    generate random numbers in the range [0.0, 1.0]. The distribution
'    of the numbers is proportional to their numeric values. For example,
'    numbers are generated in the vicinity of 0.75 with three times
'    the probability of those generated near 0.25.
'
'    Random doubles generated with the NextDouble( ) method:
'
'      0.28377004  0.75920598  0.33430371  0.66720626  0.97080243  0.27353772
'      0.17787962  0.54618410  0.08145080  0.56286100  0.99002910  0.64898614
'      0.27673277  0.99455281  0.93778966  0.76162002  0.70533771  0.44375798
'      0.55939883  0.87383136  0.66465779  0.77392566  0.42393411  0.82409159
'
'    Random integers generated with the Next( ) method:
'
'      1364479914  1230312341  1657373812  1526222928   988564704   700078020
'      1801013705  1541517421  1146312560   338318389  1558995993  2027260859
'       884520932  1320070465   570200106  1027684711   943035246  2088689333
'       630809089  1705728475  2140787648  2097858166  1863010875  1386804198
'
'    To demonstrate the proportional distribution, 1,000,000 random
'    integers and doubles are grouped into 10 equal value ranges. This
'    is the count of values in each range:
'
'            Integer Range     Count        Double Range     Count
'            -------------     -----        ------------     -----
'             0- 214748363     9,892     0.00000-0.10000     9,928
'     214748364- 429496728    30,341     0.10000-0.20000    30,101
'     429496729- 644245093    49,958     0.20000-0.30000    49,964
'     644245094- 858993458    70,099     0.30000-0.40000    70,213
'     858993459-1073741823    90,801     0.40000-0.50000    89,553
'    1073741824-1288490187   109,699     0.50000-0.60000   109,427
'    1288490188-1503238552   129,438     0.60000-0.70000   130,339
'    1503238553-1717986917   149,886     0.70000-0.80000   150,000
'    1717986918-1932735282   170,338     0.80000-0.90000   170,128
'    1932735283-2147483647   189,548     0.90000-1.00000   190,347
``````

### Comentarios

Random.Nextgenera un número aleatorio cuyo valor oscila entre 0 y menor que Int32.MaxValue.Random.Next generates a random number whose value ranges from 0 to less than Int32.MaxValue. Para generar un número aleatorio cuyo valor esté comprendido entre 0 y otro número positivo, use Random.Next(Int32) la sobrecarga del método.To generate a random number whose value ranges from 0 to some other positive number, use the Random.Next(Int32) method overload. Para generar un número aleatorio dentro de un intervalo diferente, utilice Random.Next(Int32, Int32) la sobrecarga del método.To generate a random number within a different range, use the Random.Next(Int32, Int32) method overload.

### Notas a los desarrolladores de herederos

A partir de la versión .NET Framework 2,0, si se deriva una clase Random de e invalidan el Sample() método, la distribución proporcionada por la implementación de Sample() la clase derivada del método no se utiliza en las llamadas a la clase base. implementación del Next() método.Starting with the .NET Framework version 2.0, if you derive a class from Random and override the Sample() method, the distribution provided by the derived class implementation of the Sample() method is not used in calls to the base class implementation of the Next() method. En su lugar, se utiliza la distribución uniforme devuelta por la clase base Random .Instead, the uniform distribution returned by the base Random class is used. Este comportamiento mejora el rendimiento general de la Random clase.This behavior improves the overall performance of the Random class. Para modificar este comportamiento y llamar Sample() al método en la clase derivada, también debe invalidar el Next() método.To modify this behavior to call the Sample() method in the derived class, you must also override the Next() method.

Consulte también:

## 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.

``````public:
virtual int Next(int maxValue);``````
``public virtual int Next (int maxValue);``
``````abstract member Next : int -> int
override this.Next : int -> int``````
``Public Overridable Function Next (maxValue As Integer) As Integer``

#### Parámetros

maxValue
Int32 Int32 Int32 Int32

Límite superior exclusivo del número aleatorio que se va a generar.The exclusive upper bound of the random number to be generated. `maxValue` debe ser mayor o igual que 0.`maxValue` must be greater than or equal to 0.

#### Devoluciones

Número entero de 32 bits con signo mayor o igual que 0 y menor que `maxValue`; es decir, dentro del intervalo de valores devueltos se incluye 0, pero no `maxValue`.A 32-bit signed integer that is greater than or equal to 0, and less than `maxValue`; that is, the range of return values ordinarily includes 0 but not `maxValue`. Pero si `maxValue` es igual a 0, se devuelve `maxValue`.However, if `maxValue` equals 0, `maxValue` is returned.

#### Excepciones

`maxValue` es menor que 0.`maxValue` is less than 0.

### Ejemplos

En el ejemplo siguiente se generan enteros aleatorios con varias sobrecargas Next del método.The following example generates random integers with various overloads of the Next method.

``````// Example of the Random::Next( ) methods.
using namespace System;

// Generate random numbers with no bounds specified.
void NoBoundsRandoms( int seed )
{
Console::WriteLine( "\nRandom object, seed = {0}, no bounds:", seed );
Random^ randObj = gcnew Random( seed );

// Generate six random integers from 0 to int.MaxValue.
for ( int j = 0; j < 6; j++ )
Console::Write(  "{0,11} ", randObj->Next() );
Console::WriteLine();
}

// Generate random numbers with an upper bound specified.
void UpperBoundRandoms( int seed, int upper )
{
Console::WriteLine( "\nRandom object, seed = {0}, upper bound = {1}:", seed, upper );
Random^ randObj = gcnew Random( seed );

// Generate six random integers from 0 to the upper bound.
for ( int j = 0; j < 6; j++ )
Console::Write(  "{0,11} ", randObj->Next( upper ) );
Console::WriteLine();
}

// Generate random numbers with both bounds specified.
void BothBoundsRandoms( int seed, int lower, int upper )
{
Console::WriteLine( "\nRandom object, seed = {0}, lower = {1}, upper = {2}:", seed, lower, upper );
Random^ randObj = gcnew Random( seed );

// Generate six random integers from the lower to
// upper bounds.
for ( int j = 0; j < 6; j++ )
Console::Write(  "{0,11} ", randObj->Next( lower, upper ) );
Console::WriteLine();
}

int main()
{
Console::WriteLine( "This example of the Random::Next( ) methods\n"
"generates the following output.\n" );
Console::WriteLine( "Create Random objects all with the same seed and "
"generate\nsequences of numbers with different "
"bounds. Note the effect\nthat the various "
"combinations of bounds have on the sequences." );
NoBoundsRandoms( 234 );
UpperBoundRandoms( 234, Int32::MaxValue );
UpperBoundRandoms( 234, 2000000000 );
UpperBoundRandoms( 234, 200000000 );
BothBoundsRandoms( 234, 0, Int32::MaxValue );
BothBoundsRandoms( 234, Int32::MinValue, Int32::MaxValue );
BothBoundsRandoms( 234, -2000000000, 2000000000 );
BothBoundsRandoms( 234, -200000000, 200000000 );
BothBoundsRandoms( 234, -2000, 2000 );
}

/*
This example of the Random::Next( ) methods
generates the following output.

Create Random objects all with the same seed and generate
sequences of numbers with different bounds. Note the effect
that the various combinations of bounds have on the sequences.

Random object, seed = 234, no bounds:
2091148258  1024955023   711273344  1081917183  1833298756   109460588

Random object, seed = 234, upper bound = 2147483647:
2091148258  1024955023   711273344  1081917183  1833298756   109460588

Random object, seed = 234, upper bound = 2000000000:
1947533580   954563751   662424922  1007613896  1707392518   101943116

Random object, seed = 234, upper bound = 200000000:
194753358    95456375    66242492   100761389   170739251    10194311

Random object, seed = 234, lower = 0, upper = 2147483647:
2091148258  1024955023   711273344  1081917183  1833298756   109460588

Random object, seed = 234, lower = -2147483648, upper = 2147483647:
2034812868   -97573602  -724936960    16350718  1519113864 -1928562472

Random object, seed = 234, lower = -2000000000, upper = 2000000000:
1895067160   -90872498  -675150156    15227793  1414785036 -1796113767

Random object, seed = 234, lower = -200000000, upper = 200000000:
189506716    -9087250   -67515016     1522779   141478503  -179611377

Random object, seed = 234, lower = -2000, upper = 2000:
1895         -91        -676          15        1414       -1797
*/
``````
``````Console.WriteLine(
"This example of the Random.Next( ) methods\n" +
"generates the following output.\n" );
Console.WriteLine(
"Create Random objects all with the same seed and " +
"generate\nsequences of numbers with different " +
"bounds. Note the effect\nthat the various " +
"combinations of bounds have on the sequences." );

NoBoundsRandoms( 234 );

UpperBoundRandoms( 234, Int32.MaxValue );
UpperBoundRandoms( 234, 2000000000 );
UpperBoundRandoms( 234, 200000000 );

BothBoundsRandoms( 234, 0, Int32.MaxValue );
BothBoundsRandoms( 234, Int32.MinValue, Int32.MaxValue );
BothBoundsRandoms( 234, -2000000000, 2000000000 );
BothBoundsRandoms( 234, -200000000, 200000000 );
BothBoundsRandoms( 234, -2000, 2000 );

// Generate random numbers with no bounds specified.
void NoBoundsRandoms( int seed )
{
Console.WriteLine(
"\nRandom object, seed = {0}, no bounds:", seed );
Random randObj = new Random( seed );

// Generate six random integers from 0 to int.MaxValue.
for( int j = 0; j < 6; j++ )
Console.Write( "{0,11} ", randObj.Next( ) );
Console.WriteLine( );
}

// Generate random numbers with an upper bound specified.
void UpperBoundRandoms( int seed, int upper )
{
Console.WriteLine(
"\nRandom object, seed = {0}, upper bound = {1}:",
seed, upper );
Random randObj = new Random( seed );

// Generate six random integers from 0 to the upper bound.
for( int j = 0; j < 6; j++ )
Console.Write( "{0,11} ", randObj.Next( upper ) );
Console.WriteLine( );
}

// Generate random numbers with both bounds specified.
void BothBoundsRandoms( int seed, int lower, int upper )
{
Console.WriteLine(
"\nRandom object, seed = {0}, lower = {1}, " +
"upper = {2}:", seed, lower, upper );
Random randObj = new Random( seed );

// Generate six random integers from the lower to
// upper bounds.
for( int j = 0; j < 6; j++ )
Console.Write( "{0,11} ",
randObj.Next( lower, upper) );
Console.WriteLine( );
}

/*
This example of the Random.Next( ) methods
generates the following output.

Create Random objects all with the same seed and generate
sequences of numbers with different bounds. Note the effect
that the various combinations of bounds have on the sequences.

Random object, seed = 234, no bounds:
2091148258  1024955023   711273344  1081917183  1833298756   109460588

Random object, seed = 234, upper bound = 2147483647:
2091148258  1024955023   711273344  1081917183  1833298756   109460588

Random object, seed = 234, upper bound = 2000000000:
1947533580   954563751   662424922  1007613896  1707392518   101943116

Random object, seed = 234, upper bound = 200000000:
194753358    95456375    66242492   100761389   170739251    10194311

Random object, seed = 234, lower = 0, upper = 2147483647:
2091148258  1024955023   711273344  1081917183  1833298756   109460588

Random object, seed = 234, lower = -2147483648, upper = 2147483647:
2034812868   -97573602  -724936960    16350718  1519113864 -1928562472

Random object, seed = 234, lower = -2000000000, upper = 2000000000:
1895067160   -90872498  -675150156    15227793  1414785036 -1796113767

Random object, seed = 234, lower = -200000000, upper = 200000000:
189506716    -9087250   -67515016     1522779   141478503  -179611377

Random object, seed = 234, lower = -2000, upper = 2000:
1895         -91        -676          15        1414       -1797
*/
``````
``````' Example of the Random.Next( ) methods.
Module  RandomNextDemo

' Generate random numbers with no bounds specified.
Sub NoBoundsRandoms( seed As Integer )

Console.WriteLine( vbCrLf & _
"Random object, seed = {0}, no bounds:", seed )
Dim randObj As New Random( seed )

' Generate six random integers from 0 to int.MaxValue.
Dim j As Integer
For j = 0 To 5
Console.Write( "{0,11} ", randObj.Next( ) )
Next j
Console.WriteLine( )
End Sub

' Generate random numbers with an upper bound specified.
Sub UpperBoundRandoms( seed As Integer, upper As Integer )

Console.WriteLine( vbCrLf & _
"Random object, seed = {0}, upper bound = {1}:", _
seed, upper )
Dim randObj As New Random( seed )

' Generate six random integers from 0 to the upper bound.
Dim j As Integer
For j = 0 To 5
Console.Write( "{0,11} ", randObj.Next( upper ) )
Next j
Console.WriteLine( )
End Sub

' Generate random numbers with both bounds specified.
Sub BothBoundsRandoms( _
seed As Integer, lower As Integer, upper As Integer )

Console.WriteLine( vbCrLf & _
"Random object, seed = {0}, lower = {1}, " & _
"upper = {2}:", seed, lower, upper )
Dim randObj As New Random( seed )

' Generate six random integers from the lower to
' upper bounds.
Dim j As Integer
For j = 0 To 5
Console.Write( "{0,11} ", _
randObj.Next( lower, upper ) )
Next j
Console.WriteLine( )
End Sub

Sub Main( )
Console.WriteLine( _
"This example of the Random.Next( ) methods" & _
vbCrLf & "generates the following output." & vbCrLf )
Console.WriteLine( _
"Create Random objects all with the same seed " & _
"and generate" & vbCrLf & "sequences of numbers " & _
"with different bounds. Note the effect " & vbCrLf & _
"that the various combinations " & _
"of bounds have on the sequences." )

NoBoundsRandoms( 234 )

UpperBoundRandoms( 234, Int32.MaxValue )
UpperBoundRandoms( 234, 2000000000 )
UpperBoundRandoms( 234, 200000000 )

BothBoundsRandoms( 234, 0, Int32.MaxValue )
BothBoundsRandoms( 234, Int32.MinValue, Int32.MaxValue )
BothBoundsRandoms( 234, -2000000000, 2000000000 )
BothBoundsRandoms( 234, -200000000, 200000000 )
BothBoundsRandoms( 234, -2000, 2000 )
End Sub
End Module

' This example of the Random.Next( ) methods
' generates the following output.
'
' Create Random objects all with the same seed and generate
' sequences of numbers with different bounds. Note the effect
' that the various combinations of bounds have on the sequences.
'
' Random object, seed = 234, no bounds:
'  2091148258  1024955023   711273344  1081917183  1833298756   109460588
'
' Random object, seed = 234, upper bound = 2147483647:
'  2091148258  1024955023   711273344  1081917183  1833298756   109460588
'
' Random object, seed = 234, upper bound = 2000000000:
'  1947533580   954563751   662424922  1007613896  1707392518   101943116
'
' Random object, seed = 234, upper bound = 200000000:
'   194753358    95456375    66242492   100761389   170739251    10194311
'
' Random object, seed = 234, lower = 0, upper = 2147483647:
'  2091148258  1024955023   711273344  1081917183  1833298756   109460588
'
' Random object, seed = 234, lower = -2147483648, upper = 2147483647:
'  2034812868   -97573602  -724936960    16350718  1519113864 -1928562472
'
' Random object, seed = 234, lower = -2000000000, upper = 2000000000:
'  1895067160   -90872498  -675150156    15227793  1414785036 -1796113767
'
' Random object, seed = 234, lower = -200000000, upper = 200000000:
'   189506716    -9087250   -67515016     1522779   141478503  -179611377
'
' Random object, seed = 234, lower = -2000, upper = 2000:
'        1895         -91        -676          15        1414       -1797
``````

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. Dado que el índice más alto de la matriz es uno menos que su longitud, el valor Array.Length de la propiedad se proporciona como `maxValue` parámetro.Because the highest index of the array is one less than its length, the value of the Array.Length property is supplied as a the `maxValue` parameter.

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

La Next(Int32) sobrecarga devuelve enteros aleatorios que van de 0 a `maxValue` -1.The Next(Int32) overload returns random integers that range from 0 to `maxValue` - 1. Sin embargo, `maxValue` si es 0, el método devuelve 0.However, if `maxValue` is 0, the method returns 0.

Consulte también:

## 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.

``````public:
virtual int Next(int minValue, int maxValue);``````
``public virtual int Next (int minValue, int maxValue);``
``````abstract member Next : int * int -> int
override this.Next : int * int -> int``````
``Public Overridable Function Next (minValue As Integer, maxValue As Integer) As Integer``

#### Parámetros

minValue
Int32 Int32 Int32 Int32

Límite inferior inclusivo del número aleatorio devuelto.The inclusive lower bound of the random number returned.

maxValue
Int32 Int32 Int32 Int32

Límite superior exclusivo del número aleatorio devuelto.The exclusive upper bound of the random number returned. `maxValue` debe ser mayor o igual que `minValue`.`maxValue` must be greater than or equal to `minValue`.

#### Devoluciones

Número entero de 32 bits con signo mayor o igual que `minValue` y menor que `maxValue`; es decir, dentro del intervalo de valores devueltos se incluye `minValue` pero no `maxValue`.A 32-bit signed integer greater than or equal to `minValue` and less than `maxValue`; that is, the range of return values includes `minValue` but not `maxValue`. Si `minValue` es igual que `maxValue`, se devuelve `minValue`.If `minValue` equals `maxValue`, `minValue` is returned.

#### Excepciones

`minValue` es mayor que `maxValue`.`minValue` is greater than `maxValue`.

### Ejemplos

En el ejemplo siguiente se Random.Next(Int32, Int32) usa el método para generar enteros aleatorios con tres intervalos distintos.The following example uses the Random.Next(Int32, Int32) method to generate random integers with three distinct ranges. Tenga en cuenta que el resultado exacto del ejemplo depende del valor de inicialización proporcionado por el sistema Random que se ha pasado al constructor de clase.Note that the exact output from the example depends on the system-supplied seed value passed to the Random class constructor.

``````using namespace System;

void main()
{
Random^ rnd = gcnew Random();

Console::WriteLine("\n20 random integers from -100 to 100:");
for (int ctr = 1; ctr <= 20; ctr++)
{
Console::Write("{0,6}", rnd->Next(-100, 101));
if (ctr % 5 == 0) Console::WriteLine();
}

Console::WriteLine("\n20 random integers from 1000 to 10000:");
for (int ctr = 1; ctr <= 20; ctr++)
{
Console::Write("{0,8}", rnd->Next(1000, 10001));
if (ctr % 5 == 0) Console::WriteLine();
}

Console::WriteLine("\n20 random integers from 1 to 10:");
for (int ctr = 1; ctr <= 20; ctr++)
{
Console::Write("{0,6}", rnd->Next(1, 11));
if (ctr % 5 == 0) Console::WriteLine();
}
}
// The example displays output similar to the following:
//       20 random integers from -100 to 100:
//           65   -95   -10    90   -35
//          -83   -16   -15   -19    41
//          -67   -93    40    12    62
//          -80   -95    67   -81   -21
//
//       20 random integers from 1000 to 10000:
//           4857    9897    4405    6606    1277
//           9238    9113    5151    8710    1187
//           2728    9746    1719    3837    3736
//           8191    6819    4923    2416    3028
//
//       20 random integers from 1 to 10:
//            9     8     5     9     9
//            9     1     2     3     8
//            1     4     8    10     5
//            9     7     9    10     5
``````
``````Random rnd = new Random();

Console.WriteLine("\n20 random integers from -100 to 100:");
for (int ctr = 1; ctr <= 20; ctr++)
{
Console.Write("{0,6}", rnd.Next(-100, 101));
if (ctr % 5 == 0) Console.WriteLine();
}

Console.WriteLine("\n20 random integers from 1000 to 10000:");
for (int ctr = 1; ctr <= 20; ctr++)
{
Console.Write("{0,8}", rnd.Next(1000, 10001));
if (ctr % 5 == 0) Console.WriteLine();
}

Console.WriteLine("\n20 random integers from 1 to 10:");
for (int ctr = 1; ctr <= 20; ctr++)
{
Console.Write("{0,6}", rnd.Next(1, 11));
if (ctr % 5 == 0) Console.WriteLine();
}

// The example displays output similar to the following:
//       20 random integers from -100 to 100:
//           65   -95   -10    90   -35
//          -83   -16   -15   -19    41
//          -67   -93    40    12    62
//          -80   -95    67   -81   -21
//
//       20 random integers from 1000 to 10000:
//           4857    9897    4405    6606    1277
//           9238    9113    5151    8710    1187
//           2728    9746    1719    3837    3736
//           8191    6819    4923    2416    3028
//
//       20 random integers from 1 to 10:
//            9     8     5     9     9
//            9     1     2     3     8
//            1     4     8    10     5
//            9     7     9    10     5
``````
``````Module Example
Public Sub Main()
Dim rnd As New Random()

Console.WriteLine("20 random integers from -100 to 100:")
For ctr As Integer = 1 To 20
Console.Write("{0,6}", rnd.Next(-100, 101))
If ctr Mod 5 = 0 Then Console.WriteLine()
Next
Console.WriteLine()

Console.WriteLine("20 random integers from 1000 to 10000:")
For ctr As Integer = 1 To 20
Console.Write("{0,8}", rnd.Next(1000, 10001))
If ctr Mod 5 = 0 Then Console.WriteLine()
Next
Console.WriteLine()

Console.WriteLine("20 random integers from 1 to 10:")
For ctr As Integer = 1 To 20
Console.Write("{0,6}", rnd.Next(1, 11))
If ctr Mod 5 = 0 Then Console.WriteLine()
Next
End Sub
End Module
' The example displays output similar to the following:
'       20 random integers from -100 to 100:
'           65   -95   -10    90   -35
'          -83   -16   -15   -19    41
'          -67   -93    40    12    62
'          -80   -95    67   -81   -21
'
'       20 random integers from 1000 to 10000:
'           4857    9897    4405    6606    1277
'           9238    9113    5151    8710    1187
'           2728    9746    1719    3837    3736
'           8191    6819    4923    2416    3028
'
'       20 random integers from 1 to 10:
'            9     8     5     9     9
'            9     1     2     3     8
'            1     4     8    10     5
'            9     7     9    10     5
``````

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. Dado que el índice más alto de la matriz es uno menos que su longitud, el valor Array.Length de la propiedad se proporciona como `maxValue` parámetro.Because the highest index of the array is one less than its length, the value of the Array.Length property is supplied as a the `maxValue` parameter.

``````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(0, malePetNames->Length);
int fIndex = rnd->Next(0, 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(0, malePetNames.Length);
int fIndex = rnd.Next(0, 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(0, malePetNames.Length)
Dim fIndex As Integer = rnd.Next(0, 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

La Next(Int32, Int32) sobrecarga devuelve enteros aleatorios que van de `minValue` a `maxValue` -1.The Next(Int32, Int32) overload returns random integers that range from `minValue` to `maxValue` - 1. Sin embargo, `maxValue` si `minValue`es igual a, el `minValue`método devuelve.However, if `maxValue` equals `minValue`, the method returns `minValue`.

A diferencia de las otras sobrecargas del Next método, que devuelven solo valores no negativos, este método puede devolver un entero aleatorio negativo.Unlike the other overloads of the Next method, which return only non-negative values, this method can return a negative random integer.

### Notas a los desarrolladores de herederos

A partir de la versión .NET Framework 2,0, si se deriva una clase Random de e invalidan el Sample() método, la distribución proporcionada por la implementación de Sample() la clase derivada del método no se utiliza en las llamadas a la clase base. implementación de la Next(Int32, Int32) sobrecarga del método si la diferencia entre `minValue` los `maxValue` parámetros y es mayor MaxValueque.Starting with the .NET Framework version 2.0, if you derive a class from Random and override the Sample() method, the distribution provided by the derived class implementation of the Sample() method is not used in calls to the base class implementation of the Next(Int32, Int32) method overload if the difference between the `minValue` and `maxValue` parameters is greater than MaxValue. En su lugar, se utiliza la distribución uniforme devuelta por la clase base Random .Instead, the uniform distribution returned by the base Random class is used. Este comportamiento mejora el rendimiento general de la Random clase.This behavior improves the overall performance of the Random class. Para modificar este comportamiento y llamar Sample() al método en la clase derivada, también debe invalidar la sobrecarga del Next(Int32, Int32) método.To modify this behavior to call the Sample() method in the derived class, you must also override the Next(Int32, Int32) method overload.

Consulte también: