Manufaturação industrial
Internet das coisas industrial | Materiais industriais | Manutenção e reparo de equipamentos | Programação industrial |
home  MfgRobots >> Manufaturação industrial >  >> Industrial programming >> Linguagem C

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 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) { 
            //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 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) { 
            //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 Vivo
using 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

  1. C# Hello World – Criando Sua Primeira Aplicação C#
  2. Entendendo Palavras-chave e Identificadores em C#: Regras, Listas e Boas Práticas
  3. Domine Variáveis e Tipos de Dados Primitivos em C#: Guia Completo
  4. Operadores em C# – Guia Completo dos Operadores em C#
  5. Quatro Padrões Comprovados para Funções Definidas pelo Usuário em C
  6. Como Passar Arrays 1D e 2D para Funções em C – Um Guia Prático
  7. IA no Centro do Economist Innovation Summit: Líderes Pedem Aumento, Não Substituição, de Habilidades Humanas
  8. Variáveis e Tipos de Dados em C++: Guia Completo sobre int, double, char, string, bool
  9. Dominando Funções em C: Estrutura, Declaração e Boas Práticas
  10. Uso Eficiente de Memória com Bit Fields em C