static void Main(string[] args)
{
Console.WriteLine("Hola Mundo... desde App_POOEspaciosNombreYReferenciaDLL.pbl.Program");
HolaMundo.Principal();
pbl.Dos.ClaseDos.Saluda();//De esta forma "si no colocamos el using" llamamos a otra clase que es estatica y esta en otro espacio de nombre
//ClaseDos.Saluda(); //<- Colocando a el Using de su espacio de nombre "using pbl.Dos;"
ClaseTres.Saluda();
Alias3.ClaseTres.Saluda();//usando el alias para llamar a la clase que esta dentro de un espacio de nombre, el cual puede ser tremendamente largo o no...
Console.ReadLine();
}
static void Main(string[] args)
{
ClaseUno clase1 = new ClaseUno("Clase Uno");
ClaseDos clase2 = new ClaseDos("Clase uno", "clase dos");
ClaseTres clase3 = new ClaseTres("clase uno", "clase dos", "clase tres");
ClaseCuatro clase4 = new ClaseCuatro("clase uno", "clase dos", "clase tres", "clase cuatro");
List <ClaseUno> miLista = new List <ClaseUno>();
miLista.Add(clase1);
miLista.Add(clase2);
miLista.Add(clase3);
miLista.Add(clase4);
Console.WriteLine("\n\n---------override ToString()------\n\n");
foreach (ClaseUno c in miLista)
{
Console.WriteLine(c.ToString());
}
//foreach (ClaseUno c in miLista)
//{
// Console.WriteLine(c.Mostrar());
//}
Console.WriteLine("\n\n---------Con propiedad------\n\n");
foreach (ClaseUno c in miLista)
{
Console.WriteLine(c.Propiedad1);
}
//Console.WriteLine("\n\n---------sin override ------\n\n");
//foreach (ClaseUno c in miLista)
//{
// // Console.WriteLine(c.);
//}
Console.ReadLine();
}
static void Main(string[] args)
{
ClaseUno c1 = new ClaseUno("Primera Clase");
ClaseDos c2 = new ClaseDos("Primera Clase", "Segunda Clase");
ClaseTres c3 = new ClaseTres("Primera Clase", "Segunda Clase", "Tercera Clase");
Console.WriteLine(c1.TipoClaseUno);
Console.WriteLine(c2.TipoClaseDos);
Console.WriteLine(c3.TipoClaseTres);
Console.WriteLine(c1.MostrarClaseUno());
Console.WriteLine(c2.MostrarClaseDos());
Console.WriteLine(c3.MostrarClaseTres());
Console.ReadLine();
}
static void Main(string[] args)
{
ClaseUno miClase1 = new ClaseUno("Clase 1");
Console.Write(miClase1.Tipo);
Console.Write(miClase1.ToString());
//
ClaseDos miClase2 = new ClaseDos("Clase 2", miClase1.Tipo);
Console.Write(miClase2.Tipo);
Console.Write(miClase2.ToString());
//
ClaseTres miClase3 = new ClaseTres("Clase1", "Clase2", "Clase3");
Console.Write(miClase3.Tipo);
Console.Write(miClase3.ToString());
Console.ReadLine();
//
List <ClaseUno> lista = new List <ClaseUno>();
lista.Add(miClase1);
lista.Add(miClase2);
lista.Add(miClase3);
foreach (ClaseUno a in lista)
{
Console.WriteLine(a.ToString());
Console.WriteLine(a.Tipo);
/*if(a is ClaseTres)
* {
* Console.Write(((ClaseTres)a).TipoClaseTres);
* Console.Write(((ClaseTres)a).MostrarClaseTres());
* }
* else if(a is ClaseDos)
* {
* Console.Write(((ClaseDos)a).TipoClaseDos);
* Console.Write(((ClaseDos)a).MostrarClaseDos());
* }
* else*/
}
}
static void Main(string[] args)
{
ClaseUno clase1 = new ClaseUno("Hola");
ClaseDos clase2 = new ClaseDos("Como", "Estas");
ClaseTres clase3 = new ClaseTres("Juancito", "Pepito", "Pedrito");
//Console.WriteLine(clase1.MostrarClaseUno());
//Console.WriteLine(clase3.TipoClaseTres);
//Console.WriteLine(clase2.MostrarClaseUnoDos());
//Console.WriteLine(clase3.MostrarClaseUnoDosTres());
//Console.ReadKey();
List <ClaseUno> listaClases = new List <ClaseUno>();
listaClases.Add(clase1);
listaClases.Add(clase2);
listaClases.Add(clase3);
foreach (ClaseUno clase_1 in listaClases)
{
Console.WriteLine(clase_1.Tipo);
Console.WriteLine(clase_1);//se puede poner clase_1.ToString() o solo clase_1 ya que por default invoca al ToString() del object que reciba.
Console.ReadKey();
//if (clase_1 is ClaseTres)
//{
// Console.WriteLine(((ClaseTres)clase_1).MostrarClaseUnoDosTres());
// Console.ReadKey();
//}
//
//else if (clase_1 is ClaseDos)
//{
// Console.WriteLine(((ClaseDos)clase_1).MostrarClaseUnoDos());
// Console.ReadKey();
//}
//
//else if (clase_1 is ClaseUno)
//{
// Console.WriteLine(clase_1.MostrarClaseUno());
// Console.ReadKey();
//}
}
}
static void Main(string[] args)
{
ClaseUno a = new ClaseUno("ClaseUno");
ClaseDos b = new ClaseDos("ClaseUno", "ClaseDos");
ClaseTres c = new ClaseTres("ClaseUno", "ClaseDos", "ClaseTres");
ClaseCuatro d = new ClaseCuatro("ClaseUno", "ClaseDos", "ClaseTres", "ClaseCuatro");
List <ClaseUno> _lista = new List <ClaseUno>();
_lista.Add(a);
_lista.Add(b);
_lista.Add(c);
_lista.Add(d);
foreach (ClaseUno item in _lista)
{
Console.WriteLine(item.ToString());
Console.WriteLine(item.Nombre);
}
Console.ReadLine();
}
static void Main(string[] args)
{
ClaseUno c1 = new ClaseUno("Primera Clase");
ClaseDos c2 = new ClaseDos("Primera Clase", "Segunda Clase");
ClaseTres c3 = new ClaseTres("Primera Clase", "Segunda Clase", "Tercera Clase");
Console.WriteLine(c1.TipoClaseUno);
Console.WriteLine(c2.TipoClaseDos);
Console.WriteLine(c3.TipoClaseTres);
Console.WriteLine(c1.MostrarClaseUno());
Console.WriteLine(c2.MostrarClaseDos());
Console.WriteLine(c3.MostrarClaseTres());
Console.ReadLine();
//CREO LISTA GENERICA DE TIPO CLASEUNO
List <ClaseUno> listaUno = new List <ClaseUno>();
listaUno.Add(c1);
listaUno.Add(c2);
listaUno.Add(c3);
//CREO LISTA GENERICA DE TIPO CLASEDOS
List <ClaseDos> listaDos = new List <ClaseDos>();
//listaDos.Add(c1);//ERROR
listaDos.Add(c2);
listaDos.Add(c3);
//CREO LISTA GENERICA DE TIPO CLASETRES
List <ClaseTres> listaTres = new List <ClaseTres>();
//listaTres.Add(c1);//ERROR
//listaTres.Add(c2);//ERROR
listaTres.Add(c3);
Console.ReadLine();
//RECORRO LA LISTA... CUANDO EL OBJETO SEA CLASEDOS O CLASETRES -> ERROR!
foreach (ClaseUno item in listaUno)
{
Console.WriteLine(item.TipoClaseUno);
Console.WriteLine(item.MostrarClaseUno());
}
Console.ReadLine();
#region Con Polimorfismo
//foreach (ClaseUno item in listaUno)
//{
// Console.WriteLine(item.Tipo);
// Console.WriteLine(item.Mostrar());
//}
//Console.ReadLine();
#endregion
}
static void Main(string[] args)
{
ClaseUno c1 = new ClaseUno("Primera Clase");
ClaseDos c2 = new ClaseDos("Primera Clase", "Segunda Clase");
ClaseTres c3 = new ClaseTres("Primera Clase", "Segunda Clase", "Tercera Clase");
Console.WriteLine(c1.TipoClaseUno);
Console.WriteLine(c2.TipoClaseDos);
Console.WriteLine(c3.TipoClaseTres);
Console.WriteLine(c1.MostrarClaseUno());
Console.WriteLine(c2.MostrarClaseDos());
Console.WriteLine(c3.MostrarClaseTres());
Console.ReadLine();
List <ClaseUno> lista = new List <ClaseUno>();
lista.Add(c1);
lista.Add(c2);
lista.Add(c3);
foreach (ClaseUno item in lista)
{
if (item is ClaseUno)
{
Console.WriteLine(item.TipoClaseUno);
}
if (item is ClaseDos)
{
Console.WriteLine(((ClaseDos)item).TipoClaseDos);
}
if (item is ClaseTres)
{
Console.WriteLine(((ClaseTres)item).TipoClaseTres);
}
if (item is ClaseUno)
{
Console.WriteLine(item.MostrarClaseUno());
}
if (item is ClaseDos)
{
Console.WriteLine(((ClaseDos)item).MostrarClaseDos());
}
if (item is ClaseTres)
{
Console.WriteLine(((ClaseTres)item).MostrarClaseTres());
}
}
Console.ReadLine();
#region Con Polimorfismo
//foreach (ClaseUno item in lista)
//{
// Console.WriteLine(item.Tipo);
// Console.WriteLine(item.Mostrar());
//}
//Console.ReadLine();
#endregion
}
static void Main(string[] args)
{
ClaseUno C1 = new ClaseUno("string de clase 1 \n");
//Console.WriteLine(C1.MostrarClaseUno() + "\n"); //prueba
//Console.WriteLine(C1.TipoClaseUno + "\n"); //prueba
ClaseDos C2 = new ClaseDos("juan ", "perez \n");
//Console.WriteLine(C2.MostrarClaseDos() + "\n"); //prueba
//Console.WriteLine(C2.TipoClaseDos + "\n"); //prueba
ClaseTres C3 = new ClaseTres("uno", " dos", " tres \n");
//Console.WriteLine(C3.TipoClaseTres + "\n"); //prueba
//Console.WriteLine(C3.MostrarClaseTres()); //prueba
Console.WriteLine("\n" + "recorriendo lista:" + "\n");
List <ClaseUno> ListaClases = new List <ClaseUno>(); //Lista generica debe guardar a la clase principal ya que
//los hijos tambien pertenecen al padre, si lo hago al revez
ListaClases.Add(C1); //poniendo a ClaseTres en la Lista, no va a tomar a la ClaseDos
ListaClases.Add(C2); //ni a la ClaseUno ya que de la ClaseTres para abajo serian
ListaClases.Add(C3); //del mismo tipo.
//foreach (ClaseUno item in ListaClases) //sin polimorfismo tengo que recorrer de esta el foreach y mostrar asi
//porque debo diferenciar cada tipo de objeto ya que el mostrar y la
//propiedad de cada uno es individual y debo discriminarlos
//{
// if (item is ClaseTres)
// {
// Console.WriteLine(((ClaseTres)item).MostrarClaseTres() + "\n");
// Console.WriteLine(((ClaseTres)item).TipoClaseTres + "\n");
// }
// else if (item is ClaseDos) //se usa else if porque sino al ser el mismo objeto lo muestra en todos los if
// {
// Console.WriteLine(((ClaseDos)item).MostrarClaseDos() + "\n");
// Console.WriteLine(((ClaseDos)item).TipoClaseDos + "\n");
// }
// else if (item is ClaseUno) //se usa else if porque sino al ser el mismo objeto lo muestra en todos los if
// {
// Console.WriteLine(item.MostrarClaseUno() + "\n");
// Console.WriteLine(item.TipoClaseUno + "\n");
// }
//}
foreach (ClaseUno item in ListaClases) //con polimorfismo evito lo de arriba, tener que diferenciar entre
{
Console.WriteLine(item.Mostrar()); //metodos y propiedades de cada clase ya que la clase principal los tiene
Console.WriteLine(item.Tipo); //como virtual y los hijos como override. De este modo, al recorrer el foreach
//el compilador sabe diferenciar a que metodo virtual u override debe invocar.
}
Console.WriteLine("\notro tipo de foreach: \n");
foreach (ClaseUno item in ListaClases) //en este foreach al console.writeline se le pasa el item solo, ya que
{ //sobreescribimos al ToString en cada clase y el console.writeline intenta
Console.WriteLine(item); //convertir implicimente en ToString al item.
Console.WriteLine(item.Tipo);
}
Console.ReadKey();
}
