La primera vez que oí hablar de delegados y eventos estaba en primer año.docx (Tamaño: 133,98 KB / Descargas: 149) QUE TAL
aprendiendo C# si a alguien le interesa que aprendamos sobre esto voy a ir subiendo las cosas que tengo y seria muy bueno encontrar a otros que les interese aprender C# Y SQL SERVER
SUBO UN .DOC con apuntes de delegados genericos etc

---

aca van los apuntes de indexadores ,delegados ,iteradores etc

---

PARA EL QUE NUNCA USO C# SUBO LOS SIGUIENTES APUNTES PARA ENTENDER PROPIEDADES HERENCIA OBJETOS METODOS ETCP LOS CODIGOS PARA ELLOS EN LOS MENSAJES PUEDEN EJECUTARLOS SIMPLEMENTE CON EL IDE DE VISUAL STUDIO APLICACION DE CONSOLA Y LUEGO BORRAR LA SUPERFICIE Y COPIAR Y PEGAR EL CODIGO MI INTENCION ES IR DESAROLLANDO TEMAS EN CADA MENSAJE Y EL QUE PUEDA SUBA TAMBIEN CODIGO Y APUNTES PRETENDO LLEGAR A COSAS AVANZADAS DEL LENGUAJE DE FORMA PAULATINA TRATANDO DE ENTENDER LO QUE SE HACE
LOS PRIMEROS APUNTES LOS PODEMOS USAR DE

http://www.itnuevolaredo.edu.mx/takeyas/.../index.htm

http://ramonroque.com/Materias/programacionavanzada.htm

DESDE QUE ES UN OBJETO

ELIMINE COMENTARIOS Y SE USA EDITOR DE LA PAGINA PARA ENTENDER COMO NO ES PROGRAMACION ESTRUCTURADA NO SE ENTIENDE SU LECTURA EN FORMA LINEAL!
CON LAS HERRAMIENTAS DE VISUAL STUDIO DESCRIBIRLOS COMO OBJETOS PARA COMPRENDER LOS PROGRAMAS

vinculo a pagina del guille
http://www.elguille.info/colabora/2007/s...Listas.htm
http://www.elguille.info/NET/futuro/firm...erable.htm

los ejemplos son lo mas transparente que encontre de cada tema y los mismos tienen el material especifico para descargar en archivos adjuntos
el curso de laredo es el mas completo y accesible que encontre tiene gran cantidad de ejemplos y archivos adjuntos lo dan como una materia mas universitaria

ARRAYS
un programa muy elemental de arrays

 

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;



namespace arrays1

{

    class Program

    {

        //arreglo lista variables de igual tipo

        //igual nombre distinto indice



        public static int entrada;

        public static string entrada1;



        static void Main(string[] args)

        { 

            //hay que declararlo antes de usarlo

 

 int[] notas = new int[5];



            //notas sera una variable con 5 elementos

            //notas tiene una referencia al arreglo



            for (int i = 0; i < notas.Length; i++)

            {

                Console.WriteLine("ingrese 5 notas por orden");

                //lo leemos como string

                entrada1 = Console.ReadLine();

                //convertimos lo leido a entero 

                entrada=Convert.ToInt32(entrada1);

                notas[i] = entrada;

                 

                

            }



            for (int i = 0; i < notas.Length; i++)

            {

                Console.WriteLine("usted ingreso  {0}",notas[i]);

            }

            Console.ReadLine();



        }

    }

}

 

ejemplo muy muy elemental de polimorfismo
Sin comentarios

 

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;



namespace Amy

{

    class Empleado

    {

        protected string ciudad = "capital";

        protected string codigopostal = "11111";

        public string primernombre;

        protected string segundonombre;

        protected int edad;

        protected double tasadepago;

        public Empleado(string primernombre, string segundonombre, int edad, double tasadepago)

        {

            this.primernombre = primernombre;



            this.segundonombre = segundonombre;

            this.edad = edad;

            this.tasadepago = tasadepago;



            Console.WriteLine("constructor de clase empleado de varios parametros");



        }

        public virtual double calcularpaga(ref int horastrabajadas)

        {

            horastrabajadas = horastrabajadas + 1;

            Console.WriteLine("Empleado.calcularpaga  incremento en uno num+1 es {0}   ", horastrabajadas);

            return 1;

        }

        class empleadoasalariado : Empleado

      

        {

            public string numerosegsocial;

            public empleadoasalariado(string primernombre, string segundonombre, int edad, double tasadepago)

                : base(primernombre, segundonombre, edad, tasadepago)

            {

                Console.WriteLine("constructor de clase empleadoasalariado de varios parámetros se ejecuta con el código del constructor de empleado");

            }

            public override double calcularpaga(ref int horastrabajadas)

            {

                Console.WriteLine("horas trabajadas empleadoasalariado {0} de {1}", horastrabajadas.ToString(), primernombre);



                return 2;

            }

        }

        class empleadocontratado : Empleado

        {

            public string tiempocontrato;

            public empleadocontratado(string primernombre, string segundonombre, int edad, double tasadepago)

                : base(primernombre, segundonombre, edad, tasadepago)

            {

                Console.WriteLine("constructor de clase empleadocontratado de varios parametros");

            }

            public override double calcularpaga(ref int horastrabajadas)

            {

                Console.WriteLine("horas trabajadas empleadocontratado {0} de {1}", horastrabajadas.ToString(), primernombre);

                return 3;

            }

        }





        class empleadoporhora : Empleado

        {

            public empleadoporhora(string primernombre, string segundonombre, int edad, double tasadepago)



                : base(primernombre, segundonombre, edad, tasadepago)

            {

                Console.WriteLine("constructor de clase empleadoaporhora de varios parametros cuenta con las variables y propiedades de sus superclases");

            }

            public override double calcularpaga(ref int horastrabajadas)

        

            {            









           

                Console.WriteLine("horas trabajadas empleadoporhora {0} de {1}", horastrabajadas.ToString(), primernombre);





                return 42;

            }

        }

       



        class cliente

        {

            int Indice;

            int num = 99;

            

            protected Empleado[] empleados;

           

            protected void cargarempleados()

            {

                Console.WriteLine("  SE CARGARAN 4 INGRESAR 4");

                Indice = Convert.ToInt32(Console.ReadLine());

                empleados = new Empleado[Indice];

                

                Console.WriteLine("Cargango empleados sin params");

            

                empleados[0] = new empleadoasalariado("amy", "rose", 25, 100);



                empleados[1] = new empleadocontratado("fred", "ron", 35, 150);//carga de objetos en array 

                empleados[2] = new empleadoporhora("alfred", "morgan", 19, 200);

                empleados[3] = new Empleado("alfredemp", "morganemp", 19, 200);



            }

            protected void calcularpaga()

            

            {

                





                foreach (Empleado emp in empleados)

                {   

                    emp.calcularpaga(ref  num);

                    Console.WriteLine(" ciudad {0} codigpostal {1} edad {2} primernombre {3}",emp.ciudad, emp.codigopostal, emp.edad,emp.primernombre);

                    Console.ReadLine();



                }

            }



            public static void Main()

            {

                cliente usuario = new cliente();

                usuario.cargarempleados();

                usuario.calcularpaga();

                Console.ReadLine(); 

            }

               

        }

    }

}



 

Carmen, no entiendo bien la duda que tenés, qué precisás exactamente?, apuntes de cómo usar IEnumerable en 4.0?

lo que pretendo es ir paso a paso por C#
Comienzo los primeros pasos para aprender C# con esto armando resumen
no lo escribo con el editor de codigo disponible porque se retrasa la carga de la pagina utenianos al ejecutar el script debido a comentarios va con editor de codigo igualmente pienso que se trata de entender el codigo
y no de copiar y pegar la forma

 

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace CLONUEVO

{

    class cliente

    {

        //constructor sin parámetros

        public cliente() { }

        //constructor con parametros

        public cliente(string r)

        {

            Console.WriteLine("esto lo ejecuta el constructor con parametro de clase cliente instancia cliente2 {0}", r);

            Console.ReadKey();

        }

        public string nombre { get; set; }



        public string correo { get; set; }

    }

    class Program

    {

   



        public string nombres { get; set; }



        static void Main(string[] args)

        {

            var client = new cliente { nombre = "guilleclient", correo = "@hptclient" };

            Console.WriteLine("esto lo ejecuta el constructor sin parametros de clase cliente instancia client nombre {0} correo{1}", client.nombre, client.correo);

            Console.ReadKey();

            cliente cliente2 = new cliente("cliente2") { nombre = "guille", correo = "@hpt" };

//crea dos instancias de program

            Program cli = new Program();

            Program cli1 = new Program();

//var clis es equivalente a  Program [] clis

            var clis = new[] { cli, cli1, new Program { nombres = "fuan" }, new Program { nombres = "era" } };

            foreach (Program p in clis)

            {

                Console.WriteLine("los objetos que contiene clis  {0}", p.nombres);

            }



            Console.ReadKey();



        }









    }

}

//Basado en el guiLle lo Nuevo en C# 3.0

 

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;



namespace CLONUEVO

{class cliente

    //caracteristicas a partir de .net 2008 propiedades autoimplementadas //,var,generics LIST<> USANDO VAR el compilador lo infiere 



 {//constructor sin parametros



     public cliente() { }



    //constructor con parametros

     public cliente(string r)

     { Console.WriteLine("esto lo ejecuta el constructor con parametro de clase cliente instancia cliente2 {0}",r);

     Console.ReadKey();

     }

    //uso de propiedades autoimplementadas para acceso a campos se les puede agregar privite get 

    // por ejemplo para no poder ser accedidas en C# 3.0

    public string nombre { get; set; }



    public string correo { get; set; }

}

    class Program

    {//no puedo definir  var aqui ,solo definir con variables locales ,tampoco usar en parametros de procedimientos



        public string nombre { get; set; }



        public string nombres { get; set; }

       

        static void Main(string[] args)

       {//con inferencia de tipos no hace falta cliente()

            //inicializaciones de arrays de colecciones

           var client = new cliente { nombre ="guilleclient",correo="@hptclient"};

           Console.WriteLine("esto lo ejecuta el constructor sin parametros de clase cliente instancia client nombre {0} correo{1}", client.nombre, client.correo);

           Console.ReadKey();



           cliente cliente2 = new cliente("cliente2") { nombre = "guille", correo = "@hpt" };

            //campos de la instancia cliente2

           Console.WriteLine("muestra solo los campos de la instancia cliente2 nombre {0} correo {1}", cliente2.nombre, cliente2.correo);

           Console.ReadKey();

            //ahora instancias de clase program

           //entonces pudimos hacer inicializaciones de arrays y colecciones podemos asignar elementos a una variable de la coleccion

            //al mismo tiempo que la definimos

            //ahora declaramos dos instancias de Program

           Program cli = new Program();

            Program cli1 = new Program();

            //uso de generics  List<Program>= new List<Program>{};podremos recorrelo con foreach

            //el compilador inferira al tipo de variable por haber puesto var y seria lo mismo que escribir lo anterior

            //escribimos menos asi

            var clis = new [] {cli,cli1, new Program {nombres="fuan"},new Program{nombres="era" }};

            foreach (Program p in  clis)

            {

                Console.WriteLine("los objetos que contiene clis son muestra primero cli y luego cli1 {0}", p.nombres);

                //aca no se porque me muestra cuatro lineas? lo voy a revisar

            }



            Console.ReadKey();



        }









    }

}



 

---

subo el guille aprenda c# 3.0

---

no lo sube intento otro

Te edite los tags de code a ver si asi se ve mejor.

Por otra parte, no se entiende bien tu duda/pregunta lo que sea.
¿Estas teniendo un problema al pasar de una version vieja del framework a una mas nueva o viceversa?

en ESTE post quisiera que nos fuera de utilidad a los que nos interes C# y sql server a aprenderlo ,que si alguien participa comente sobre el codigo yescrito tambien que pueda escribir su codigo y asi poder entender mejor este lenguaje ,no es ninguna duda en particular
E n este mensaje tratare sobre Inicializadores de Objetos en C# 3.0 A partir de la versión 3.0 de C#, se pueden inicializar objetos tanto a través de constructores, como a través de inicializadores automáticos
ejemplo asignando valores a las propiedades al mismo tiempo que creamos al objeto

 

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;



namespace inicializadores

{

    class Producto

    { public int Precio { get; set; }

    public string PaisDeOrigen { get; set; }



    public string Nombre { get; set; }



    public int Id { get; set; }

    }

    class DetalleDeFactura

    {

       

        

            public int Id { get; set; }

            public int CantidadDeProducto { get; set; }

            public Producto ProductoSeleccionado { get; set; }

        



    }

        class cliente

        {

            static void Main(string[] args)

            {

                DetalleDeFactura detalle = new DetalleDeFactura()

                {

                    Id = 1,

                    CantidadDeProducto = 3,

                    ProductoSeleccionado = new Producto()

                    {

                        Id = 0,

                        Nombre = "Impresora Canon MP140",

                        PaisDeOrigen = "Japón",

                        Precio = 50

                    }

                };



                Console.WriteLine("Detalle: {0}", detalle.Id);

                Console.WriteLine("Producto: {0}", detalle.ProductoSeleccionado.Nombre);

                Console.WriteLine("Cantidad: {0}", detalle.CantidadDeProducto);

                Console.ReadKey();



            }

        }



    }

otro para ver herencia

 



using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;



namespace herenciacochetaxi

{

    class CocheSimple

    {

        private int VelocMax;

        private string Marca;

        private string Modelo;



        public CocheSimple()

        {

            this.VelocMax = 0;

            this.Marca = "??";

            this.Modelo = "??";

        }

        public CocheSimple(string marca, string mod, int velMax)

        {

            this.VelocMax = velMax;

            this.Marca = marca;

            this.Modelo = mod;

        }

        public override string ToString()

        {

            return (this.Marca + " " + this.Modelo +

                        "  (" + this.VelocMax + " Km/h)");

        }





    



    } // class CocheSimple



    class Taxi : CocheSimple

    {

        private string CodLicencia;



        public Taxi() { }

        public Taxi(string marca, string mod, int velMax,

                     string lic)

            : base(marca, mod, velMax)

        {



            this.CodLicencia = lic;

        }

        public string Licencia

        {

            get { return this.CodLicencia; }

        }

        public override string ToString()

        {

            return (base.ToString() + "\n   Licencia: " +

                    this.Licencia);

        }





    }











    class DemoHerenciaApp

    {

        static void Main(string[] args)

        {

            CocheSimple MiCoche =

             new CocheSimple("Citröen", "Xsara Picasso", 220);

            CocheSimple TuCoche =

               new CocheSimple("Opel", "Corsa", 190);

            CocheSimple UnCoche = new CocheSimple();



            Console.Write("Mi coche: ");

            

            Console.WriteLine("Mi coche: " + MiCoche);

           

            Console.WriteLine("El tuyo: " + TuCoche);

            



            Console.WriteLine("Un coche sin identificar: " + UnCoche);

            Console.WriteLine();



            Taxi ElTaxiDesconocido = new Taxi();

           

            //Console.WriteLine("Mi coche: " + MiCoche.ToString());

            //SON EQUIVALENTES ESTAS DOS INSTRUCCIONES

            //Console.WriteLine("Mi coche: " + MiCoche); 



            Taxi NuevoTaxi = new Taxi("Citröen", "C5", 250, "GR1234");

           

            Console.Write("   Licencia: {0}  ", NuevoTaxi);



            Console.ReadLine();





        }

    }



}

Si querés aprender, hacete una aplicación boluda con WPF o ASP.NET MVC que persista en un SQL.
Estaría bueno que la cuelgues en GitHub así otro que esté interesado puede colaborar.

Las cosas que pusiste son todos chiches que hacen menos tedioso el laburo y mejoran la expresividad, pero tampoco son imprescindibles. Te recomiendo que te bajes la extensión ReSharper que te va a ayudar a explotar todas estas cosas y usar LINQ.

Abrazo!

Carmen , me parece muy copado lo que haces. Te doy dos consejos y quiero que los tomes constructivamente.

C# 3.0 trajo muchas cosas nuevas importantes al C# 2.0 y tambien poco importantes. Las importantes son las que categorizo como las que "tenes que saber para poder laburar bien en .NET" y las otras no son necesarias.

Ejemplos:
LinQ es importante porque extiende todas las colecciones. Salvo que labures en sistemas triviales , las colecciones es posiblemente lo que mas manejes
Objects initializers y collections initializers son "syntactyc sugar". Podes ni saber que existen y tu codigo va a ser funcionando. Del lado del compilador no cambia mucho. Lo mismo para propiedades automaticas.
Anonymus types es como para clases readonly. Es como un struct de C. Esta bueno en algunos casos
Lambda expresions esta genial si aprendiste funcional.
Partial method nunca lo use en el laburo.

A lo que voy es que hay cosas que trajo C# 3.0 hace 5 años que no son tan importantes. En tu lugar me enfocaria en aprender Linq , Lambda y Asp.NET. C# 4.0 lo aprenderia solo si la empresa que vas a laburar lo usa y no es muy comun que esten tan avanzados.

Lambda es clave para usar cualquier cosa de Linq.

Anonymous types similar a structs? En qué sentido? Se usa generalmente para trabajar dentro de un método al hacer una proyección o agregación dentro de Linq, que terminás haciendo un select new {...}. Y ahora con dynamic en .NET 4.0 es bastante feliz devolver una clase anónima como dynamic, yo igual no lo usaría para este fin salvo algún caso raro que lo requiera.

Tal como decís hay varias cosas que son syntactic sugar pero si no las entendés, al leer código de cualquiera que programe en .NET 3/4 desde hace al menos un ratito pueden prestar a confusión.

Y bueno, en .NET 4.0 como interesante está dynamic, parámetros opcionales y named y la nueva librería de parallel y tasks.

Off-topic:

jaajjajaja "Azucar sintáctico" la traduccion literal es una masa. Todavia me estoy cagando de risa.

Y el operador "??" de que version es 4.0 tambien no?
Aguante las Lambda expressions, igual no son algo demasiado complicado tampoco, pero sirven para con LINQ. La vez que tuve que usar un proyecto escrito con NET 2.0 sufri la falta de LINQ.

Cita:Anonymous types similar a structs? En qué sentido?

En que ambos guardan solamente datos y no funciones.

Cita:Anonymous types contain one or more public read-only properties. No other kinds of class members, such as methods or events, are valid. The expression that is used to initialize a property cannot be null, an anonymous function, or a pointer type.

http://msdn.microsoft.com/en-us/library/bb397696.aspx

Cita:Y ahora con dynamic en .NET 4.0 es bastante feliz devolver una clase anónima como dynamic, yo igual no lo usaría para este fin salvo algún caso raro que lo requiera.

Llamenme anticuado , pero una de las cosas que me gusta de C# es que es estaticamente tipado. Ya puteo suficiente con JS y su tipeo dinamico

Cita:Tal como decís hay varias cosas que son syntactic sugar pero si no las entendés, al leer código de cualquiera que programe en .NET 3/4 desde hace al menos un ratito pueden prestar a confusión.

Buen punto, pero asi como es facil de entender es facil de explicar. Yo si tengo que elegir entre un contratar un recurso que sabe linq o sabe el syntanctyc sugar de 3.0 , contrato el de linq. Me cuesta menos guita capacitarlo, por eso le digo que prioritice linq y lambda

Cita:Y bueno, en .NET 4.0 como interesante está dynamic, parámetros opcionales y named y la nueva librería de parallel y tasks.

Gracias a dios por los named parameters , laburar con el api de office va a dejar de ser un sida

Faloi comenze este post con cosas elementales con aplicaciones de consola no quise empezar siquiera con windows form es mas si alguien tiene problemas para entender la sintaxis y conceptos de objetos subo material tengo de una universidad de españa que empiezan explicando porque decir hola o no decir hola y pienso que les resulta
Para llegar a Lambda ,linq ,BPM ,El workflow foundation ( wf
) colecciones en los workflows de Workflow Foundation el Windows AppFabric crear colas e integrarlas con WCFetc etc
Antes me parece que esta bueno y necesario ver por ejemplo antes de linq los tipos anonimos porque
Las expresiones de consulta linq utilizan con frecuencia los tipos anónimos
los wf utilizan muchos conceptos de colecciones y delegados que debemos manejar y "entender" para crear aplicaciones con ellos
Bueno gracias por todos los comentarios quiero llegar a colecciones en el siguiente mensaje en este muestro una coleccion muy simple muy simple!!! si alguien tiene ejemplos de codigo barbaro en estas primeras cosas elementales
Va sobrecarga del metodo tostring y el recorrido de la coleccion con un foreach ya que list deriva de collection y implementa IEnumerable sin tener que definirlo nosotros
en el proximo mensaje colecciones desde 1.0 con las definiciones de interfaces tipo pascalito a lo mas abstracto del 4.0
en este me baso en el guille
http://www.elguille.info/colabora/2007/s...Listas.htm
Y en un blog de rojas

 

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;



namespace inicializadores

{

    public class Producto

    {

        public int Id { get; set; }

        public string Nombre { get; set; }

        public double Precio { get; set; }

        public string PaisDeOrigen { get; set; }



        public override string ToString()

        {

            return string.Format("Id: {0}, Producto: {1},  Precio: {2}, Pais: {3}", Id, Nombre, Precio.ToString(), PaisDeOrigen);

        }

    }



    class DetalleDeFactura

    {





        public int Id { get; set; }

        public int CantidadDeProducto { get; set; }

        public Producto ProductoSeleccionado { get; set; }





    }

    class cliente

    {

        static void Main(string[] args)

        {

            DetalleDeFactura detalle = new DetalleDeFactura()

            {

                Id = 1,

                CantidadDeProducto = 3,

                ProductoSeleccionado = new Producto()

                {

                    Id = 0,

                    Nombre = "Impresora Canon MP140",

                    PaisDeOrigen = "Japón",

                    Precio = 50

                }

            };

            Producto miProducto = new Producto();

            miProducto.Id = 0;

            miProducto.Nombre = "Audífonos JVC Super bass";

            miProducto.PaisDeOrigen = "Holanda";

            miProducto.Precio = 49.99;

            Console.WriteLine("Producto  C# 1.0: con metodo sobrecargado override string ToString() {0}", miProducto);

            Console.ReadKey();

            Console.WriteLine("Detalle: {0}", detalle.Id);

            Console.WriteLine("Producto: {0}", detalle.ProductoSeleccionado.Nombre);

            Console.WriteLine("Cantidad: {0}", detalle.CantidadDeProducto);

            Console.ReadKey();



            List<Producto> productos = new List<Producto>

{

    new Producto(){ Id=1,Nombre = "intel i7", Precio=1008 ,PaisDeOrigen="holanda"},

    new Producto(){ Id=2,Nombre = "intel i5", Precio=980 ,PaisDeOrigen="belgica"},

    new Producto(){Id=2,Nombre = "nvidea", Precio=2980 ,PaisDeOrigen="japon"  }

};

            foreach (Producto c in productos)

            { System.Console.WriteLine(c); }

            Console.ReadKey();

           



        } 

    }

}



 

aqui va el primero de colecciones en otro mensaje enviare con generics y en el ultimo linq y lambda
cualquier comentario sobre mis comentarios //comentarios //vendria muy bien
dado que algunas son cosas que deduje
Aprovechando las ventajas proporcionadas por los genéricos, en la BCL del .NET 2.0 se ha optimizado la implementación de las colecciones introduciendo en un nuevo espacio de nombres System.Collections.Generic dos nuevas interfaces llamadas IEnumerable<T> e IEnumerator<T> que las colecciones podrán implementar para conseguir que el acceso a las colecciones sea mucho más eficiente que con las viejas IEnumerable e IEnumerator al evitarse el boxing/unboxing o downcasting/upcasting que el tipo de retorno object de la propiedad Current de IEnumerator implicaba. Además, en ellas se ha optimizado el diseño eliminando el tan poco utilizado método Reset()
y haciéndoles implementar en su lugar la estandarizada interfaz IDisposable
http://www.elguille.info/NET/futuro/firm...erable.htm

 

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Collections;



namespace AAAiteradores

{

 public class DaysOfTheWeek : IEnumerable

    { private string[] days = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };

   public IEnumerator GetEnumerator()

{for (int index = 0; index < days.Length; index++)

            {yield return days[index];

    

            }

        }

    }

     class Program

    {

        public static System.Collections.Generic.IEnumerable<int>

            EvenSequence(int firstNumber, int lastNumber)

        {

            for (int number = firstNumber; number <= lastNumber; number++)

            {

                if (number % 2 == 0)

                {

                    yield return number;

                }

            }

        }



        static void Main(string[] args)

        {

            foreach (int number in EvenSequence(5, 18))

            {

                Console.Write(number.ToString() + " ");

            }

            

            Console.ReadKey();

           

            DaysOfTheWeek days = new DaysOfTheWeek();



            foreach (string day in days)

            {

                Console.Write(day + " ");

            }

            Console.ReadKey();





        }

    }

 }

 

 

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Collections;





public class DiasDeLaSemana : System.Collections.IEnumerable

{

string[] Dias = { "Dom", "Lun", "Mar", "Mie", "Jue", "Vie", "Sab" };



public System.Collections.IEnumerator GetEnumerator()

{

for (int i = 0; i < Dias.Length; i++)

{

yield return Dias[i];

}

}

}



class TestDiasDeLaSemana

{

static void Main()

{





DiasDeLaSemana semana = new DiasDeLaSemana();





foreach (string dia in semana)

{

System.Console.Write(dia + " ");

}

}

}

  





 

.SE ELIMINARON COMENTARIOS





//Ejemplo didactico de ing nuñez
//En este ejemplo, la clase DiasDeLaSemana es una clase de colección simple que almacena
//los días de la semana como cadenas. Después de cada iteración de un bucle foreach,
//se devuelve la cadena siguiente en la colección.

ejemplo con editor

 

public class DiasDeLaSemana : System.Collections.IEnumerable

{

string[] Dias = { "Dom", "Lun", "Mar", "Mie", "Jue", "Vie", "Sab" };



public System.Collections.IEnumerator GetEnumerator()

{

for (int i = 0; i < Dias.Length; i++)

{

yield return Dias[i];

}

}

}



class TestDiasDeLaSemana

{

static void Main()

{

// Crear una clase de la clase coleccion



DiasDeLaSemana semana = new DiasDeLaSemana();



// Iterar con foreach



foreach (string dia in semana)

{

System.Console.Write(dia + " ");

}

}

}

 

ALGO de linq en proximo mensaje tratare de ver tipados beneficios y defectos
por los comentarios de .py y,rulo y leandrodg
Extraido de msdn es bastante pesado ir por esas paginas de lectura lineal
Por eso deben de ser tan caros los cursos de C# y los libros de ceballos !!!!!!!!!!!!!!!
Los tipos anónimos ofrecen un modo útil de encapsular un conjunto de propiedades de sólo lectura en un único objeto sin tener que definir antes un tipo de forma explícita
var v = new { Amount = 108, Message = "Hello" };
var no significa "variant" ni indica que la variable tenga establecimiento flexible de tipos ni que sea de enlace en tiempo de ejecución. Simplemente significa que el compilador determina y asigna el tipo más adecuado cuando una variable se inicializa con un tipo anónimo, se debe declarar a la variable como var Desde la perspectiva del código fuente, un tipo anónimo no tiene nombre. Por tanto, si una variable de consulta se ha inicializado con var, la única manera de tener acceso a las propiedades de la secuencia de objetos devuelta consiste en utilizar var como el tipo de la variable de iteración en la instrucción foreach.
Los tipos anónimos se crean utilizando el operador new con un inicializador de objeto
Los tipos anónimos son tipos de referencia que se derivan directamente de object. El compilador les asigna un nombre Cuando se asigna un tipo anónimo a una variable, esa variable debe inicializarse con la construcción var. Esto se debe a que el compilador es el único que tiene acceso al nombre subyacente del tipo anónimo Un tipo anónimo tiene ámbito de método, por esto Si debemos almacenar los resultados de la consulta o pasarlos fuera del límite de método, hay que utilizar una clase o una estructura con nombre común en lugar de un tipo anónimo porque anulariamos el establecimiento inflexible de tipos del tipo anónimo voy a probar como se cuelga microsoft
Al querer pasar un tipo anónimo (o una colección que contenga tipos anónimos) fuera del límite de un método
Los tipos anónimos son tipos class que constan de una o más propiedades públicas de sólo lectura. No se permite ningún otro tipo de miembros de clase, como métodos o eventos
EJEMPLO DE CONSULTA CON TIPO ANONIMO:

 

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;



namespace ConsoleApplication16

{

    class IntroToLINQ

    { 

        static void Main()

        {

            

            int[] numbers = new int[7] { 0, 1, 2, 3, 4, 5, 6 };



         

            var numQuery =

            from num in numbers

            where (num % 2) == 0

            select num;



            foreach (int num in numQuery)

            {

                Console.Write("{0,1} ", num);

            }

        }

    }



}

en este codigo use la guia total del programador ing diego g ruiz de la utn
en la pag 148 hay un ejemplo de metodos virtuales modifique algunas cosas para enlazarlo con lo que el explica de composicion en la pag 133

 

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;



namespace jugadoreslibro

{

    class Jugador

      {

          protected string jugador55;

                  public  virtual void RealizarMoviA()

          {

              this.jugador55 = "NOMBRE jugador DADO EN CLASE PADRE";



              Console.WriteLine("cliente pudo modificar miembro protejido jugador55 = {0} :", jugador55);



              Console.WriteLine("Clase:padreJugador,Metodo:RealizarMovida");



          }



      }

        class Juego

                {

       // string juegoprivado;

                Jugador jugador1;

                    Jugador jugador2;

                    public void EmpezarPartida(Jugador jug1, Jugador jug2)

 {//dos jugadores usan con overwrite el mismo metodo de jugador

jugador1 = jug1;

            jugador2 = jug2;

            jugador1.RealizarMoviA();

            jugador2.RealizarMoviA();

 }



                }

    class bt1 : Jugador

    {public override void RealizarMoviA()

        //implementa su propia logica para evaluar juego y realizar la movida

        {            Console.WriteLine("clasehija:bot1,metodo RealizarMovida()");

        }



    }

    class bt2 : Jugador

    {

        public override void RealizarMoviA()

        {



            Console.WriteLine("clasehija:bot2,metodo RealizarMovida()");

        }



    }













    class Program

    {

        static void Main(string[] args)

        {

            bt1 jug1 = new bt1();

            bt2 jug2 = new bt2();

            Juego j = new Juego();

            j.EmpezarPartida(jug1, jug2);

            Console.ReadLine();

            Jugador jpadre = new Jugador();

            jpadre.RealizarMoviA();

            Console.ReadLine();

            

        }

    }

}





 

se eliminaron los comentarios

Hay que tener en cuenta que al llamar a un método a través de un delegado no se tiene en cuenta si es private no se tendrá en cuenta su modificador de visibilidad
En delegados1 desde la clase A a través del delegado obj indirectamente estamos llamando a un método privado de la clase B “private static void Privado()”
Y EL COMPILADOR LO TOMA COMO BUENO
Y SI LO INVOCAMOS Y NO TIENE UN METODO ASOCIADO LA REFERENCIA ES NULL Y PROTESTA EL COMPILADOR CON UN
System.NullReferenceException

 

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;



namespace DELEGADOS

{delegate void D (int valor);

    class Program

    {

        public  void F(int x)

       

        { Console.WriteLine("paso valor {0} a F",x); }

        static void Main(string[] args)

        {

            Program OBJPROGRAM = new Program();

            D OBJDELEGADO = new D(OBJPROGRAM.F);

            OBJDELEGADO(3);

            Console.ReadLine();

        }

    }

}



 

otro ejemplo de uso de delegados

 

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;



namespace DELEGADOS2

{



    delegate void D(int valor);

class EjemploDelegado

{

public string Nombre;

  

EjemploDelegado(string nombre)

{

Nombre = nombre;

}

public static void Main()

{

EjemploDelegado obj1 =new EjemploDelegado("obj1");



   

D objDelegado = new D(f);

  

   objDelegado += new D(obj1.g);

    

objDelegado(3);

objDelegado -= new D(obj1.g);

objDelegado(5);

Console.ReadLine();

}

public void g(int x)

{

Console.WriteLine("Pasado valor {0} a g() en objeto {1}", x, Nombre);

}

public static void f(int x)

{

Console.WriteLine( "Pasado valor {0} a f()", x);

}

} } 

 

Si necesitamos de un objeto o componente(Reloj) que pueda llamar a un metodo (periódicamente)de una clase (notificada) lo hacemos mediante el evento(Tick )
Para esto hay que crear primero al delegado
public delegate void manejatick (int Ticks);
porque Cada evento puede ser de un tipo mediante un delegado
public event manejatick Tick; este es una señal generada por el (Reloj),


y luego la señal se conecta a un gestor de evento
(con mireloj.Tick+=new manejatick(mireloj_Tick)

 

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;



namespace ojedadelegados

  

{ public delegate void manejatick (int Ticks);

    

    

    class Reloj

    {

        public event manejatick Tick;

        public Reloj()

        { 

            Tick = null; }

        //metodo que generara la señal cada 100 ticks

        public void Inicio()

        {

            for (int i = 0; i < 1000; i++)

           

                if( (i %100==0)&& Tick !=null)

               

                    //el reloj notifica 

                    //genera el evento

                    Tick(i);

                    

                    

                



            

        }

  }

    class notificada

    {public notificada()

        {

            Reloj mireloj = new Reloj();

            Console.WriteLine("antes de asignar invocamos inicio");

            mireloj.Inicio();

        //asignamos gestor del evento

        mireloj.Tick+=new manejatick(mireloj_Tick);

        //solicitamos al reloj que nos notifique con:

        mireloj.Inicio();

        

    }

    public void mireloj_Tick(int tick)

    {

        Console.WriteLine("nos avisa al llegar a 100 {0}",tick);

        Console.ReadKey();

    }

        static void Main(string[] args)

    {

        notificada minotificacion = new notificada();

        }



       

    }

}

 

PROXIMA LLAMADAS ASINCRONICAS EVENTOS PARA LUEGO ENTENDER LAMBDA