C# - Delegados

Delegados C# são semelhantes a ponteiros para funções, em C ou C++. Um delegado é uma variável de tipo de referência que contém a referência a um método. A referência pode ser alterada em tempo de execução.

Os delegados são usados ​​especialmente para implementar eventos e métodos de retorno de chamada. Todos os delegados são derivados implicitamente do System.Delegate classe.

Declarando Delegados

A declaração do delegado determina os métodos que podem ser referenciados pelo delegado. Um delegado pode fazer referência a um método, que tem a mesma assinatura do delegado.

Por exemplo, considere um delegado -

public delegate int MyDelegate (string s);

O delegado anterior pode ser usado para referenciar qualquer método que tenha uma única string parâmetro e retorna um int variável de tipo.

A sintaxe para declaração de delegado é -

delegate <return type> <delegate-name> <parameter list>

Instanciando delegados

Uma vez que um tipo de delegado é declarado, um objeto delegado deve ser criado com o novo palavra-chave e ser associado a um método específico. Ao criar um delegado, o argumento passado para o novo expressão é escrita de forma semelhante a uma chamada de método, mas sem os argumentos para o método. Por exemplo -

public delegate void printString(string s);
...
printString ps1 = new printString(WriteToScreen);
printString ps2 = new printString(WriteToFile);

O exemplo a seguir demonstra a declaração, a instanciação e o uso de um delegado que pode ser usado para referenciar métodos que usam um parâmetro inteiro e retornam um valor inteiro.
Demonstração ao vivo

using System;

delegate int NumberChanger(int n);
namespace DelegateAppl {
   
   class TestDelegate {
      static int num = 10;
      
      public static int AddNum(int p) {
         num += p;
         return num;
      }
      public static int MultNum(int q) {
         num *= q;
         return num;
      }
      public static int getNum() {
         return num;
      }
      static void Main(string[] args) {
         //create delegate instances
         NumberChanger nc1 = new NumberChanger(AddNum);
         NumberChanger nc2 = new NumberChanger(MultNum);
         
         //calling the methods using the delegate objects
         nc1(25);
         Console.WriteLine("Value of Num: {0}", getNum());
         nc2(5);
         Console.WriteLine("Value of Num: {0}", getNum());
         Console.ReadKey();
      }
   }
}

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

Value of Num: 35
Value of Num: 175

Multicast de um delegado

Objetos delegados podem ser compostos usando o operador "+". Um delegado composto chama os dois delegados dos quais foi composto. Somente delegados do mesmo tipo podem ser compostos. O operador "-" pode ser usado para remover um delegado de componente de um delegado composto.

Usando essa propriedade de delegados, você pode criar uma lista de invocação de métodos que serão chamados quando um delegado for invocado. Isso é chamado de multicast de um delegado. O programa a seguir demonstra o multicast de um delegado -
Demonstração ao vivo

using System;

delegate int NumberChanger(int n);
namespace DelegateAppl {
   class TestDelegate {
      static int num = 10;
      
      public static int AddNum(int p) {
         num += p;
         return num;
      }
      public static int MultNum(int q) {
         num *= q;
         return num;
      }
      public static int getNum() {
         return num;
      }
      static void Main(string[] args) {
         //create delegate instances
         NumberChanger nc;
         NumberChanger nc1 = new NumberChanger(AddNum);
         NumberChanger nc2 = new NumberChanger(MultNum);
         
         nc = nc1;
         nc += nc2;
         
         //calling multicast
         nc(5);
         Console.WriteLine("Value of Num: {0}", getNum());
         Console.ReadKey();
      }
   }
}

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

Value of Num: 75

Usando delegados

O exemplo a seguir demonstra o uso de delegate. O delegado printString pode ser usado para referenciar o método que recebe uma string como entrada e não retorna nada.

Usamos esse delegado para chamar dois métodos, o primeiro imprime a string no console e o segundo imprime em um arquivo -
Demonstração ao vivo

using System;
using System.IO;

namespace DelegateAppl {

   class PrintString {
      static FileStream fs;
      static StreamWriter sw;
      
      // delegate declaration
      public delegate void printString(string s);

      // this method prints to the console
      public static void WriteToScreen(string str) {
         Console.WriteLine("The String is: {0}", str);
      }
      
      //this method prints to a file
      public static void WriteToFile(string s) {
         fs = new FileStream("c:\\message.txt",
         FileMode.Append, FileAccess.Write);
         sw = new StreamWriter(fs);
         sw.WriteLine(s);
         sw.Flush();
         sw.Close();
         fs.Close();
      }
      
      // this method takes the delegate as parameter and uses it to
      // call the methods as required
      public static void sendString(printString ps) {
         ps("Hello World");
      }
      
      static void Main(string[] args) {
         printString ps1 = new printString(WriteToScreen);
         printString ps2 = new printString(WriteToFile);
         sendString(ps1);
         sendString(ps2);
         Console.ReadKey();
      }
   }
}

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

The String is: Hello World