Entendendo Delegates em C#: Guia de Referências de Funções e Eventos
Os delegates em C# são semelhantes a ponteiros de funções em C ou C++. Um delegate é uma variável de tipo de referência que mantém a referência a um método. Essa referência pode ser alterada em tempo de execução.
Delegates são especialmente usados para implementar eventos e métodos de callback. Todos os delegates são implicitamente derivados da classe System.Delegate.
Declarando Delegates
A declaração de um delegate determina quais métodos podem ser referenciados por ele. Um delegate pode referenciar um método que tenha a mesma assinatura do delegate.
Por exemplo, considere um delegate:
public delegate int MeuDelegate(string s);
O delegate acima pode ser usado para referenciar qualquer método que tenha um único parâmetro string e retorne uma variável do tipo int.
Sintaxe para declaração de delegate:
delegate <tipo de retorno> <nome-do-delegate> <lista de parâmetros>
Instanciando Delegates
Uma vez declarado o tipo delegate, um objeto delegate deve ser criado com a palavra-chave new e associado a um método específico. Ao criar um delegate, o argumento passado para a expressão new é escrito de forma semelhante a uma chamada de método, mas sem os argumentos do método. Por exemplo:
public delegate void printString(string s); printString ps1 = new printString(EscreverNaTela); printString ps2 = new printString(EscreverNoArquivo);
O exemplo a seguir demonstra declaração, instanciação e uso de um delegate que pode referenciar métodos que recebem um parâmetro inteiro e retornam um valor inteiro.
Demo ao Vivousing 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) {
//cria instâncias do delegate
NumberChanger nc1 = new NumberChanger(AddNum);
NumberChanger nc2 = new NumberChanger(MultNum);
//chama os métodos usando os objetos delegate
nc1(25);
Console.WriteLine("Valor de Num: {0}", getNum());
nc2(5);
Console.WriteLine("Valor de Num: {0}", getNum());
Console.ReadKey();
}
}
}
Quando o código acima é compilado e executado, produz o seguinte resultado:
Valor de Num: 35 Valor de Num: 175
Multicasting de um Delegate
Objetos delegate podem ser compostos usando o operador "+". Um delegate composto chama os dois delegates dos quais foi composto. Apenas delegates do mesmo tipo podem ser compostos. O operador "-" pode ser usado para remover um delegate componente de um delegate composto.
Usando essa propriedade dos delegates, você pode criar uma lista de invocação de métodos que serão chamados quando um delegate for invocado. Isso é chamado de multicasting de um delegate. O programa a seguir demonstra multicasting de um delegate:
Demo ao Vivousing 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) {
//cria instâncias do delegate
NumberChanger nc;
NumberChanger nc1 = new NumberChanger(AddNum);
NumberChanger nc2 = new NumberChanger(MultNum);
nc = nc1;
nc += nc2;
//chamando multicast
nc(5);
Console.WriteLine("Valor de Num: {0}", getNum());
Console.ReadKey();
}
}
}
Quando o código acima é compilado e executado, produz o seguinte resultado:
Valor de Num: 75
Usando Delegates
O exemplo a seguir demonstra o uso de delegate. O delegate printString pode ser usado para referenciar método que recebe uma string como entrada e não retorna nada.
Usamos este delegate para chamar dois métodos: o primeiro imprime a string no console, e o segundo imprime em um arquivo:
Demo ao Vivousing System;
using System.IO;
namespace DelegateAppl {
class PrintString {
static FileStream fs;
static StreamWriter sw;
// declaração do delegate
public delegate void printString(string s);
// este método imprime no console
public static void WriteToScreen(string str) {
Console.WriteLine("A String é: {0}", str);
}
//este método imprime em um arquivo
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();
}
// este método recebe o delegate como parâmetro e o usa para
// chamar os métodos conforme necessário
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, produz o seguinte resultado:
A String é: Hello World
Linguagem C
- C# Hello World – Criando Sua Primeira Aplicação C#
- Entendendo Palavras-chave e Identificadores em C#: Regras, Listas e Boas Práticas
- Domine Variáveis e Tipos de Dados Primitivos em C#: Guia Completo
- Operadores em C# – Guia Completo dos Operadores em C#
- Quatro Padrões Comprovados para Funções Definidas pelo Usuário em C
- Como Passar Arrays 1D e 2D para Funções em C – Um Guia Prático
- IA no Centro do Economist Innovation Summit: Líderes Pedem Aumento, Não Substituição, de Habilidades Humanas
- Variáveis e Tipos de Dados em C++: Guia Completo sobre int, double, char, string, bool
- Dominando Funções em C: Estrutura, Declaração e Boas Práticas
- Uso Eficiente de Memória com Bit Fields em C