Entero aleatorio en VB.NET


50

Necesito generar un entero aleatorio entre 1 y n (donde n es un número entero positivo) para usar para una prueba unitaria. No necesito algo demasiado complicado para garantizar la verdadera aleatoriedad, solo un número aleatorio anticuado.

¿Cómo podría hacer eso?

49

Para obtener un valor entero aleatorio entre 1 y N (inclusive) puede usar lo siguiente.

CInt(Math.Ceiling(Rnd() * n)) + 1 
+6

* "entre 1 y N (inclusive)" * incorrecto, devolverá un valor entre '0' y' N'. 'Math.Ceiling (0)' es '0'. 18 jul. 122012-07-18 21:09:58

+5

Rnd() puede devolver 0. Si esto sucede, incluso cuando n> 0, el resultado sería 0. Por lo tanto, esto daría un error muy desagradable, especialmente porque es muy raro. si quieres un código defectuoso, entonces usa esto. La documentación de MS dice: "La función Rnd devuelve un valor inferior a 1, pero mayor o igual que cero". http://msdn.microsoft.com/en-us/library/f7s023d2(v=vs.90).aspx 30 ene. 142014-01-30 15:10:17

+4

Intenté esto como está y me encontré con la instancia de 12 cuando uso n = 11. No inclusivo MSDN tiene mejor ejemplo: randomValue = CInt (Math.Floor ((upperbound - lowerbound + 1) * Rnd())) + lowerbound 19 dic. 142014-12-19 18:27:57


4
Public Function RandomNumber(ByVal n As Integer) As Integer 
    'initialize random number generator 
    Dim r As New Random(System.DateTime.Now.Millisecond) 
    Return r.Next(1, n) 
End Function 
+2

si quiere errores, luego use este código. MS hizo su método Next() bastante extraño. el parámetro Mín es el mínimo inclusivo como cabría esperar, pero el parámetro Máx es el máximo exclusivo que uno NO esperaría. en otras palabras, si pasa min = 1 y max = 5, sus números aleatorios serían cualquiera de 1, 2, 3 o 4, pero nunca incluiría 5. 30 ene. 142014-01-30 16:31:00

+4

@ShawnKovac Así es como se implementan la mayoría de los generadores de números aleatorios. 30 ene. 142014-01-30 17:53:28


32

Uso System.Random:

Dim MyMin As Integer = 1, MyMax As Integer = 5, My1stRandomNumber As Integer, My2ndRandomNumber As Integer 

' Create a random number generator 
Dim Generator As System.Random = New System.Random() 

' Get a random number >= MyMin and <= MyMax 
My1stRandomNumber = Generator.Next(MyMin, MyMax + 1) ' Note: Next function returns numbers _less than_ max, so pass in max + 1 to include max as a possible value 

' Get another random number (don't create a new generator, use the same one) 
My2ndRandomNumber = Generator.Next(MyMin, MyMax + 1) 
+5

Parece más simple con el retorno Nuevo aleatorio(). Siguiente (minValue, maxValue) 02 feb. 102010-02-02 10:25:35

+2

Es cierto. Sin embargo, si el usuario desea una secuencia de números aleatorios (en lugar de solo uno), querría retener la referencia aleatoria. 03 feb. 102010-02-03 00:01:01

+1

Cambia 'Dim Generator' a' Static Generator' y tienes una instancia que puedes conservar (no es segura para subprocesos, pero eso no va a importar en la mayoría de los escenarios realistas). 20 abr. 102010-04-20 18:50:54

+1

parece más simple, pero este código es completamente incorrecto. si quieres un error, utiliza este código. MS hizo su método Next() bastante extraño. el parámetro Mín es el mínimo inclusivo como cabría esperar, pero el parámetro Máx es el mínimo * exclusivo * como uno NO esperaría. en otras palabras, si pasa min = 1 y max = 5, sus números aleatorios serían cualquiera de 1, 2, 3 o 4, pero nunca incluiría 5. 30 ene. 142014-01-30 15:15:01

  0

@ShawnKovac - Buena captura. No había notado la falta de coincidencia inclusiva/exclusiva entre los parámetros mínimos y máximos de Random.Next. Muestra de código actualizada. 01 feb. 142014-02-01 19:27:29


61

Como se ha señalado muchas veces, la sugerencia de escribir código como esto es problemático:

Public Function GetRandom(ByVal Min As Integer, ByVal Max As Integer) As Integer 
    Dim Generator As System.Random = New System.Random() 
    Return Generator.Next(Min, Max) 
End Function 

La razón es que el constructor para la clase Random proporciona una inicialización predeterminada basada en el reloj del sistema. En la mayoría de los sistemas, esto tiene una granularidad limitada, en algún lugar cercano a los 20 ms. Así que si usted escribe el siguiente código, usted va a obtener el mismo número de un montón de veces consecutivas:

Dim randoms(1000) As Integer 
For i As Integer = 0 to randoms.Length - 1 
    randoms(i) = GetRandom(1, 100) 
Next 

Las siguientes direcciones de código de este problema:

Public Function GetRandom(ByVal Min As Integer, ByVal Max As Integer) As Integer 
    ' by making Generator static, we preserve the same instance ' 
    ' (i.e., do not create new instances with the same seed over and over) ' 
    ' between calls ' 
    Static Generator As System.Random = New System.Random() 
    Return Generator.Next(Min, Max) 
End Function 

me tiró juntos una programa simple usando ambos métodos para generar 25 números enteros aleatorios entre 1 y 100. Aquí está la salida:

Non-static: 70 Static: 70 
Non-static: 70 Static: 46 
Non-static: 70 Static: 58 
Non-static: 70 Static: 19 
Non-static: 70 Static: 79 
Non-static: 70 Static: 24 
Non-static: 70 Static: 14 
Non-static: 70 Static: 46 
Non-static: 70 Static: 82 
Non-static: 70 Static: 31 
Non-static: 70 Static: 25 
Non-static: 70 Static: 8 
Non-static: 70 Static: 76 
Non-static: 70 Static: 74 
Non-static: 70 Static: 84 
Non-static: 70 Static: 39 
Non-static: 70 Static: 30 
Non-static: 70 Static: 55 
Non-static: 70 Static: 49 
Non-static: 70 Static: 21 
Non-static: 70 Static: 99 
Non-static: 70 Static: 15 
Non-static: 70 Static: 83 
Non-static: 70 Static: 26 
Non-static: 70 Static: 16 
Non-static: 70 Static: 75 
  0

Creo que esto nunca generará realmente "100". es entre min y menos que MaxValue en realidad (creo) 11 abr. 122012-04-11 13:29:47

+1

@maxhodges: Sí, creo que tienes razón. Hay una desafortunada ambigüedad en la palabra "entre"; No sé si al OP le importa si 100 está incluido o no. Yo no, personalmente; mi respuesta solo pretendía ilustrar el hecho de compartir un objeto 'Aleatorio' entre múltiples llamadas a función usando la palabra clave' Estática'. 11 abr. 122012-04-11 13:56:03

  0

He descubierto que necesitaba hacer referencia a este código más de una vez. ¡Gracias! 30 jun. 132013-06-30 17:53:33

  0

le daría un +1 por la información estática, pero el código tiene errores. ¡pero felicitaciones por esa visión estática!y te hubiera dado -1 por una respuesta falsa. pero incluso salen. 30 ene. 142014-01-30 15:24:08

+3

si quiere un error, luego use este código. MS hizo su método Next() bastante extraño. el parámetro Min es el mínimo inclusivo como cabría esperar, pero el parámetro Máx es el mínimo exclusivo que uno NO esperaría. en otras palabras, si pasa min = 1 y max = 5, sus números aleatorios serían cualquiera de 1, 2, 3 o 4, pero nunca incluiría 5. 30 ene. 142014-01-30 15:24:52

+1

@ShawnKovac: puedo apreciar que puede ser sorprendente . Pero llamarlo "buggy" es un poco exagerado, en mi opinión; simplemente no era el comportamiento * que * esperabas. La verdad es que la mayoría de las implementaciones de números aleatorios (que yo sepa) funcionan de esta manera: límite inferior exclusivo, límite superior exclusivo. Puede ser conveniente en muchos casos de uso común, como seleccionar un elemento aleatorio de una matriz (donde se selecciona el elemento entre '0' y' array.length'). 30 ene. 142014-01-30 15:37:26

  0

Por ejemplo: ['Random.nextInt'] (http://docs.oracle.com/javase/7/docs/api/java/util/Random.html#nextInt (int)) en Java, [' Math. random'] (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random) en JavaScript, ['rand'] (http: //www.ruby-doc .org/core-2.1.0/Random.html # method-i-rand) en Ruby, etc. 30 ene. 142014-01-30 15:39:11

  0

gracias Dan. Aprecio esa retroalimentación. en el mejor de los casos, es incómodo, y luego veo a los programadores que piensan que "mínimo" y "máximo" tienen una similitud consistente como inclusiva y exclusiva ... sí, como lo haría yo. pero esto es humano tantos "caprichos" en la programación es por qué la programación es tan complicada como lo es. y solo necesitamos escribir un mejor código. Agradezco tus comentarios, aunque Gracias. 30 ene. 142014-01-30 16:37:05

  0

Creo que lo que yo llamaría no es caprichoso ni estrafalario, pero incluso el código de calidad es si las variables simplemente se nombraran para reflejar * claramente * qué son: incMin y excMax serían nombres cortos factibles. :) y tal vez un comentario que incMin = incluido mínimo y excMax = máximo exclusivo. 30 ene. 142014-01-30 16:37:53

  0

@dantao: agradezco mucho sus comentarios. gracias por abrir mi mente un poco más (al menos tanto como me permito verlo de otra manera). ;) He nombrado mis variables en mi 'código fijo' para que otros programadores que puedan ver mi código más tarde no se confundan si esperaran este comportamiento "peculiar" (que para mí, todavía siento que tiene errores porque es no un uso consistente de ambos parámetros que sean inclusivos o exclusivos). mi método usa límites inclusivos para ambos parámetros, lo que también permite el rango máximo y completo de un int como resultado, que es como creo que debería codificarse. 30 ene. 142014-01-30 16:47:38

  0

@ShawnKovac: No estás solo. Python ['random.randint'] (http://docs.python.org/2/library/random.html#random.randint), por ejemplo, es inclusivo en ambos extremos. Y estoy de acuerdo con usted en que los nombres de variables 'min' y' max' deberían ser más explícitos (de hecho, ¡puede ver que menciono la ambigüedad en mi comentario anterior de abril de 2012!). Supongo que una de las preguntas más complicadas al diseñar una interfaz es esta: ¿intentas hacerla intuitiva "en el vacío", o recurres a las expectativas de los desarrolladores de lo que ha venido antes? 30 ene. 142014-01-30 16:52:11

  0

@ShawnKovac: indexación de matriz basada en 0 es un ejemplo perfecto. Podría decirse que no es "intuitivo" (para algunos, al menos al principio), pero está tan extendido que ahora, si crearas un nuevo lenguaje que utilizara indexación basada en 1, en realidad * sorprenderías * a muchos desarrolladores. Entonces lo no intuitivo puede volverse intuitivo en base a la experiencia previa. Mi sensación con 'Random.Next' en .NET es que está en algún lugar en un área gris. Muchos desarrolladores (como tú) seguramente lo sorprenden, pero creo que también hay algunos que esperan exactamente el comportamiento que tiene. 30 ene. 142014-01-30 16:54:48

  0

sí, entiendo el catering para el uso inverso. es gracioso, estaba pensando en el índice máximo de VB cuando declarar una matriz es contrario a la intuición debido a la declaración de estilo C 'esperada', que es muy común. pero tienes razón, la imagen más grande es todo el problema de indexación de 0. tienes mucha razón. ahora estamos acostumbrados y sería más incómodo usar indexación basada en 1 ... ahora que estoy acostumbrado. que creo que es tu punto exacto. gracias por esos puntos y compartir tu sabiduría! El método Instr() de VB es un buen ejemplo también con la indexación basada en 1. Bueno, supongo que una cosa es cambiar con el tiempo. :) 30 ene. 142014-01-30 17:01:53

  0

Modifiqué la función de la siguiente manera: Función pública GetRandom (ByVal Min como entero, ByVal Max como entero) Como entero 'al hacer generador estático, conservamos la misma instancia' '(es decir, no crear nuevo instancias con la misma semilla una y otra vez) ' ' entre llamadas ' generador estático como System.Random = New System.Random() Dim Resultado como entero = generador.Siguiente (Mín., Máx.) si Resultado = Máx. Luego resultado - = 1 Fin Función Luego paso 1 más que el máximo que deseo (por ejemplo, si quiero un máximo de 255, paso 256 como máximo). 24 nov. 162016-11-24 17:40:16


-5
Function xrand() As Long 
     Dim r1 As Long = Now.Day & Now.Month & Now.Year & Now.Hour & Now.Minute & Now.Second & Now.Millisecond 
     Dim RAND As Long = Math.Max(r1, r1 * 2) 
     Return RAND 
End Function 

[BBOYSE] Esta es la mejor manera, a partir de cero: P

+3

esto es horrible. no es aleatorio en absoluto. es solo un número precalculado basado en el tiempo. esto no mostraría ninguna propiedad de un número aleatorio. Además, no responde la pregunta. la pregunta no era cómo generar ningún número aleatorio sino uno entre 1 y un valor dado. 30 ene. 142014-01-30 15:33:20


1

Si está utilizando la respuesta de José, que es una gran respuesta, y éstos se ejecutan espalda con espalda de esta manera:

dim i = GetRandom(1, 1715) 
dim o = GetRandom(1, 1715) 

A continuación, el El resultado podría repetirse una y otra vez porque procesa la llamada tan rápido. Esto puede no haber sido un problema en '08, pero dado que los procesadores son mucho más rápidos hoy en día, la función no permite que el reloj del sistema tenga tiempo suficiente para cambiar antes de hacer la segunda llamada.

Dado que la función System.Random() se basa en el reloj del sistema, debemos dejar suficiente tiempo para que cambie antes de la próxima llamada. Una forma de lograr esto es pausar el hilo actual durante 1 milisegundo. Vea el siguiente ejemplo:

Public Function GetRandom(ByVal min as Integer, ByVal max as Integer) as Integer 
    Static staticRandomGenerator As New System.Random 
    max += 1 
    Return staticRandomGenerator.Next(If(min > max, max, min), If(min > max, min, max)) 
End Function 
+2

si quiere un error, luego use este código. MS hizo su método Next() bastante extraño. el parámetro Min es el mínimo inclusivo como cabría esperar, pero el parámetro Máx es el mínimo exclusivo que uno NO esperaría. en otras palabras, si pasa min = 1 y max = 5, sus números aleatorios serían cualquiera de 1, 2, 3 o 4, pero nunca incluiría 5. 30 ene. 142014-01-30 15:26:35

  0

@ShawnKovac Gracias por informarme sobre el .Siguiente la función no devuelve el número máximo y el uso del objeto static.random estático (aunque el nombre Min y Max probablemente ya no sean apropiados ya que ahora es solo un rango: A a B). Hice una prueba, y el rendimiento de los dos es igual. Además, uso entero en lugar de int32 porque actualmente está vinculado a int32 (que los hace casi iguales) y dado que trabajo mucho en SQL, me gusta la sintaxis y no me importa escribir la 'e' antes que mi ' lengüeta.' (Para cada uno su propio.) ~ Cheers 21 mar. 142014-03-21 19:16:04

  0

gracias por preocuparse por corregir su código. estás mucho más allá de muchas otras personas en eso. Sí, Int32 e Integer producen el mismo efecto, hasta donde yo sé, exactamente lo mismo. Excepto para mí, Int32 es más claro, para las personas que no saben qué tamaño de Entero es un 'Ingeger'. Esa es la razón principal por la que uso Int32. Pero entiendo que es totalmente una cuestión de preferencia. 27 mar. 142014-03-27 16:06:56

  0

También me gusta el alias más corto de Int32, y sí, con intellisence el tipeo es casi igual. Pero me gusta la lectura más compacta también. Pero cuando codigo C#, todavía me gusta usar el Int32 más específico en lugar de su 'int' aún más corta en caso de que los novatos estén mirando mi código, por el bien de la claridad de los demás. Pero a cada cual lo suyo. :) 27 mar. 142014-03-27 16:08:35

  0

Solo quiero señalar que su código se ejecutará o lanzará un error si su max = Integer.MaxValue. Por supuesto, esto generalmente no importará, pero si quiere eliminar ese problema potencial, puede ver mi respuesta en la que proporcioné una solución para obtener el rango completo de Int aleatorio, si el usuario desea incluir Integer.MaxValue. Desafortunadamente, Microsoft simplemente no hizo que fuera fácil tener un código muy robusto para esto cuando implementaron lo que llamo una función aleatoria extremadamente peculiar. Código realmente robusto es difícil de encontrar. :( 27 mar. 142014-03-27 16:11:52


5

Todas las respuestas hasta ahora tienen problemas o errores (en plural, no solo uno). Lo explicaré. Pero primero quiero complementar la idea de Dan Tao de usar una variable estática para recordar la variable Generador, por lo que llamarla varias veces no repetirá el mismo # una y otra vez, además de que me dio una explicación muy buena. Pero su código sufrió el mismo defecto que la mayoría de los demás, como explico ahora.

MS hicieron su método Next() bastante extraño. el parámetro Mín es el mínimo inclusivo como cabría esperar, pero el parámetro Máx es el máximo exclusivo máximo como uno NO esperaría. en otras palabras, si pasa min = 1 y max = 5, sus números aleatorios serían cualquiera de 1, 2, 3 o 4, pero nunca incluiría 5.Este es el primero de dos posibles errores en todo el código que usa el método Random.Next() de Microsoft.

Para un simple respuesta (pero aún con otros problemas posibles, pero raras) entonces que había necesidad de usar:

Private Function GenRandomInt(min As Int32, max As Int32) As Int32 
    Static staticRandomGenerator As New System.Random 
    Return staticRandomGenerator.Next(min, max + 1) 
End Function 

(me gusta usar Int32 en lugar de Integer porque hace que sea más clara qué tan grande es la int, además es más corta de escribir, pero se adapta a ti).

Veo dos posibles problemas con este método, pero será adecuado (y correcto) para la mayoría de los usos. Entonces, si quiere una solución simple, creo que esto es correcto.

Los únicos 2 problemas que veo con esta función son: 1: cuando Máx = Int32.MaxValue por lo que agregar 1 crea un desbordamiento numérico. aunque, esto sería raro, todavía es una posibilidad. 2: cuando min> max + 1. cuando min = 10 y max = 5, la función Next arroja un error. esto puede ser lo que quieras. pero puede no ser tampoco. o considerar cuando min = 5 y max = 4. agregando 1, 5 pasa al método Next, pero no arroja un error, cuando realmente es un error, pero el código de Microsoft .NET que probé devuelve 5. entonces realmente no es un máximo 'exclusivo' cuando el máximo = el mínimo. pero cuando max < min para la función Random.Next(), arroja una ArgumentOutOfRangeException. por lo que la implementación de Microsoft es realmente inconsistente y con errores también en este sentido.

es posible que desee simplemente intercambiar los números cuando min> max para que no se produzca ningún error, pero depende totalmente de lo que se desee. si desea un error en los valores no válidos, entonces es probable que también arroje el error cuando el máximo exclusivo de Microsoft (máximo + 1) en nuestro código es igual al mínimo, donde MS falla al error en este caso.

manejando una solución temporal para cuando max = Int32.MaxValue es un poco incómodo, pero espero publicar una función completa que maneje ambas situaciones. y si quieres un comportamiento diferente de como lo codifiqué, únete a ti mismo. pero tenga en cuenta estos 2 problemas.

Happy coding!

Edit: Así que necesitaba un generador de enteros aleatorio, y decidí codificarlo 'a la derecha'. Entonces, si alguien quiere la funcionalidad completa, aquí hay una que realmente funciona. (Pero no gana el premio más simple con sólo 2 líneas de código, pero en realidad no es compleja, ya sea..)

''' <summary> 
''' Generates a random Integer with any (inclusive) minimum or (inclusive) maximum values, with full range of Int32 values. 
''' </summary> 
''' <param name="inMin">Inclusive Minimum value. Lowest possible return value.</param> 
''' <param name="inMax">Inclusive Maximum value. Highest possible return value.</param> 
''' <returns></returns> 
''' <remarks></remarks> 
Private Function GenRandomInt(inMin As Int32, inMax As Int32) As Int32 
    Static staticRandomGenerator As New System.Random 
    If inMin > inMax Then Dim t = inMin : inMin = inMax : inMax = t 
    If inMax < Int32.MaxValue Then Return staticRandomGenerator.Next(inMin, inMax + 1) 
    ' now max = Int32.MaxValue, so we need to work around Microsoft's quirk of an exclusive max parameter. 
    If inMin > Int32.MinValue Then Return staticRandomGenerator.Next(inMin - 1, inMax) + 1 ' okay, this was the easy one. 
    ' now min and max give full range of integer, but Random.Next() does not give us an option for the full range of integer. 
    ' so we need to use Random.NextBytes() to give us 4 random bytes, then convert that to our random int. 
    Dim bytes(3) As Byte ' 4 bytes, 0 to 3 
    staticRandomGenerator.NextBytes(bytes) ' 4 random bytes 
    Return BitConverter.ToInt32(bytes, 0) ' return bytes converted to a random Int32 
End Function 
+1

Tonterías completas. Como dijo Bill, el comportamiento de 'Next()' es completamente normal, no "bastante extraño". 17 sep. 152015-09-17 14:39:59

  0

Para ser justos, tan "normal" como podría ser para las funciones incorporadas de varios lenguajes de programación , en realidad es bastante extraño para el resto del mundo. ¿Cuándo fue la última vez que escuchó a alguien decir que 1D6 le da un número entre 1 y 7? Para cualquiera que no haya leído cuidadosamente la documentación del idioma y no esté familiarizado con el comportamiento extraño de las funciones de RNG, podrían ser una sorpresa y no saber realmente qué pasó. 28 dic. 152015-12-28 07:22:32

  0

@MichaelS, me perdiste con '1D6' dando un # entre 1 y 7. No entiendo tu 'D'. Pero también en lo que respecta a 2 cómo funciona Random.Next (min, max) de Microsoft, el programa proporciona 1 y 7 y el método arroja un # dentro del rango de 1 y 6. Así que creo que estaba un poco fuera de la exactitud exacta de su analogía (a menos que te estés refiriendo a algún otro comportamiento sin sentido. Pero si pretendía referirse a Microsoft, solo digo que su pequeña confusión es perfectamente * normal * porque lo que MS hizo no tiene sentido lógico (aparte de lo que otros han señalado: que se ha convertido en la nueva 'norma'). 29 dic. 152015-12-29 13:09:49

  0

Y simplemente estoy vocalizando un poco de lógica que es mejor utilizar lógicamente el mínimo inclusivo y el máximo inclusivo para la consistencia y rechazar la cuasi-'normidad 'que ha comenzado. Eso es todo. :) 29 dic. 152015-12-29 13:11:22

  0

1D6 significa tirar un dado de seis caras, del tipo utilizado en muchos juegos de mesa o juegos de rol de mesa. Los números van del 1 al 6, inclusive, y la gente diría "1 a 6", no "1 a 7" y supondrá que sabe que 7 no está incluido. Podría usar analogías similares de muchos otros aspectos de la vida. Si digo que una liga de béisbol es para niños entre 12 y 14 años, incluyo los 12 y los 14 años. Etc. No puedo pensar en un ejemplo práctico de excluir el límite superior de un rango fuera de una clase de matemática. 04 ene. 162016-01-04 04:57:43

  0

Bien, @MichaelS, ahora que entiendo su publicación, veo que usted y yo estamos completamente de acuerdo. Usted acaba de expresar el mismo concepto de otra manera. Buen punto.:) Gracias por la aclaración. 11 ene. 162016-01-11 17:55:29


0
Dim rnd As Random = New Random 
rnd.Next(n) 

1

Debe crear un generador de números pseudo-aleatorios sólo una vez:

Dim Generator As System.Random = New System.Random() 

Entonces, si un número entero es suficiente para sus necesidades, puede utilizar:

Public Function GetRandom(myGenerator As System.Random, ByVal Min As Integer, ByVal Max As Integer) As Integer 
'min is inclusive, max is exclusive (dah!) 
Return myGenerator.Next(Min, Max + 1) 
End Function 

tantas veces como desee. El uso de la función de envoltura se justifica solo porque el valor máximo es exclusivo: sé que los números aleatorios funcionan de esta manera, pero la definición de .Next es confusa.

Creo que crear un generador cada vez que necesita un número es incorrecto; los números pseudoaleatorios no funcionan de esta manera.

Primero, aparece el problema con la inicialización que se ha discutido en las otras respuestas.Si se inicializa una vez, no tiene este problema.

En segundo lugar, no estoy del todo seguro de que obtenga una secuencia válida de números aleatorios; más bien, obtienes una colección de la primera cantidad de múltiples secuencias diferentes que se inicializan automáticamente en función del tiempo de la computadora. No estoy seguro de que estos números pasen las pruebas que confirman la aleatoriedad de la secuencia.


1

Microsoft Ejemplo Rnd Function

https://msdn.microsoft.com/en-us/library/f7s023d2%28v=vs.90%29.aspx

1- Inicializar el generador de números aleatorios.

Randomize() 

2 - Generar valor aleatorio entre 1 y 6.

Dim value As Integer = CInt(Int((6 * Rnd()) + 1)) 

0

Sólo como referencia, VB definición Fuction NET para RND y RANDOMIZE (que debe dar los mismos resultados de BASIC (1980 años) y después de todas las versiones es:

Public NotInheritable Class VBMath 
    ' Methods 
    Private Shared Function GetTimer() As Single 
     Dim now As DateTime = DateTime.Now 
     Return CSng((((((60 * now.Hour) + now.Minute) * 60) + now.Second) + (CDbl(now.Millisecond)/1000))) 
    End Function 

    Public Shared Sub Randomize() 
     Dim timer As Single = VBMath.GetTimer 
     Dim projectData As ProjectData = ProjectData.GetProjectData 
     Dim rndSeed As Integer = projectData.m_rndSeed 
     Dim num3 As Integer = BitConverter.ToInt32(BitConverter.GetBytes(timer), 0) 
     num3 = (((num3 And &HFFFF) Xor (num3 >> &H10)) << 8) 
     rndSeed = ((rndSeed And -16776961) Or num3) 
     projectData.m_rndSeed = rndSeed 
    End Sub 

    Public Shared Sub Randomize(ByVal Number As Double) 
     Dim num2 As Integer 
     Dim projectData As ProjectData = ProjectData.GetProjectData 
     Dim rndSeed As Integer = projectData.m_rndSeed 
     If BitConverter.IsLittleEndian Then 
      num2 = BitConverter.ToInt32(BitConverter.GetBytes(Number), 4) 
     Else 
      num2 = BitConverter.ToInt32(BitConverter.GetBytes(Number), 0) 
     End If 
     num2 = (((num2 And &HFFFF) Xor (num2 >> &H10)) << 8) 
     rndSeed = ((rndSeed And -16776961) Or num2) 
     projectData.m_rndSeed = rndSeed 
    End Sub 

    Public Shared Function Rnd() As Single 
     Return VBMath.Rnd(1!) 
    End Function 

    Public Shared Function Rnd(ByVal Number As Single) As Single 
     Dim projectData As ProjectData = ProjectData.GetProjectData 
     Dim rndSeed As Integer = projectData.m_rndSeed 
     If (Number <> 0) Then 
      If (Number < 0) Then 
       Dim num1 As UInt64 = (BitConverter.ToInt32(BitConverter.GetBytes(Number), 0) And &HFFFFFFFF) 
       rndSeed = CInt(((num1 + (num1 >> &H18)) And CULng(&HFFFFFF))) 
      End If 
      rndSeed = CInt((((rndSeed * &H43FD43FD) + &HC39EC3) And &HFFFFFF)) 
     End If 
     projectData.m_rndSeed = rndSeed 
     Return (CSng(rndSeed)/1.677722E+07!) 
    End Function 

End Class 

mientras que la clase Random es:

Public Class Random 
    ' Methods 
    <__DynamicallyInvokable> _ 
    Public Sub New() 
     Me.New(Environment.TickCount) 
    End Sub 

    <__DynamicallyInvokable> _ 
    Public Sub New(ByVal Seed As Integer) 
     Me.SeedArray = New Integer(&H38 - 1) {} 
     Dim num4 As Integer = If((Seed = -2147483648), &H7FFFFFFF, Math.Abs(Seed)) 
     Dim num2 As Integer = (&H9A4EC86 - num4) 
     Me.SeedArray(&H37) = num2 
     Dim num3 As Integer = 1 
     Dim i As Integer 
     For i = 1 To &H37 - 1 
      Dim index As Integer = ((&H15 * i) Mod &H37) 
      Me.SeedArray(index) = num3 
      num3 = (num2 - num3) 
      If (num3 < 0) Then 
       num3 = (num3 + &H7FFFFFFF) 
      End If 
      num2 = Me.SeedArray(index) 
     Next i 
     Dim j As Integer 
     For j = 1 To 5 - 1 
      Dim k As Integer 
      For k = 1 To &H38 - 1 
       Me.SeedArray(k) = (Me.SeedArray(k) - Me.SeedArray((1 + ((k + 30) Mod &H37)))) 
       If (Me.SeedArray(k) < 0) Then 
        Me.SeedArray(k) = (Me.SeedArray(k) + &H7FFFFFFF) 
       End If 
      Next k 
     Next j 
     Me.inext = 0 
     Me.inextp = &H15 
     Seed = 1 
    End Sub 

    Private Function GetSampleForLargeRange() As Double 
     Dim num As Integer = Me.InternalSample 
     If ((Me.InternalSample Mod 2) = 0) Then 
      num = -num 
     End If 
     Dim num2 As Double = num 
     num2 = (num2 + 2147483646) 
     Return (num2/4294967293) 
    End Function 

    Private Function InternalSample() As Integer 
     Dim inext As Integer = Me.inext 
     Dim inextp As Integer = Me.inextp 
     If (++inext >= &H38) Then 
      inext = 1 
     End If 
     If (++inextp >= &H38) Then 
      inextp = 1 
     End If 
     Dim num As Integer = (Me.SeedArray(inext) - Me.SeedArray(inextp)) 
     If (num = &H7FFFFFFF) Then 
      num -= 1 
     End If 
     If (num < 0) Then 
      num = (num + &H7FFFFFFF) 
     End If 
     Me.SeedArray(inext) = num 
     Me.inext = inext 
     Me.inextp = inextp 
     Return num 
    End Function 

    <__DynamicallyInvokable> _ 
    Public Overridable Function [Next]() As Integer 
     Return Me.InternalSample 
    End Function 

    <__DynamicallyInvokable> _ 
    Public Overridable Function [Next](ByVal maxValue As Integer) As Integer 
     If (maxValue < 0) Then 
      Dim values As Object() = New Object() { "maxValue" } 
      Throw New ArgumentOutOfRangeException("maxValue", Environment.GetResourceString("ArgumentOutOfRange_MustBePositive", values)) 
     End If 
     Return CInt((Me.Sample * maxValue)) 
    End Function 

    <__DynamicallyInvokable> _ 
    Public Overridable Function [Next](ByVal minValue As Integer, ByVal maxValue As Integer) As Integer 
     If (minValue > maxValue) Then 
      Dim values As Object() = New Object() { "minValue", "maxValue" } 
      Throw New ArgumentOutOfRangeException("minValue", Environment.GetResourceString("Argument_MinMaxValue", values)) 
     End If 
     Dim num As Long = (maxValue - minValue) 
     If (num <= &H7FFFFFFF) Then 
      Return (CInt((Me.Sample * num)) + minValue) 
     End If 
     Return (CInt(CLng((Me.GetSampleForLargeRange * num))) + minValue) 
    End Function 

    <__DynamicallyInvokable> _ 
    Public Overridable Sub NextBytes(ByVal buffer As Byte()) 
     If (buffer Is Nothing) Then 
      Throw New ArgumentNullException("buffer") 
     End If 
     Dim i As Integer 
     For i = 0 To buffer.Length - 1 
      buffer(i) = CByte((Me.InternalSample Mod &H100)) 
     Next i 
    End Sub 

    <__DynamicallyInvokable> _ 
    Public Overridable Function NextDouble() As Double 
     Return Me.Sample 
    End Function 

    <__DynamicallyInvokable> _ 
    Protected Overridable Function Sample() As Double 
     Return (Me.InternalSample * 4.6566128752457969E-10) 
    End Function 


    ' Fields 
    Private inext As Integer 
    Private inextp As Integer 
    Private Const MBIG As Integer = &H7FFFFFFF 
    Private Const MSEED As Integer = &H9A4EC86 
    Private Const MZ As Integer = 0 
    Private SeedArray As Integer() 
End Class