Pues bien, si ya llevas algún tiempo programando, habrás notado que esto de extraer los datos de la fuente de datos y tratarlos como objetos es algo complicado, sobre todo porque existen buenas diferencias entre las bases de datos relacionales y los lenguajes orientados a objetos como C#.

Se han diseñado unas cuantas herramientas ORM (Object-Relational mapping) para resolver este problema (crear una base de datos orientada a objetos virtual), pero casi siempre dejan algo que desear, y hoy por hoy, a pesar de haber unas cuantas herramientas de uso libre y comercial, muchos programadores prefieren usar sus propias bibliotecas para trabajar con fuentes de datos.

En este contexto es que nace la idea de LINQ (Language INtegrated Query), en principio una herramienta más para dar solución al problema del mapeo objeto-relacional (ORM) y simplificar la interacción entre objetos y fuentes de datos (XML, ADO.Net, RDBMS), quién luego se convirtió en un conjunto de herramientas de consulta integrado en varios lenguajes de la plataforma .Net.

LINQ es un cambio en la forma de manejar y manipular los datos, permite el acceso a cualquier fuente de datos (LINQ to Objects, LINQ to SQL, LINQ to DataSets), mezclar datos de diferentes fuentes con una sintaxis muy sencilla, comprobar en tiempo de compilación las consultas, el uso de IntelliSense de Visual Studio y un enfoque declarativo para escribir códigos más cortos y sencillos. Funciona a partir de C# 3.0 y VB.Net 9.0 ya que requiere de ayuda por parte del compilador.

En realidad LINQ lo que provee es una capa intermedia entre la fuente de dato y el cliente, por decirlo de alguna forma. Gracias a esta abstracción es que podemos trabajar de la misma forma con LINQ sin importar que la fuente de datos sea un archivo XML o una base de datos.

Bueno,  vamos a ver algunos códigos y ejemplos de consultas LINQ y su ventaja frente a las consultas imperativas que se hacen con C# y a otras.

Nota: Para este ejemplo, vamos a suponer que tenemos ya una base de datos llamada Personal mapeada a un conjunto de clases como sigue. Noten que en muchos casos esto se puede hacer de forma automática con Visual Studio.

Esta sería la estructura de la clase que hace referencia a la base de datos:

[Table(Name="Personas")]
class Persona
{
     [Column(IsPrimaryKey=true)]
      public int ID;
 
     [Column(Name="ContactName")]
      public string Nombre;
 
     [Column(Name="ContactAge")]
      public int Edad;
 
     [Column]
      public string Ocupación;
}

Ahora vamos a obtener todas las personas que tengan menos de 30 años y que sean abogados usando LINQ:

var consulta =
            from persona in db.GetTable()
            where persona.Edad<30 && persona.Ocupacion==”abogado”
            select persona;

Y así ya dejamos de tener que hacer las consultas SQL aquellas que nos complicaban la vida, ahora todo es mucho más sencillo, y podemos mantener las mismas consultas sin importar que fuente de dato se esté usando. En el MSDN hay unos cuantos buenos ejemplos de LINQ. Terminaré con una frase que describe en dos líneas la idea esencial de LINQ:

“Before LINQ it was like you had to order your dinner in one language and drinks in another”
Jason McConnel, Product Manager for Visual Studio at Microsoft

Para seguir leyendo sobre LINQ:

Hoja de Trucos de LINQ to SQL
Ejemplo práctico con LINQ y C#
Tutorial de LINQ to SQL *

Entradas relacionadas

Crear una aplicación de Consola:

Para esto, deberemos ir a File->New->Project si usas Visual Studio, pero con cualquier otro IDE debe ser algo parecido. Entonces se mostrará una nueva ventana como la de la figura, seleccionamos C# en el menu izquierdo y luego como tipo de proyecto marcamos “Console Apliccation”, le ponemos un nombre al proyecto y le damos Ok. Ya estaremos listos para empezar con el código.

Métodos útiles para trabajar con la consola

Para interactuar con el usuario es que existen algunos métodos básicos cuando trabajamos con la Consola. Veamos los más usados:

1- Console.WriteLine();
Escribe una nueva linea en la consola, es como presionar Enter y escribir una linea. Por ejemplo, podemos hacer:
Console.WriteLine(“Lo que quiera q salga en la consola”);
También podremos imprimir las variables de nuestro programa, para esto hay dos formas, pero veamos mejor dos ejemplos que son lo mismo:

//declaramos dos variables
string nombre = "Invitado";
int edad = 22;
//Imprimimos una linea en la consola de dos formas distintas
Console.WriteLine("Tu nombre es: "+nombre+" y tienes " + edad + " años.");
//En C# se usa el operador + para concatenar cadenas
Console.WriteLine("Tu nombre es {0} y tienes {1} años", nombre, edad);

Como ven la segunda vía es mucho más simple, solo debes recordar que el numero que está entre cochetes, es el indice del parámetro que se pasa al final del método.
2- Console.Write()
Hace casi lo mismo que Console.WriteLine() pero sin cambiar de línea, o sea… concatena el texto que le pasemos al método con lo que se haya escrito hasta ese momento en la consola.

3- Console.ReadLine()
Se usa para leer lo que el usuario escribió en la consola, y podemos guardarlo en una variable para despues usarlo en nuestro programa. No hay que pasarle ningún parámetro y el programa solo continuará cuando el usuario teclee alguna línea y presione Enter. Podemos hacer algo como esto:

Console.WriteLine("Escriba su nombre");
string nombre = Console.ReadLine();

Importante: Si lo que queremos es recoger lo que el usuario escriba como un tipo en específico, por ejemplo, un entero, deberemos usar el método estático int.Parse, por ejemplo:

int x = int.Parse(Console.ReadLine();

ya que lo que devuelve Console.ReadLine() es un string.

4-Console.ReadKey()
Este método resulta importante algunas veces, sobre todo cuando queremos darle varias opciones al usuario (a, b, c, d). Aunque se puede utilizar Console.ReadLine(). En este caso, este método lo que devuelve es un objeto de tipo ConsoleKeyInfo, y se puede utilizar de la siguiente forma, por ejemplo:

Console.WriteLine("Presiona una tecla");
ConsoleKeyInfo c = Console.ReadKey();
Console.WriteLine("Presionaste la tecla "+ c.KeyChar);

static void Main(string[] args)

public static int DameEdad(int dia, int mes, int año)
{
     //Usamos la clase DateTime y un método estatico para restar fechas
     DateTime fecha_nacimiento = new DateTime(año, mes, dia);
     TimeSpan edad = DateTime.Now.Subtract(fecha_nacimiento);
     return (edad.Days/365);
}

private static void Main(string[] args)
{
    //Variables que usaremos para la fecha de nacimiento
    int dia_nacimiento, mes_nacimiento, año_nacimiento=0;
 
    Console.WriteLine("Escriba su nombre");
    string nombre = Console.ReadLine();
    Console.WriteLine("Hola {0}, bienvenido a mi aplicacion!",nombre);
    Console.WriteLine("Por favor, introduce tu fecha de nacimiento:");
    //El while solo termina cuando se hace break
    while (true)
    {
        //Pedimos el dia y lo validamos
        Console.Write("Dia de nacimiento: ");
        dia_nacimiento = int.Parse(Console.ReadLine());
        if (dia_nacimiento < 1 || dia_nacimiento > 31)
             Console.WriteLine("Por favor, especifique un dia entre 1 y 31");
        else
             //Si el dia es valido, entonces pasamos a pedir el mes
             break;
    }
 
    while (true)
    {
        //Pedimos el mes y lo validamos
        Console.Write("Mes de nacimiento: ");
        mes_nacimiento = int.Parse(Console.ReadLine());
        if (mes_nacimiento < 1 || mes_nacimiento > 12)
             Console.WriteLine("Por favor, especifique un mes entre 1 y 12");
        else
             break;
    }
    while (true)
    {
        //Pedimos el año y lo validamos
        Console.Write("Año de nacimiento: ");
        año_nacimiento = int.Parse(Console.ReadLine());
        //El año no puede ser posterior a 1900 y anterior al año actual
        if (año_nacimiento < 1900 || año_nacimiento > DateTime.Now.Year)
             Console.WriteLine("Por favor, especifique un año entre 1900 y el {0}", DateTime.Now.Year);
        else
             break;
     }
     //Si llegamos aqui, es porque tenemos una fecha correcta, vamos a calcular la edad con
     //el método DameEdad() que escribimos antes
     int edad = DameEdad(dia_nacimiento, mes_nacimiento,año_nacimiento);
     Console.WriteLine(nombre+", usted tiene " + edad + " años.");
     Console.WriteLine("Presione cualquier tecla para terminar el programa");
     Console.ReadKey();
}

Cual es el problema?

Una rejilla n × n es un grafo no dirigido que consiste de n filas y n columnas de vértices. El vértice de la fila i y la columna j se denota (i, j). Todos los vértices en la rejilla tienen exactamente 4 vecinos, excepto los vértices frontera que corresponden a los (i, j) para los cuales: i = 1, i = n, j = 1 o j = n. Dados m <n2 puntos iniciales (x1, y1), (x2, y2), . . . , (xm, ym) en la rejilla, el problema de la evacuación consiste en determinar si existen m caminos disjuntos (no tienen vértices comunes), que comiencen en los puntos iniciales y lleguen hasta m puntos diferentes de la frontera.

Resumen

El problema consiste en encontrar m caminos disjuntos entre dos conjuntos A y B, donde A son los m puntos de entrada y B es el conjunto de los vértices en la frontera. Primeramente se verá cómo podemos reducir el problema de encontrar m caminos vértice-disjuntos en encontrar m caminos arista-disjuntos entre dos nuevos vértices s y t transformando la entrada. En la segunda parte reduciremos el problema de saber si existen m caminos arista-disjuntos entre s y t, en un problema de flujo máximo con capacidades 1 y 0, exponiendo una condición necesaria y suficiente. Por último mostraremos un algoritmo para encontrar el flujo máximo en un grafo en O(n3).

1. Transformando la entrada

Primeramente veremos cómo el problema de encontrar m caminos vértice-disjuntos entre dos conjuntos de vértices se puede reducir a encontrar m caminos vértice-disjuntos entre dos nuevos vértices s y t.

Sean:
i. A⊂V(G) y B⊂V(G) | A∩B=∅ ^ |A|=m
ii. s y t dos nuevos vértices donde s,t ∉V(G).
iii. ∀v∈A, E(G) = E(G) + <s,v>

Sea k la cantidad de caminos vértice-disjuntos que van desde A hasta B y sea k’ la cantidad de caminos disjuntos que van de s a t, donde estos son los únicos vértices comunes en los k’ caminos, entonces k=k’, ya que aumentamos cada uno de los A-B caminos vértice-disjuntos con dos aristas <s,v0> y <vn,t> donde v0 es el primer vértice de un A-B camino y vn el último.Luego, si hacemos estos cambios al grafo de la entrada tendremos un nuevo grafo G’=<V’,E’>, donde:

V’=V+{s,t}
E’=E+{s,u}+{v,t} | u∈A ^ v∈B

Ahora convertiremos el grafo G’ en un grafo dirigido de la siguiente forma:

Por cada arista no dirigida en G’, pondremos dos aristas dirigidas, una en cada sentido. Luego, los k caminos vértice-disjuntos en G’ se mantienen luego de hacer esta transformación. Lo siguiente que haremos será convertir los caminos vértice-disjuntos en G en caminos arista-disjuntos en G´, para esto hacemos:

V’ = {vin, vout | v∈V(G)}
E’ = {(vout, win) | (v,w) ∈E(G)} ∪ {(vin, vin) | v∈V(G)}

Con las transformaciones propuestas obtenemos un nuevo grafo G’ donde cada camino vértice-disjunto en G corresponde con un camino arista-disjunto en G’ entre los vértices s y t, ya que cada camino que pasa por un vértice v pasará solo a través de la arista (vin, vout). El costo de obtener G’ a partir de G es claramente O(V), lo que en términos de la entrada sería O(n2).

2. Reduciendo el problema de encontrar k caminos arista-disjuntos a un problema de flujo máximo en una red de flujo.

En esta segunda parte, definiremos una red de flujo matemáticamente y veremos en detalle cómo resolver nuestro problema original utilizando un algoritmo para encontrar el flujo máximo en una red con capacidades de valor 1.

Sin pérdida de generalidad, sea G=<V,E> un grafo conexo y dirigido con dos vértices distinguidos s y t que llamaremos origen y destino respectivamente, donde indeg(s)=exdeg(t)=0. Definamos una función c: E→Z+ en G que llamaremos capacidad, y representa intuitivamente la cantidad máxima de flujo que puede pasar por la arista (u,v).

Diremos que un flujo s-t es una función f:E→Z+ donde el valor f(u,v) representa la cantidad de flujo que puede pasar entre los vértices u y v. El flujo f debe satisfacer las siguientes dos propiedades:

i. 0≤f(u,v)≤c(u,v), ∀(u,v)∈E(G).

ii. La sumatoria de los flujos que entran en un vértice es igual a la sumatoria de los flujos que salen de él (no lo puedo porner matemáticamente)

Obviamente la propiedad (ii) no se cumple para s y t, ya que indeg(s)=exdeg(t)=0. Llamaremos flujo de G y lo denotaremos por f(G) a la cantidad de flujo generado por s, luego f(G) es la suma de los flujos de las aristas que salen de s. El problema del flujo máximo es hallar cual es el máximo valor de f(G). O sea, ¿Cuál es la mayor cantidad de flujo que se puede enviar desde s sin violar las capacidades de las aristas? Denotaremos el flujo máximo de G como f*(G).

Volviendo a nuestro problema, después de hacer los cambios propuestos en (1) a la rejilla de entrada, tendremos un grafo D=<V,E> conexo, dirigido y dos vértices distinguidos s y t, indeg(s)=exdeg(t)=0. Luego, podemos definir un flujo s-t en D, donde en un principio todas las aristas tendrán capacidad 1 y se puede ver fácilmente que no se viola ninguna de las dos propiedades. Veamos una condición necesaria y suficiente para saber cuál es el número máximo de caminos arista disjuntos entre s y t:

Teor: El número máximo de caminos arista-disjuntos entre s y t en D, es igual al flujo máximo en D entre s y t donde todas las aristas tienen capacidad 1.

D/ Sea k el número de caminos arista-disjuntos en D entre s y t, entonces el flujo máximo f(D)≥k.

Sea P el conjunto de los k caminos disjuntos de s a t. Vamos a hacer lo siguiente:

1. f(u,v)=1 ∀(u,v)∈E(P)

2. f(u,v)=0 ∀(u,v)∉E(P)

f(u,v) solo toma valores 0 ó 1, por lo que se cumple la propiedad (i). Además, todo camino empieza en s y termina en t, y esto implica que todos los vértices interiores que participan en alguno de los k caminos arista-disjuntos tiene una arista que entra y una que sale de v con flujo 1 por construcción, por lo que se cumplirá la propiedad (ii). Luego, tendremos un flujo válido en D, f(G) =k, que son la cantidad de aristas con flujo que salen de s. Luego, f*(G) ≥f(G) ≥k.

Sea D una red de flujo, donde f(D)= k y todas las aristas tienen capacidad 1, entonces existen al menos k caminos arista-disjuntos entre s y t.

En otras palabras, lo que tenemos que demostrar es que el conjunto de aristas con f(u,v)=1 contiene un subconjunto de k caminos arista-disjuntos entre s y t, esto es porque el flujo en este caso toma siempre valores 0 ó 1, por la forma en la que construimos nuestro grafo D.

Sea f(D)=k y m’ el conjunto de aristas tal que f(u,v)=1.

Para esta demostración haremos inducción en el número de aristas con f(u,v)=1.

No hay entradas relacionadas.

¿Qué es la genericidad?

Primero lo primero. La genericidad nos permite pasar un tipo genérico (o más), como parámetro a un método, clase, estructura o interfaz. O sea, este nuevo tipo (que llamaremos <T>), viene a sustituir al tipo object, que es usado sobre todo en estructuras de propósito general, como son los arraylist, pilas (stack), colas (queue) y otras que usamos frecuentemente, en las cuales todos los elementos deben ser de un mismo tipo. Por ejemplo, en una lista de números, en la que no queremos que hayan datos de tipo strings o char, solo de tipo int. Ahora se preguntarán ¿Por qué sustituir el tipo Object?

Recuerden que todos los tipos en C# (int, long, string, char, etc) heredan de la clase Object, lo cual es una ventaja para algunas cosas, pero a la vez es un problema a la hora de chequear el tipo de los elementos que se insertan en estas estructuras, ya que no hay una forma rápida y eficaz de verificar que todos los elementos sean del mismo tipo, para controlar esto, tendríamos que castear* cada vez que queramos obtener un valor de dicha estructura, lo cual puede llevar a errores, por no mencionar que es algo muy pesado, incómodo de programar y hay una gran posibilidad de errores en tiempo de ejecución.

Al usar genericidad también tenemos que tener en cuenta algunos cambios (para bien) en nuestra forma de programar, pero es mejor verlo en la práctica, veamos un ejemplo: Supongamos que queremos crear una clase con un método o función que nos devuelva el menor de dos valores de un mismo tipo. Utilizando la genericidad, tendríamos algo así:

class Ejemplo //T es el tipo de dato genérico
{
    //Método que devuelve un elemento de tipo T que es el mínimo
    //entre el elemento x y el elemento <em>y</em>
    T Minimo(T x, T y)
    {
       if(x &lt; y)
          return x;
       else
          return y;
    }
 
}

Ahora veamos qué pasa cuando invocamos este método:

//Supongamos que tenemos una clase Figura
Figura f1 = new Figura();
Figura f2 = new Figura();
Ejemplo ej = new Ejemplo();
Figura min = ej.Minimo(f1, f2);

Este código ni siquiera se ejecutaría, y dará un error en tiempo de compilación en la línea marcada de la clase Ejemplo<T> donde T es la clase Figura, ya que en ninguna parte especificamos cuando una instancia de Figura es menor, mayor o igual que otra, sin embargo, para el tipo int esto no supondría ningún problema verdad?

¿Qué quiere decir esto?

Cuando usemos genericidad tenemos que ser mucho más cuidadosos y formales cuando programemos, lo cual no es una mala práctica y es bueno ir acostumbrándose. Ahora arreglemos la clase Ejemplo para que el método Minimo(T x, T y) funcione con cualquier tipo de dato en general (que se pueda comparar):

class Ejemplo where T: IComparable;
{
    T Minimo(T x, T y)
    {
        int c = x.CompareTo(y);
        if(c<0)
            return x;
        else
            return y;
    }
}

Ahora ya especificamos que T es un tipo que debe implementar la interfaz IComparable<T>. En otras palabras, obligamos a que los elementos de tipo T se pueden comparar entre ellos, ya que en otro caso, hallar el mínimo pierde el sentido. En estos casos, se utiliza la palabra reservada where: y a continuación todas las restricciones que debe cumplir T, separadas por coma.

Entonces usamos el método CompareTo que debe implementar toda clase T que sea IComparable para saber cuál es el menor elemento. Este método deberá devolver 0 si x=y, 1 si x>y,-1 si x<y. Por tanto, el resultado de ejecutar Minimo, depende completamente de cómo implementemos el método CompareTo(). Por ejemplo, si tenemos la clase Figura:

class Figura: IComparable
{
    //Supongamos que tenemos estos métodos implementados
    public long Area();
    public long Perimetro();
 
    //Ahora implementamos el método <em>CompareTo</em>
    public int CompareTo(Figura f)
    {
        if(this.Area&gt;f.Area)
            return 1;
        else if(this.Area

En este caso, decidimos que una Figura es mayor que otra, en función del área, pero podemos definir que se comparen por el diámetro, por el perímetro, etc. Noten que aquí si podemos usar los operadores binarios dentro del CompareTo, ya que en este caso comparamos implícitamente elementos de tipo long, que son IComparables por defecto. Ya vas notando algunas ventajas de usar genericidad?

Ahora en un mismo método Mínimo, podemos devolver el elemento menor de cualquier tipo de dato que se pueda comparar, noten que este método nos servirá para Int, String, Long, Figuras, Personas y toda clase o tipo que implemente la interfaz IComparable.

Les dejo dos implementación de la clase Queue<T>, que es una cola con algunos métodos genéricos. En una de las implementaciones uso arrays, y en la otra colas enlazables. No lo he probado muy bien, pero funcionaba hace dos años cuando la implementé, jeje.

Veremos algunas otras cosas que podemos hacer con la genericidad en la segunda entrega de este tutorial, la semana próxima. Cualquier duda en los comentarios.

Descarga aquí el archivo en .zip:  Cola en C#

Entradas relacionadas

Que día de la semana cae el 20 de abril del 2020?

Que día de la semana será el 12 de agosto del 2011?

Estas respuestas sin la ayuda de la computadora solo algunos eruditos pueden responderlas (yo conozco a uno). El problema no es tan sencullo como dividir y hallar restos de división.

Primero hay que buscar una forma de guardar cuantos días tiene cada mes, teniendo en cuenta claro, si el año es bisiesto o no…

Recuerden que un año es bisiesto si es divisible entre 400 ó es divisible entre 4 y no entre 100.

Bueno, vamos a hacer un programa de consola, que primero le pida al usuario que entre una fecha válida, con su día, mes y año y luego imprimiremos en consola que día de la semana será o fue la fecha recibida.

Vamos al código:

using System;
 
namespace DiaDeLaSemana
{
   class Class1
   {
      //Esta es la aplicación de entrada
      static void Main()
      {
         while(true)
	 {
		//Pedimos que entre la fecha y validamos que
                //los datos sean correctos
                Console.WriteLine("Escribe una fecha"+'\n');
		Console.Write("Dia: ");
		int d = int.Parse(Console.ReadLine());
		if(d<=0) break;
		Console.Write("Mes: ");
		int m = int.Parse(Console.ReadLine());
		if(m<=0) break;
		Console.Write("Año: ");
		int a = int.Parse(Console.ReadLine());
		if(a<=0) break;
                //Creamos un array con los días de la semanas
		string[] days = {"Domingo", "Lunes", "Martes",
                "Miercoles", "Jueves", "Viernes", "Sabado"};
           //Esta es la respuesta, usando el método DayOfWeek()
	   Console.WriteLine("Ese dia es "+days[DayOfWeek(d,m,a)]);
	 }
    }
 
    public static int DayOfWeek(int day, int month, int year)
    {
	int[] mesCode = {0,6,2,2,5,0,3,5,1,4,6,2,4};
     int result = year%100 + (year%100)/4 + day + mesCode[month];
 
	if(year/100==17) result += 5;
	else if(year/100==18) result += 3;
	else if(year/100==19) result += 1;
	else if(year/100==20) result += 0;
	else if(year/100==21) result += -2;
	else if(year/100==22)  result += -4;
 
        //Vemos si es bisiesto y quitamos un día si
        //el mes es enero o febrero
	if(EsBisiesto(year) && (month==1 || month==2))
	    result += -1;	
 
        //Esto devuelve un número entre 0 y 7
        //que nos dá el día de la semana
	return result%7;
    }
 
    //Método para saber si un año es bisiesto
    private static bool EsBisiesto(int a)
    {
	return (a%4==0 && a%100!=0) || a%400==0;
    }
}
}

Interesante verdad? Pues ya saben algo nuevo, si quieren este método puede ser un poco más elegante y con menos código, piensen en alguna otra solución y la discutimos en los comentarios.

'\n'

Entradas relacionadas

Random r = new Random
// Creamos el objeto Random, que tiene un constructor por defecto
// O para los más exigentes, añadimos un plus de
// aleatoriedad, algo así:
Random r = new Random(DateTime.Now.Millisecond);

Y una vez tenemos el objeto, utilizaremos uno de esos tres métodos.

1.- El método Next Tiene tres sobrecargas:

int aleatorio1 = r.Next();
 
// Le imponemos un máximo
int aleatorio2 = r.Next(100);
 
// Le imponemos un rango, por ejemplo queremos
// un número de 3 cifras
int aleatorio3 = r.Next(100, 999);
 
// Queremos un número entre el 3 y el 12,
int aleatorio4 = r.Next(3, 12);

2.- El método NextDouble

// Devuelve un double entre 0 y 1
int aleatorio5 = r.NextDouble();

3.- El método NextBytes

byte[] buffer = new byte[100];
r.NextBytes(buffer);

¡¡Como ven, es super sencillo trabajar con esta clase, ahora veamos un ejemplo de como trabajar con esta clase.

1 – Crear un array de tamaño aleatorio con números aleatorios. Esto nos puede servir para probar varios métodos que usan arrays (ordenación, búsqueda, etc).

//Inicializamos la clase Random
Random r = new Random();
 
//Creamos un array que va a contener cantidad
//aleatoria de elementos menor que 50.
int [] numeros = new int [r.Next(0,50)];
 
//Recorremos el array y vamos asignando a cada
//posición un número aleatorio
for(int i=0; i<numeros.Lenght; i++)
   numeros[i] = r.Next(0,50);

Y hasta aquí, ya veremos después como es por dentro esta clase…

Entradas relacionadas