Tutorial CSharp: Delegados

Los delegados en C# son un tipo especial de objeto que puede contener una referencia a un método. En otros términos, un delegado es una especie de puntero seguro a un método. Los delegados en C# son similares a las funciones de puntero en C o C++, pero son más seguros y más orientados a objetos.

Los delegados tienen un tipo que se define por la firma del método que pueden almacenar, es decir, los tipos de los parámetros y el tipo de retorno del método. Una vez definido un delegado, este puede hacer referencia a cualquier método que tenga una coincidencia con el tipo de delegado.

Declaración y uso de delegados

La declaración de un delegado se realiza con la palabra clave delegate, seguida del tipo de retorno y la firma del método. Por ejemplo, el siguiente delegado puede hacer referencia a cualquier método que no tome parámetros y no devuelva ningún valor:

public delegate void SimpleDelegate();

Para utilizar este delegado, primero debe definirse un método que coincida con su firma:

public void MiMetodo()
{
    Console.WriteLine("¡Hola desde MiMetodo!");
}

A continuación, se puede crear una instancia del delegado, pasando el método que se desea referenciar al constructor del delegado:

SimpleDelegate miDelegado = new SimpleDelegate(MiMetodo);

Y ahora puede usarse el delegado para llamar al método:

miDelegado();

Esto imprimirá "¡Hola desde MiMetodo!" en la consola.

Delegados con parámetros y retorno

Los delegados pueden tener parámetros y devolver valores. La firma del delegado debe coincidir con la firma del método. Por ejemplo, el siguiente delegado puede referenciar a cualquier método que tome un int como parámetro y devuelva un int:

public delegate int DelegadoConParametro(int num);

Y puede usarse con un método que coincida con esta firma:

public int Duplicar(int num)
{
    return num * 2;
}

DelegadoConParametro miDelegado = new DelegadoConParametro(Duplicar);
int resultado = miDelegado(4);
Console.WriteLine(resultado);  // Imprime "8"

Delegados predefinidos

C# proporciona algunos delegados predefinidos que pueden se usados para evitar la necesidad de declarar delegados propios. Los más comunes son Action, Func y Predicate.

• Action se utiliza para métodos que no devuelven un valor. Action puede tener de 0 a 16 parámetros de tipo, que se declaran entre <>.

Action<string> miAccion = (s) => Console.WriteLine(s);
miAccion("Hola, mundo!");

En el ejemplo anterior, un Action puede referenciar cualquier método que reciba un único string y no devuelva nada. Se le asigna una lambda que recibe un string s como parámetro, y lo imprime sin devolver nada.

• Func se utiliza para métodos que devuelven un valor. Func puede tener de 0 a 16 parámetros de tipo, y el último tipo es el tipo de retorno.

Func<int, int, int> sumar = (a, b) => a + b;
int resultado = sumar(3, 4);  // resultado es 7

En el ejemplo anterior, un Func<int, int, int> puede referenciar cualquier método que reciba dos int y devuelva un int. Se le asigna una lambda que recibe dos int a y b, y devuelve su suma.

• Predicate se utiliza para métodos que toman un parámetro y devuelven un bool.

Predicate<int> esPar = num => num % 2 == 0;
bool resultado = esPar(4);  // resultado es true

En resumen, los delegados son una característica muy útil y flexible de C# que permiten una programación más dinámica y orientada a eventos.