Ejercicio 1:

Visual studio, crear una interface comparable

interface Comparable
{
bool SosIgual(Comparable elemento);
bool SosMenos(Comparable elemento);
bool SosMayor(Comparable elemento);
}

o:

public abstract class Comparable

{
public abstract bool SosIgual();
public abstract bool SosMenos();
public abstract bool SosMayor();
}

Las interfaces no pueden contener atributos, solo van comportamientos,+

no la implementacion.

Ejercicio 2:

public class Numero : Comparable //Implementar la interfaz

{

public int valor

{
get
{
return this._vakir * 2;
}
set
{
this._valor = value;
}
}

public Numero(int valor)

{
this.valor = valor;
}

public int GetValor()

{
return numero;
}
}

public bool SosIGual(Comparable elemento)

{
return this.valor = ((Numero)elemento).valor;
}

public bool SosMenor(Comparable elemento)

{
return this.valor > ((Numero)elemento).valor;
}
public bool SosMayor(Comparable elemento)
{
return this.valor < ((Numero)elemento).valor;
}

public string ToString()

{
return valor.ToString;
}

Main:

Numero num = new Numero(12);

num.SosMayor(new Numero (10)); //Esto me va a dar Falso

Ejercicio 3:

class Coleccionable
{
int Cuantos();
Comparable Minimo();
Comparable Maximo();
void Agregar(Comparable elemento);
bool Contiene();

Ejercicio 4:

public class Pila : Coleccionable

{
List<Comparable> elementos = new List<Comparable>();

public void Agregar (Comparable elemento)

{
elementos.Add(elemento);
}

public bool Contiene(Comparable elemento)

{
foreach(Comparable elemen in elementos)
{
if (elemento.SosIgual(elemento))
return true;
}
return false;
}

public int Cuantos()

{
return elementos.Count;
}
 public Comparable Maximo()
{
Comparable maximo = null;
if (elementos.Count > 0)
maximo = elementos[0];

foreach(Comparable elemen in elementos)

{
if (maximo.SosMayor(elemen))
maximo = elemen;
}
return maximo;
}

public Comparable Minimo()

{
Comparable minimo = null;
if (elementos.Count > 0)
minimo = elementos[0];

foreach(Comparable elemen in elementos)

{
if (minimo.SosMayor(elemen))
minimo = elemen;
}
return minimo;
}

Ejercicio 5:

Main:

Main:

Console.WriteLine("1 Pila");
Console.WriteLine("2 Cola");

string opcion = "1";

string opcion = Console.ReadLine();
switch(opcion)
{
case "1" : coleccionable = new Pila();
break;
case "2" : coleccionable = new Cola();
break;

}
Coleccionable pila = new Pila();
Coleccionable cola = new Cola();
Llenar(pila);
Lenar(cola);
Coleccionable coleccionMultiple = new ColeccionMultiple(pila,cola);
Informar(pila);
Informar(cola);
informar(coleccionmultiple);

List<int> lista = new List<int>();

lista.Add(3);
lsta.Add(1);
lista.Add(10);

foreach(int elemento in lista)

{
Console.WriteLine(Elemento);
}
lista.Sort();

Llenar(coleccionable);
Informar(coleccionable);

Coleccionable coleccionable = null;

Coleccionable coleccionable = new Pila();
coleccionable = new Cola();

public static void Llenar(Coleccionable coleccionable)

{
for (int i = 0; i < 20; i++)
{
Numero num = new Numero (new Random().Next(1000));
coleccionable.Agregar(num);
}
}

Ejercicio 6:

Main:

public static void Informar(Coleccionable coleccionable)

{
Console.WriteLine("Cantidad de elementos en el coleccionable: ", +
coleccionable.Cuantos());

Console.WriteLine("Cantidad de elemento mas chico en el coleccionable: ", +

coleccionable.Minimo());

Console.WriteLine("Cantidad de elemento mas grande en el coleccionable: ", +

coleccionable.Maximo());
int valor = int.Parse(Console.ReadLine());
Numero numero = new Numero(valor);
Console.WriteLine("Ingrese un valor menor a 1000");

if(coleccionable.Contiene(numero))
{
Console.WriteLine("El valor leido por teclado esta en la coleccion");
else
Console.WriteLine("El valor leido por teclado no esta en la coleccion");
}
}

Ejercicio 7:

public class ColeccionMultiple : Coleccionable

{
public ColeccionMultiple(Pila p, Cola c)
{
this.pila = p;
 this.cola = c;
}
private Cola cola;
private Pila pila;

public void Agregar(Comparable elemento)

{

public bool Contiene(Comparable elemento)

{
return cola.Contiene(elemento) || pila.Contiene(elemento);
}

public int Cuantos()

{
return cola.Cuantos() +�pila.Cuantos();
}

public Comparable Maximo()

{
if (pila.Maximo().SosMenor(cola.Maximo()))
return pila.Maximo();
else
return cola.Maximo();
}

public Comparable Minimo()

{
if (pila.Minimo().SosMenor(cola.Minimo()))
return cola.Minimo();
else
return cola.Minimo();
}
}

Ejercicio 11:

public class Persona : Comparable

{
public Persona()
{
}

public Persona(string nombre, int dni)

{
this.Nombre = nombre;
this.Dni = dni;
}
public int Dni{ get;set;};
public string Nombre {get; set;};

public bool SosIgual(Comparable elemento)

{
return this.Dni == (Persona)elemento).Dni;
}

public bool SosIgual(Comparable elemento)

 {
return this.Dni == (Persona)elemento).Dni;
}

public bool SosMenor(Comparable elemento)

{
return this.Dni < (Persona)elemento).Dni;
}

public bool SosMayor(Comparable elemento)

{
return this.Dni > (Persona)elemento).Dni;
}

ordenar:
Consultas a la base de datos:

List <Persona> personasOrdenadas = listaPersonas.OrderBy(p=>p.dni).ToList();

List <Persona> personasConJ = listaPersonas.Where(p=>p.Nombre.SubString(0,1) ==

"J").ToList();

personasConJ = from l in listaPersonas where p.Dni > 1 select *

Ejercicio 12:

public static string NombreAlAzar()

{
List<string> nombres = new List<string>();
nombre.Add("Pedro");
nombre.Add("Jose");
nombre.Add("Marina");
nombre.Add("Juana");
nombre.Add("Alfredo");
int posicion = new Random().Next(nombres.Count-1);
string nombreAlAzar = nombres[posicion];
return nombreAlAzar;
}
}