C# | delegados

Un delegado es un objeto que se refiere a un método o puede decir que es una variable de tipo de referencia que puede contener una referencia a los métodos. Los delegados en C# son similares al puntero de función en C/C++ . Proporciona una forma que indica qué método se llamará cuando se active un evento. 
Por ejemplo, si hace clic en un botón en un formulario (aplicación Windows Form), el programa llamará a un método específico. En palabras simples, es un tipo que representa referencias a métodos con una lista de parámetros particular y un tipo de retorno y luego llama al método en un programa para su ejecución cuando es necesario.
Puntos importantes sobre los delegados: 
 

• Proporciona una buena manera de encapsular los métodos.
• Los delegados son la clase de biblioteca en el espacio de nombres del sistema.
• Estos son los punteros de tipo seguro de cualquier método.
• Los delegados se utilizan principalmente para implementar los métodos y eventos de devolución de llamada.
• Los delegados se pueden enstringr juntos ya que se pueden llamar dos o más métodos en un solo evento.
• No le importa la clase del objeto al que hace referencia.
• Los delegados también se pueden utilizar en la invocación de «métodos anónimos».
• Los métodos anónimos (C# 2.0) y las expresiones Lambda (C# 3.0) se compilan para delegar tipos en ciertos contextos. A veces, estas características juntas se conocen como funciones anónimas.

Declaración de Delegados

El tipo de delegado se puede declarar usando la palabra clave delegado . Una vez que se declara un delegado, la instancia del delegado hará referencia y llamará a aquellos métodos cuyo tipo de devolución y lista de parámetros coincidan con la declaración del delegado.
Sintaxis: 
 

[modifier] delegate [return_type] [delegate_name] ([parameter_list]);

modificador: Es el modificador requerido que define el acceso del delegado y es opcional de usar.
delegado: Es la palabra clave que se utiliza para definir el delegado.
return_type: Es el tipo de valor devuelto por los métodos a los que va a llamar el delegado. Puede ser nulo. Un método debe tener el mismo tipo de retorno que el delegado.
delegado_nombre: es el nombre o identificador definido por el usuario para el delegado.
lista_parámetros: contiene los parámetros que requiere el método cuando se llama a través del delegado. 

Ejemplo: 
 

// "public" is the modifier
// "int" is return type
// "GeeksForGeeks" is delegate name
// "(int G, int F, int G)" are the parameters
public delegate int GeeksForGeeks(int G, int F, int G);

Nota: un delegado llamará solo a un método que esté de acuerdo con su firma y tipo de retorno. Un método puede ser un método estático asociado con una clase o puede ser un método de instancia asociado con un objeto, no importa. 
 

Creación de instancias e invocación de delegados

Después de declarar un delegado, se crea un objeto delegado con la ayuda de una nueva palabra clave. Una vez que se crea una instancia de un delegado, el delegado pasa una llamada de método realizada al delegado a ese método. Los parámetros pasados ​​al delegado por el autor de la llamada se pasan al método, y el valor de retorno, si lo hubiera, del método, se lo devuelve al autor de la llamada por parte del delegado. Esto se conoce como invocar al delegado. 
Sintaxis:
 

[delegate_name]  [instance_name] = new [delegate_name](calling_method_name);

Ejemplo: 
 

GeeksForGeeks GFG = new GeeksForGeeks (Geeks);
       // here,
       // "GeeksForGeeks" is delegate name. 
       // "GFG" is instance_name
       // "Geeks" is the calling method.

El siguiente programa ilustra el uso de Delegado:
 

// C# program to illustrate the use of Delegates
using System;
namespace GeeksForGeeks {
     
// declare class "Geeks"
class Geeks {
     
// Declaring the delegates
// Here return type and parameter type should
// be same as the return type and parameter type
// of the two methods
// "addnum" and "subnum" are two delegate names
public delegate void addnum(int a, int b);
public delegate void subnum(int a, int b);
     
    // method "sum"
    public void sum(int a, int b)
    {
        Console.WriteLine("(100 + 40) = {0}", a + b);
    }
 
    // method "subtract"
    public void subtract(int a, int b)
    {
        Console.WriteLine("(100 - 60) = {0}", a - b);
    }
 
// Main Method
public static void Main(String []args)
{
     
    // creating object "obj" of class "Geeks"
    Geeks obj = new Geeks();
 
    // creating object of delegate, name as "del_obj1"
    // for method "sum" and "del_obj2" for method "subtract" &
    // pass the parameter as the two methods by class object "obj"
    // instantiating the delegates
    addnum del_obj1 = new addnum(obj.sum);
    subnum del_obj2 = new subnum(obj.subtract);
 
    // pass the values to the methods by delegate object
    del_obj1(100, 40);
    del_obj2(100, 60);
 
    // These can be written as using
    // "Invoke" method
    // del_obj1.Invoke(100, 40);
    // del_obj2.Invoke(100, 60);
}
}
}

Producción: 
 

(100 + 40) = 140
(100 - 60) = 40

Explicación: En el programa anterior, hay dos delegados addnum y subnum . Estamos creando el objeto obj de la clase Geeks porque ambos métodos ( addnum y subnum ) son métodos de instancia. Entonces necesitan un objeto para llamar. Si los métodos son estáticos, no es necesario crear el objeto de la clase.
 

Multidifusión de un Delegado

La multidifusión de delegado es una extensión del delegado normal (a veces denominado delegado de transmisión única). Ayuda al usuario a señalar más de un método en una sola llamada.
Propiedades: 
 

• Los delegados se combinan y cuando llama a un delegado, se llama a una lista completa de métodos.
• Todos los métodos se llaman en orden Primero en entrar, primero en salir (FIFO).
• El operador ‘+’ o ‘+=’ se usa para agregar los métodos a los delegados.
• El operador ‘–’ o ‘-=’ se utiliza para eliminar los métodos de la lista de delegados.

Nota: Recuerde, la multidifusión de delegados debe tener un tipo de retorno de Vacío; de lo contrario, generará una excepción de tiempo de ejecución. Además, la multidifusión de delegado devolverá el valor solo del último método agregado en la multidifusión. Aunque, los otros métodos se ejecutarán con éxito.
El siguiente programa demuestra el uso de multidifusión de un delegado:
 

// C# program to illustrate the
// Multicasting of Delegates
using System;
 
class rectangle {
     
// declaring delegate
public delegate void rectDelegate(double height,
                                  double width);
 
    // "area" method
    public void area(double height, double width)
    {
        Console.WriteLine("Area is: {0}", (width * height));
    }
  
    // "perimeter" method
    public void perimeter(double height, double width)
    {
        Console.WriteLine("Perimeter is: {0} ", 2 * (width + height));
    }
  
  
// Main Method
public static void Main(String []args)
{
     
    // creating object of class
    // "rectangle", named as "rect"
    rectangle rect = new rectangle();
 
    // these two lines are normal calling
    // of that two methods
    // rect.area(6.3, 4.2);
    // rect.perimeter(6.3, 4.2);
 
    // creating delegate object, name as "rectdele"
    // and pass the method as parameter by
    // class object "rect"
    rectDelegate rectdele = new rectDelegate(rect.area);
     
    // also can be written as
    // rectDelegate rectdele = rect.area;
 
    // call 2nd method "perimeter"
    // Multicasting
    rectdele += rect.perimeter;
 
    // pass the values in two method
    // by using "Invoke" method
    rectdele.Invoke(6.3, 4.2);
    Console.WriteLine();
     
    // call the methods with
    // different values
    rectdele.Invoke(16.3, 10.3);
}
}

Producción: 
 

Area is: 26.46
Perimeter is: 21 

Area is: 167.89
Perimeter is: 53.2