Algunos conceptos del lenguaje C#. Incluye delegados, eventos, delegados genéricos, métodos anónimos, tipos anónimos, expresiones lambda, métodos de extensión, linq, parámetros opcionales, argumentos nombrados, atributos.

1. Conceptos de C#
Danae Aguilar Guzmán

2. Conceptos de C#
| 2
Contenido
Introducción..................................................................................................................................................3
1. Delegados..........................................................................................................................................3
2. Eventos..............................................................................................................................................7
3. Delegados Genéricos ......................................................................................................................10
4. Métodos anónimos.........................................................................................................................11
5. Tipos anónimos...............................................................................................................................13
6. Expresiones Lambda .......................................................................................................................15
7. Métodos de Extensión ....................................................................................................................16
8. Introducción a LINQ ........................................................................................................................18
9. Parámetros opcionales ...................................................................................................................22
10. Argumentos nombrados.............................................................................................................24
11. Covarianza y Contra varianza......................................................................................................26
12. Indexadores.................................................................................................................................28
13. Atributos .....................................................................................................................................29

3. Conceptos de C#
| 3
Introducción
En esta lección repasaremos algunos conceptos del lenguaje C# los cuales son necesarios tener en
cuenta para desarrollar aplicaciones C# de cualquier tipo.
1. Delegados
El concepto de delegados permite tratar a los métodos como a objetos, asignarlos a variables y pasarlos
como parámetros. En el fondo los delegados son objetos que contienen una referencia a algún método
de algún objeto.
Los tipos delegados en .NET son objetos type-safe que hacen referencia a uno o mas métodos a la vez.
Los delegados son clases que soportan invocación asíncrona de métodos y multicasting. Mediante el uso
de delegados se implementa el mecanismo de Callback en .NET.
Type-safe. Porque conocen la cantidad de parámetros, tipo de parámetros y el tipo de retorno.
Multicasting. Porque permiten llamar a varios métodos secuencialmente.

4. Conceptos de C#
| 4
1. Declaración del delegado:
Al ser compilado el código los delegados se convierten en clases, por lo tanto es posible declarar un
delegado en cualquier alcance en que declararíamos una clase: anidado dentro de otra clase,
independiente a nivel global.
La manera básica de declarar un delegado es muy parecida a la declaración de un método abstracto solo
incluyendo la palabra delegate, por ejemplo:
public delegate double MetodoDelegate(double x);
En este ejemplo la clase delegado se llama MetodoDelegate (el nombre tiene el sufijo Delegate por
convención), recibe 1 parámetro de tipo double, y retorna double.
2. Algunos métodos con la firma correcta.
Algunos ejemplos de métodos que podríamos usar para instanciar al delegado son los que cumplen la
misma firma, por ejemplo:
double Cuadrado(double x)
{
return x * x;
}
static double Cubo(double x)
{
return x * x * x;
}

5. Conceptos de C#
| 5
3. Crear una instancia del delegado:
Ahora crearemos instancias de nuestro delegado MetodoDelegate, la sintaxis es la siguiente:
Para un método de instancia:
Program p = new Program();
MetodoDelegate instancia1 = new MetodoDelegate(p.Cuadrado);
Para un método estático:
MetodoDelegate instancia3 = new MetodoDelegate(Math.Sqrt);
En ambos casos la sintaxis reducida consiste en asignar directamente el nombre del método a la
instancia del delegado. Ambas sintaxis son equivalentes, ej:
MetodoDelegate instancia1 = p.Cuadrado;
MetodoDelegate instancia2 = Cubo;
MetodoDelegate instancia3 = Math.Sqrt;

6. Conceptos de C#
| 6
4. Invocar a la instancia del delegado:
Para invocar al método o métodos suscritos a nuestra instancia del delegado podemos llamar al método
Invoque pasándole los parámetros que le pasaríamos al método suscrito y recibiendo el valor retornado,
ej:
double res1 = instancia1.Invoke(2.0);
double res2 = instancia2.Invoke(3.0);
La sintaxis reducida es la siguiente, ambas sintaxis son equivalentes:
double res3 = instancia3(9.0);
Nota: Si se han suscrito varios métodos a la instancia del delegado, el valor de retorno será el valor
retornado por el último método que se ejecute, los demás valores de retorno de los demás métodos
serán ignorados.
Los delegados son referencias a métodos, tanto a métodos estáticos como a métodos de instancia. Esto
nos permite por ejemplo almacenar los métodos en una variable, pasarlos como parámetros a otro
método y posteriormente invocarlos dinámicamente.

7. Conceptos de C#
| 7
Los delegados en el fondo almacenan una lista de métodos, es posible usar el operador += para agregar
mas métodos a la lista y el operador -= para remover métodos de la lista. Los métodos de la lista serán
invocados uno por uno secuencialmente en el orden en que fueron agregados a la lista.
Los delegados con inmutables, lo que quiere decir que cada vez que se modifica el delegado por
ejemplo al usar el operador += en el fondo de crea un nuevo delegado y se deshecha el anterior.
El operador += se traduce en una llamada al método Combine de la clase Delegate y se encarga de
combinar los métodos en una lista de invocación.
El operador -= se traduce en una llamada al método Remove de la clase Delegate y se encarga de
remover los métodos de la lista de invocación.
2. Eventos
Una de las principales aplicaciones de los delegados es la creación y manejo de eventos.
Los eventos son prácticamente la otra cara del espejo de los delegados. Los delegados son interactivos
ya que el proceso inicia con la invocación del delegado y posteriormente las llamadas a los métodos.
Los eventos son reactivos, porque en el proceso primero están los métodos (event handlers) los cuales
son manejados en reacción a un evento que fue lanzado.

8. Conceptos de C#
| 8
Los eventos permiten notificar cuando algo sucede:
- Un método puede registrar su interés en un evento.
- Un método puede de registrar su interés en el evento.
- Los métodos registrados serán ejecutados cuando el evento ocurra.
1. Definir y lanzar eventos:
Los eventos se definen en base a delegados, la sintaxis recomendada para definir un nuevo evento es la
siguiente:
public event EventHandler Evento = delegate{};
La sintaxis es parecida a la de instanciar un delegado con la adición de la palabra reservada event
especificando que es un evento y no así una instancia de un delegado. Inicializamos el evento con un
delegado vacio para evitarnos tener que validar si es nulo cada vez que lancemos el evento.
La manera de lanzar el evento es invocarlo como se hace con un delegado. Nótese que el tipo del evento
es EventHandler, este es un delegado que acepta métodos void que reciben 2 parámetros: (object y
EventArgs), ej:

9. Conceptos de C#
| 9
public void FunctionQueLanzaElEvento()
{
Evento(this, EventArgs.Empty);
}
2. Manejar o recibir eventos:
Para manejar el evento podemos crear métodos (conocidos como event handlers), estos métodos
deben cumplir la firma del evento y deben ser registrados con el evento para ser notificados cuando se
lance el evento.
La manera de registrar un event handler con un evento es agregándolo a la lista de ejecución, ej:
Publicador publicador = new Publicador();
publicador.Evento += new EventHandler(publicador_Evento);
Y definiendo el método (event handler) que se ejecutará en reacción al evento, ej:
void publicador_Evento(object sender, EventArgs e)
{
//... Hacer algo
}

10. Conceptos de C#
| 10
Los eventos no son simples instancias de delegados, mas bien son delegados que ofrecen mayor
encapsulación y protección evitando la modificación inadecuada de la lista de invocación desde
cualquier instancia externa.
En el fondo los eventos encapsulan a los delegados mediante los métodos Add y Remove mediante los
cuales suscriben y remueven las suscripciones a los métodos (event handlers) que están interesados en
ser notificados de la ejecución del evento.
Los event handlers se suscriben al evento con el operador += y se remueven las suscripciones con el
operador -= de los eventos.
3. Delegados Genéricos
El .NET Framework define los delegados Action y Func, los cuales nos ahorran el trabajo de tener que
declarar nuestros propios delegados cada vez.
Action representa los métodos que no retornan nada (los métodos void), y permite una combinación de
hasta 16 parámetros, lo cual es normalmente mas que suficiente.
Func representa los métodos que si retornan algún valor cuyo tipo se define al final de la lista genérica
de definición, por ejemplo:
Func<int, string, bool> miDelegado;

11. Conceptos de C#
| 11
Declara un delegado para métodos que reciben 2 parámetros (int y string) y retornan bool.
Func también soporta hasta 16 parámetros de entrada.
4. Métodos anónimos
Los métodos anónimos simplifican la sintaxis de los delegados y son utiles en casos donde el método
invocado por el delegado es invocado en un solo lugar y cuyo código es simple.
La sintaxis de los métodos anónimos ha sido mejorada con la introducción de las expresiones Lambda,
por lo cual veremos brevemente la sintaxis de los métodos anónimos:
Declaración:
Action <int> imprimirRaizCuadrada = delegate(int numero)
{
Console.WriteLine(Math.Sqrt(numero));
};
Invocación:
imprimirRaizCuadrada(9);

12. Conceptos de C#
| 12
Los métodos anónimos en comparación con los delegados pueden mejorar la legibilidad del código ya
que se puede ver la implementación del método en el lugar donde se lo declara sin tener que crear
otros métodos y otros delegados.
No es muy recomendable usar métodos anónimos cuando la lógica del método es muy larga ya que en
este caso estaríamos haciendo que el código sea menos legible.
En el fondo el compilador creará un método para cada método anónimo por lo cual la ventaja de los
métodos anónimos es principalmente hacer el código mas limpio.

13. Conceptos de C#
| 13
5. Tipos anónimos
Los tipos anónimos fueron introducidos en C# 3.0 principalmente para colaborar con LINQ, permiten la
creación de clases dinámicamente al vuelo y la instanciación de objetos al mismo tiempo, estas clases no
tienen nombre por eso se las llama anónimas.
Los tipos anónimos son clases que solamente definen propiedades, de definen de la siguiente manera:
var ana = new { Nombre = "Ana", CI = 7513521, Edad = 15 };
var juan = new { Nombre = "Juan", CI = 5295124, Edad = 27 };
Como no se sabe el nombre del tipo se usa var para definirlos y se usa solamente new para
instanciarlos. En este ejemplo hemos definido objetos de un tipo anónimo pero lo que realmente
interesa son las propiedades que el tipo define las cuales en el ejemplo son Nombre, CI y Edad.
Los objetos instanciados mediante tipos anónimos se usan de manera normal, accedemos a las
propiedades definidas como siempre:
Console.WriteLine("{0} con CI {1} tiene {2} años", ana.Nombre, ana.CI, ana.Edad);

14. Conceptos de C#
| 14
Los tipos anónimos al ser compilados son clases a las que el compilador les da un nombre y las incluye
en el assembly, de esta manera el CLR los trata normalmente como a los tipos comunes (tipos
nomimales).
Los tipos anónimos al ser compilados incluyen solamente un constructor con los parámetros
correspondientes para inicializar todas sus propiedades, las propiedades publicas de solo lectura por lo
cual no es posible modificar el valor de las propiedades una vez instanciada la clase, campos privados de
solo lectura para cada propiedad, los métodos heredados de la clase object: ToString, Equals,
GetHashCode.

15. Conceptos de C#
| 15
6. Expresiones Lambda
Adiós a la sintaxis de los métodos anónimos!
Las expresiones Lambda ofrecen principalmente el beneficio de remover un nivel de llamadas en
nuestro código. Es decir, lo que normalmente tienes que hacer es crear un método, darle un nombre y
pasar ese nombre a un delegado, esto es útil cuando usas ese código en varios lugares. Pero cuando solo
usas ese código en un lugar entonces es preferible usar expresiones Lambda que te permiten poner el
código directamente sin tener que crear un método y darle un nombre y asignarlo a un delegado.
El concepto es el mismo que el del los métodos anónimos (C# 2.0), las expresiones Lambda fueron
definidas en C# 3.0 y es recomendado usar la nueva sintaxis de expresiones Lambda en vez de la antigua
sintaxis de los métodos anónimos ya que las expresiones Lambda hacen el código mas fácil de escribir,
de leer y de mantener.

16. Conceptos de C#
| 16
7. Métodos de Extensión
Los métodos de extensión nos permiten agregar nuevos métodos principalmente a clases de las cuales
no somos autores y no tenemos el código. Estos métodos pueden estar definidos en un assembly
distinto al de la clase original. De esta manera muchos métodos han sido agregados a las clases antiguas
del BCL por ejemplo los métodos para manejar colecciones con expresiones Lambda.
Nos damos cuenta que un método es de extensión cuando el primer parámetro que recibe tiene la
palabra this al inicio, entonces este parámetro no espera que se le pase ningún argumento solo indica a
que tipo esta extendiendo el método.
Para definir un método anónimo debemos:
1. Declararlo en una clase static.
2. El método debe ser static también.
3. El primer parámetro debe ser del tipo al que estamos extendiendo por ejemplo string, y debe
tener la palabra this al inicio.
static class Extensiones
{
public static string InvertirCadena(this string cadena)
{
char[] caracteres = cadena.ToCharArray();
Array.Reverse(caracteres);
string cadenaInversa = new string(caracteres);
return cadenaInversa;
}
}

17. Conceptos de C#
| 17
Una vez definido el método de extensión debe estar al alcance del código donde se quiere invocar, ya
sea en el mismo assembly o en un assembly que agregamos como referencia. Entonces podemos usar el
nuevo método como si fuera parte de la clase:
string cadena = "!odnumaloH";
Console.WriteLine(cadena.InvertirCadena());
Lo cual es lo mismo que hacer una llamada al método estático definido en la clase:
Console.WriteLine(Extensiones.InvertirCadena(cadena));

18. Conceptos de C#
| 18
En resumen los métodos de extensión nos permiten extender la funcionalidad de tipos previamente
compilados lo cual es útil especialmente si no tenemos el código fuente para manipularlo y
recompilarlo.
Los métodos de extensión no pueden ser usados para redefinir y reemplazar métodos que ya existen en
la clase.
Deben ser definidos en una clase estática cuyo nombre no es relevante.
8. Introducción a LINQ
LINQ ofrece una sintaxis conveniente para realizar consultas sobre colecciones de datos, usando LINQ
podemos fácilmente filtrar ítems, ordenarlos, obtener una proyección de un conjunto de los ítems y
mucho más.
LINQ permite hacer consultas sobre cualquier colección que implemente IEnumerable<T>, ya sea un
arreglo, una lista, XML DOM, fuentes de datos remotas como tablas en un servidor SQL.
La declaración de una consulta LINQ tiene una sintaxis parecida al lenguaje de consultas SQL pero en
LINQ primero especificamos de donde obtendremos los resultados de la consulta mediante las palabras
reservadas from in. Luego podemos o no especificar una condición con where, y posteriormente
especificamos lo que deseamos seleccionar con select.

19. Conceptos de C#
| 19
En este ejemplo declaramos la consulta para seleccionar los empleados cuyo apellido empiece con la
letra A:
IEnumerable<Empleado> consultaEmpleados = from e in empleados
where e.Apellido.StartsWith("A")
select e;
Tener este código no quiere decir que tengamos el resultado de la consulta. LINQ no ejecuta la consulta
hasta que se accede al resultado ya sea recorriéndolo con un foreach o mediante la llamada a algún
método como Count por ejemplo.
foreach (var empleado in consultaEmpleados)
{
Console.WriteLine(empleado.Apellido);
}
Aquí es donde realmente se ejecuta la consulta, también podría ser aquí:
int cantidad = consultaEmpleados.Count();

20. Conceptos de C#
| 20
LINQ permite obtener los resultados de una consulta en un orden especifico, esto se consigue
especificando el comando orderby antes de select. En el ejemplo retornamos los empleados en orden
alfabético de apellidos.
Para evitar obtener resultados repetidos podemos hacer uso del método Distinct() aplicado sobre la
consulta. Es importante notar que al aplicar la ejecución de cualquier método como Distinct() sobre la
consulta se esta realizando la ejecución de la misma.
La manera de realizar agrupaciones con LINQ es mediante el comando group by, el cual nos retornara
una estructura de tipo IGrouping<T,S> donde T es el tipo del campo por el cual estamos agrupando y S
es el tipo de los objetos agrupados. Entonces tendremos una colección de IGrouping<T, S> a la cual
podemos iterar mediante dos foreach anidados.

21. Conceptos de C#
| 21
LINQ realiza consultas sobre tipos IEnumerable o IEnumerable<T>, por lo cual si alguna colección no es
de este tipo primero tendremos que convertirla si queremos usar LINQ sobre ella.
LINQ tiene ejecución diferida, lo cual quiere decir que la declaración de la consulta en realidad no la
ejecuta solo la define, la ejecución se realiza la primera vez que se trata de acceder a los resultados.
LINQ nos da el beneficio de verificar los tipos en tiempo de compilación lo cual evita errores posteriores.
Además nos permite tener un mismo modelo de consulta consistente entre diferentes y diversas
fuentes de datos como listas, tablas, XML y mas.

22. Conceptos de C#
| 22
9. Parámetros opcionales
Los parámetros opcionales son una nueva característica de C# 4.0 que nos permite especificar un valor
por defecto para los parámetros que no sean obligatorios, de esta manera cuando llamemos al método
podemos omitir estos parámetros y ellos tomaran el valor por defecto.
Los parámetros opcionales nos ahorran el trabajo de definir diversas sobrecargas de un método en el
cual la única diferencia es la cantidad de parámetros.
La manera de especificar que un parámetro de un método es opcional es tan sencilla como asignarle un
valor por defecto en el mismo lugar de su declaración:
public Producto(string nombre, decimal? precio = null)
{
…
}
Entonces podemos usar el método ya sea pasándole el parámetro u omitiendo el mismo:
Producto producto1 = new Producto("Chocolate blanco", 9);
Producto producto2 = new Producto("Chocolate");

23. Conceptos de C#
| 23
Uno de los principales objetivos de los parámetros opcionales es el de facilitar la interacción con
componentes COM, pero como hemos visto también nos ahorra tener que escribir múltiples
sobrecargas del mismo método.
Los parámetros opcionales deben declarar un valor constante por defecto que será usado en caso de
que el parámetro no sea especificado en la llamada al método.
Deben ser especificados siempre al final del método después de los parámetros obligatorios excepto en
el caso de params que va al final.
Los parámetros opcionales no pueden ser out ni ref.

24. Conceptos de C#
| 24
10. Argumentos nombrados
Esta característica nueva de C# 4.0 va de la mano de los parámetros opcionales, permite cambiar el
orden de los argumentos cuando se llama a un método, para esto se debe especificar el nombre del
parámetro al que se refiere nuestro argumento seguido de dos puntos : y el valor. Esto es útil cuando se
tiene varios parámetros opcionales del mismo tipo en un método.
También facilita la comprensión especificando a que parámetro se refiere cada argumento en la llamada
a un método.
Los argumetos nombrados pueden ser usados con ref y out, para esto solo basta especificar ref u out
antes del valor del argumento nombrado y proceder de la manera normal:

25. Conceptos de C#
| 25
int numero;
bool success = int.TryParse("10", result: out numero);
Los argumentos nombrados nos permiten especificar los parámetros sin importar su posición
basándonos en su nombre.
Hace más legible el código de las llamadas a los métodos ya que el programador puede saber que
representa cada argumento.
Cuando se usan argumentos nombrados se los debe especificar después de los argumentos posicionales
normales.

26. Conceptos de C#
| 26
11. Covarianza y Contra varianza
El concepto de covarianza y contra varianza no es algo nuevo, sin embargo desde la versión 4.0 de C# lo
nuevo es el soporte de covarianza y contra varianza en colecciones genéricos lo cual antes no era
posible.
La varianza y contra varianza están relacionadas a la conversión implícita de un tipo hijo a un tipo padre,
por lo cual es posible asignar un objeto de tipo Estudiante y almacenarlo en una variable de tipo
Persona.
Ahora también es posible realizar esta operación en colecciones genéricas como las definidas en este
ejemplo.

27. Conceptos de C#
| 27
La covarianza permite agregar colecciones de un tipo hijo por ejemplo de Estudiante a una colección
definida con un tipo padre por ejemplo Persona. Esto parece algo obvio pero no había sido permitido
antes de C# 4.0
La contra varianza nos permite usar métodos definidos para un tipo padre por ejemplo Persona en
colecciones genéricas definidas para un tipo hijo por ejemplo Estudiante. Igualmente esta operación
parece obvia ya que un Estudiante puede ser tratado como Persona debido a la herencia, pero antes de
C# 4.0 esto no era posible en colecciones genéricas como la del ejemplo.

28. Conceptos de C#
| 28
12. Indexadores
Los indexadores permiten acceder a colecciones declaradas dentro de nuestras clases mediante uno o
más parámetros usando una sintaxis similar a la de los arreglos.
Los indexadores son propiedades que se definen de manera especial y reciben parámetros, para
empezar su nombre es this y en vez de usar paréntesis para los parámetros (como los hacen los
métodos) se usa corchetes.
class Semana
{
private string[] dias = {"Domingo", "Lunes", "Martes",
"Miércoles", "Jueves", "Viernes",
"Sábado"};
public string this[int numDia] // indexer
{
get { return dias[numDia]; }
set { dias[numDia] = value; }
}
}
La manera de usar los indexadores es pasando los argumentos entre corchetes:
Semana semana = new Semana();
Console.WriteLine(semana[0]);

29. Conceptos de C#
| 29
Los indexadores permiten acceder a elementos de una colección declarada en una clase o struct. Son
similares a las propiedades pero reciben parámetros que normalmente se usan como un índice.
Se declaran con el nombre this y los parámetros se declaran entre corchetes [], no es obligatorio recibir
solo un parámetro, pueden ser mas.
13. Atributos

30. Conceptos de C#
| 30
Los atributos o atributos personalizados (custom attributes) son una manera de asociar información
adicional a nuestros tipos, esta información es emitida por el compilador en la metadata del módulo.
Muchos atributos no tienen significado para el compilador pero de todos modos los agrega en la
metadata. Los atributos son útiles para los programadores en tiempo de diseño y de ejecución.
Varios frameworks usan atributos para identificar los tipos y métodos, por ejemplo [Serializable]
identifica a una clase como apta para ser serializada, [TestMethod] especifica que un método define un
test en la aplicación.
La manera de crear nuestros propios atributos personalizados es creando una clase que herede de
Attribute, por convención nuestra clase llevara el sufijo Attribute en su nombre:
public class CommandLineAliasAttribute : Attribute
{
public CommandLineAliasAttribute(string alias)
{
Alias = alias;
}
public string Alias { get; set; }
}
Nuestra clase atributo puede tener propiedades que guarden la información que nos interesa. Una vez
definida nuestra clase atributo podemos usarla instanciándola entre corchertes sobre el tipo que
queremos marcar por nuestro atributo:
class CommandLineInfo
{
[CommandLineAlias("?")]
public bool Ayuda { get; set; }
// ...
}
Es importante notar que al momento de usar el atributo no es necesario usar el sufijo Attribute con el
que nombramos a nuestra clase, de esta manera reducimos el largo del nombre lo cual es mas cómodo y
hace que el código sea mas limpio.

31. Conceptos de C#
| 31
Los atributos tienen como objetivo principal agregar información personalizada a elementos del código.
Para implementarlos debemos derivar de la clase Attribute, por convención el nombre debe llevar el
sufijo Attribute que no es necesario a la hora de usar el atributo. Los atributos se aplican
instanciándolos entre corchetes sobre el elemento al cual queremos aplicarlo.