Análisis y Programación: Curso de C#: delegados

Conceptos teóricos

Un delegado es una referencia a una función, también se conoce como un puntero a una función. Un delegado permite acceder a una función de forma casi anónima, ya que simplemente tiene la dirección de memoria de dicha función. Y sabiendo la dirección de la memoria, podemos acceder a ella.

El equivalente de los delegados en el lenguaje C/C++ sería un puntero a función (callback)

Un delegado, es un tipo que define una firma o prototipo de método y se puede asociar a cualquier método con una firma compatible. Puede invocar (o llamar) al método a través del delegado. Un delegado permite enviar un método como parámetro a otro método.

Firma o prototipo de método

Cuando se habla de una "firma o prototipo de método" se hace referencia al tipo de retorno, número y tipos de parámetros del mismo. A continuación se muestra un ejemplo de dos firmas diferentes de un método:

Public void MostrarTexto(string mensaje, int cantidadveces) {…}

Public string MostrarTexto(string mensaje) {…}

Son diferentes, porque el tipo de dato que retorna, la cantidad de parámetros y los tipos de parámetros son diferentes para cada método.

Una “firma o prototipo compatible" significa que el delegado debe tener la misma firma del método que va a invocar (llamar o implementar).

Declaración de un delegado

Un delegado se declara igual que la firma de un método, sin cuerpo, es decir sin llaves e interponiendo la palabra reservada delegate entre el modificador de acceso y el tipo de retorno de la firma.

Public delegate void DelegadoMostrar(string mensaje, int cantidadveces);

Cada delegado debe tener un nombre diferente. Una vez declarados los delegados y los métodos podemos instanciarlos e invocarlos.

Utilización de los delegados

Si queremos acceder a una función que devuelve una cadena y que recibe un parámetro de tipo Cliente, debemos definir un delegado con esas características, y cuando posteriormente queramos acceder a ese método, en lugar de hacerlo directamente o por medio de un puntero directo, usaremos un objeto del tipo definido por el delegado. Lo que nos lleva a una segunda definición de lo Un delegado permite acceder a una función de forma casi anónima, ya que simplemente tiene la dirección de memoria de dicha función .que es un delegado, en la que podemos decir que es un tipo especial que nos permite definir la forma de acceder a una función.

Veamos el ejemplo del método que devuelve una cadena y recibe un parámetro de tipo Cliente. Ese método lo podemos definir en C# de esta forma:

public string MiFuncion(Cliente c)

{return “...”;}

La forma de usar ese método sería algo así:

string s = MiFuncion( new Cliente() );

Los delegados, y los eventos en .NET están estrechamente relacionados; tanto es así que no podemos definir un evento sin la intervención de un delegado.

Para utilizar un delegado es necesario crear una instancia de él, indicándole el nombre del método que ejecutará; así:

DelegadoMostrar miDelegado = new DelegadoMostrar(MostrarTexto);

Al constructor del delegado se le envía el nombre (solo el nombre, sin parámetros) del método que se invocará.

Después se invoca el delegado:

miDelegado(“hola mundo”, 5);

Al llamar al delegado se invoca el método que se dio como parámetro al instanciarlo. No se llama el método directamente porque, con un delegado se puede invocar cualquier método con la única condición de que la firma sea idéntica. Un ejemplo son los eventos. Cuando se crea un evento onclick a un botón lo que hace es crear un método, y "decirle" al botón que cuando hagan clic en él, invoque dicho método.

Un tipo delegado es el que se define con la palabra clave delegate.

Un objeto delegado es una instancia de ese tipo delegado.

Ejemplo mínimo de declaración y utilización de delegados:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Delegados

{

// Un delegado puede estar dentro de una clase, fuera de una clase, dentro de un namespace o fuera de un namespace.

// Se crea y define el -tipo- delegado, en la definición (o firma) de un tipo delegado

// Se considera: el tipo de retorno, número de parámetros y el tipo de los parámetros, estas características las deben cumplir los métodos que luego se asignarán.

public delegate int MiDelegado(int parámetro); // Es muy similar a declarar un método

class ClsDelegados

{

public static void Main()

{

Console.WriteLine("Se inicia el programa");

// Se crea un objeto de la clase 'OtraClase'

OtraClase objOtraClase = new OtraClase();

// Se crea un objeto delegado y se le asigna un método, en este ejemplo se

// asigna solo un método, pero se le pueden asignar más.

// Crear un objeto delegado es muy similar a crear un objeto con una clase, la

// diferencia es que le asignamos un método.

// El método no se llama usando '()' solo se le asigna al objeto delegado, por

//eso no se usan los '()'

MiDelegado objDelegado = new MiDelegado(objOtraClase.Método1);

// Se crea una variable de tipo int y se le asigna el valor de retorno

// del objeto delegado, que es el mismo retorno del método anteriormente asignado

int retorno = objDelegado(5); // Se hace la llamada de la misma forma que un método

// Muestra el valor de retorno

Console.WriteLine("El valor devuelto es {0}", retorno);

}

public class OtraClase

{

// Este método cumple con el prototipo del delegado al cual se asigna

public int Método1(int a)

{

Console.WriteLine("Soy Método1 y mi argumento es: {0}", a);

return a + 10;

}

Al compilar y ejecutar el programa, la salida será de este estilo:

Se inicia el programa

Soy el método1 y mi argumento es: 5

El valor devuelto es 15

Añadir y quitar métodos a un objeto delegado

Se puede añadir uno o más métodos a un objeto delegado y en el caso de ser varios métodos es posible ejecutar de forma ordenada a través del objeto, añadir y eliminar métodos a un objeto delegado y ejecutarlos de forma ordenada.

Se utilizan los operadores ‘+=’ para añadir y ‘-=’ para eliminar métodos. Estos son operadores sobrecargados para que el uso de los objetos delegados sea más intuitivo.

using System;

public class Delegado

{

// Se crea y define un tipo delegado,

// Se define el tipo delegado, tipo de retorno, numero de parámetros y tipos de parámetros.

public delegate void TipoDelegado();

public static void Main()

{

Console.WriteLine("Se inicia el programa");

// Se crea un objeto de la clase Delegado

Delegado objClaseDelegado = new Delegado();

// Se crea un objeto de tipo delegado y se le añade un método. //No importa si el método es de un objeto de la propia clase TipoDelegado objTipoDelegado = new TipoDelegado(objClaseDelegado.Método1);

// Se añade al objeto delegado un método, ahora el objeto delegado tendrá 2 métodos añadidos.

// Al añadir un primer método a un delegado se puede usar el operador de asignación '='

// Para añadir otro método se tiene que usar el operador '+='

objTipoDelegado += new TipoDelegado(objClaseDelegado.Método2);

Console.WriteLine("Se llamará al objeto delegado con los métodos ya asignados");

objTipoDelegado();

Console.WriteLine("Se llamará al objeto delegado después de eliminar Método2");

//Eliminar el método 'Método2' y luego llamar al objeto delegado

objTipoDelegado -= new TipoDelegado(objClaseDelegado.Método2);

objTipoDelegado();

// Es posible añadir el mismo método más de una vez

Console.WriteLine("Se añade -de nuevo- Método1");

objTipoDelegado += new TipoDelegado(objClaseDelegado.Método1);

objTipoDelegado();

}

// Los métodos deben cumplir con la definición (firma) del tipo delegado (void en este caso)

public void Metodo1()

{

Console.WriteLine("Soy el Método1");

}

public void Metodo2()

{

Console.WriteLine("Soy el Método2");

}

Al ejecutar el programa el resultado será:

Se inicia el programa

Soy el Método1

Soy el Método2

Se llamará al objeto delegado después de quitar Método2

Soy el Método1

Se añade -de nuevo- el Método1

Soy el Método1

Al inicializar un objeto delegado, se le puede asignar un método usando el operador ‘=’ , pero para asignar o quitar otros métodos al objeto delegado se tiene que usar los operadores ‘+=’ y ‘-=’.

Al llamar al objeto delegado se ejecutan los métodos que almacena de forma ordenada, salen en el mismo orden que se añadieron.

Un mismo método se puede añadir a un objeto delegado más de una vez.

Cuándo utilizar delegados

Los delegados se pueden utilizar en los siguientes supuestos:

-Cuando se llama a varios métodos con una sola llamada.

-Cuando se pasan métodos como parámetros.

-Para la ordenación de un conjunto de elementos. Por ejemplo, para ordenar una secuencia de métodos.

-Cuando se utiliza un modelo de diseño de eventos. Los eventos son como las propiedades, son una forma de acceder a los delegados. Devuelven una respuesta cuando se asigna y/o quita un método a un evento que representa un objeto delegado.

-Para encapsular un método estático. La llamada a un objeto delegado se utiliza para acceder a métodos estáticos o privados de otra clase.

-El autor de la llamada no tiene necesidad de obtener acceso a otras propiedades, métodos o interfaces del objeto.

-Cuando una clase necesita más de una implementación de métodos.

-Para realizar devolución de llamadas asíncronas (en un hilo de ejecución aparte) y finalizar llamadas asíncronas.

-Cuando se produce un cambio en base de datos. Por ejemplo, a partir de un cambio ‘x’ en una tabla, se genera una respuesta ‘y’.

-Asociación de código a la carga y descarga de ensamblados.

-Cuando se produce un cambio en el sistema de archivos. Al borrar ‘x’ archivo se escribe un registro en otro archivo ‘y’, que contiene datos del archivo borrado.

A continuación extendemos uno de los casos presentados en la lista anterior.

Acceso a miembros de delegados

A continuación veremos cómo acceder a métodos privados y estáticos de otra clase utilizando delegados.

// Accede a varios métodos estáticos y privados

using System;

public class EstaClase

{

public delegate void MiDelegado(int parametro1, int parametro2);

public static void Main()

{

Console.WriteLine("Se inicia el programa");

// Se crea una instancia de la clase OtraClase'

OtraClase objOtraClase = new OtraClase();

Console.WriteLine("Se añade al objeto delegado el método estático 'Método1DeOtraClase'");

// Añadir a 'objDelegado' un método estático de 'OtraClase'

// Para añadir un primer método a un objeto delegado, se usa el operador '='.

Console.WriteLine("Se crea una instancia de la clase 'OtraClase'");

MiDelegado objDelegado = new MiDelegado(OtraClase.Metodo1DeOtraClase);

Console.WriteLine("Se añade al objeto delegado el método no estático 'Metodo2DeOtraClase'");

// Se añade 'Metodo2DeOtraClase' que no es estático. Ahora se

// Utiliza el operador '+=' ya que no es el primer método a añadir.

objDelegado += new MiDelegado(objOtraClase.Metodo2DeOtraClase);

Console.WriteLine("Se añade al objeto delegado el método estático 'Método1DeEstaClase'");

// Se añade un método estático de esta clase. No hay que referirse al nombre de esta

objDelegado += new MiDelegado(Metodo1DeEstaClase);

Console.WriteLine("Se crea una instancia de la clase 'EstaClase'");

// Crear una instancia de esta clase 'EstaClase'

EstaClase objEstaClase = new EstaClase();

Console.WriteLine("Se añade al objeto delegado el método no estático 'Método2DeEstaClase'");

// Se añade un método público de esta clase

objDelegado += new MiDelegado(objEstaClase.Metodo2DeEstaClase);

Console.WriteLine("Se llama a objDelegado objDelegado (8, 3);");

// Llamar a un método estático que se almacena en 'objDelegado'

objDelegado(8, 3);

// Llamamos a los métodos que están relacionados con los métodos // de 'objEstaClase' y los de 'objOtraClase'. Se vio que al llamar // a 'objDelegado' no importa si los métodos a añadir son //estáticos o públicos.

// Algunos atajos para añadir métodos a un objeto delegado.

objDelegado += objEstaClase.Metodo2DeEstaClase;

objDelegado += OtraClase.Metodo1DeOtraClase;

objDelegado(10, 20);

}

public static void Metodo1DeEstaClase(int parametro1, int parametro2)

{

Console.WriteLine("Se llama a un método estático 'Metodo1DeEstaClase' de esta clase");

Console.WriteLine("Muestra los argumentos: {0} y {1}", parametro1, parametro2);

}

public void Metodo2DeEstaClase(int parametro1, int parametro2)

{

Console.WriteLine("Se llama a 'Metodo2DeOtraClase' de esta clase");

Console.WriteLine("Muestra los argumentos: {0} y {1}", parametro1, parametro2);

}

public class OtraClase

{

public static void Metodo1DeOtraClase(int parametro1, int parametro2)

{

Console.WriteLine("Se llama a un método estático 'Metodo1DeOtraClase' de la clase 'OtraClase'");

Console.WriteLine("Muestra los argumentos: {0} y {1}", parametro1, parametro2);

}

public void Metodo2DeOtraClase(int parametro1, int parametro2)

{

Console.WriteLine("Se a llamado a 'Metodo2DeOtraClase' de un objeto de la clase OtraClase");

Console.WriteLine("Muestra estos argumentos: {0} y {1}", parametro1, parametro2);

}

A continuación la salida.

Se inicia el programa

Se añade al objeto delegado el método estático 'Metodo1DeOtraClase'

Se crea una instancia de la clase 'OtraClase'

Se añade al objeto delegado el método no estático 'Metodo2DeOtraClase'

Se añade al objeto delegado el método estático 'Metodo1DeEstaClase'

Se crea una instancia de la clase 'EstaClase'

Se añade al objeto delegado el método no estático 'Metodo2DeEstaClase'

Se llama a objDelegado objDelegado (8, 3);

Se llama a un método estático 'Metodo1DeOtraClase' de la clase 'OtraClase'

Muestra estos argumentos: 8 y 3

Se llama a 'Metodo2DeOtraClase' de un objeto de la clase OtraClase

Muestra estos argumentos: 8 y 3

Se llama a un método estático 'Método1DeEstaClase' de esta clase

Muestra estos argumentos: 8 y 3

Se llama a 'Metodo2DeOtraClase' de esta clase

Muestra estos argumentos: 8 y 3

Se llama a un método estático 'Metodo1DeOtraClase' de la clase 'OtraClase'