Olá pessoal, neste artigo veremos os conceitos e exemplos do Delegate e como invoca-lo. Veremos também os Métodos Anônimos da linguagem C#. Acompanhem:
Introdução – O Delegate é um tipo de variável que guarda o endereço de um método. A principal utilidade dele é centrada no uso dos eventos. Em um determinado evento, uma classe dispara uma mensagem que será executada por um método em tempo de execução. O Delegate entra com a responsabilidade de guardar o endereço de memória onde se encontra este método.
As classes do Delegate oferecem uma interface pública que permite inicializar, adicionar, remover e invocar delegates.
A palavra-chave delegate tem a finalidade de definir delegates novos. Veja a sintaxe para a definição de uma classe delegate nova:
Modificador_de_Acesso delegate Tipo_de_Retorno Nome_do_Delegate()
Agora veja esta sintaxe aplicada a um exemplo:
public delegate void exemploDelegate();
No exemplo acima criamos um delegate com o nome exemploDelegate, que pode apontar para qualquer método que não receba nenhum parâmetro e seja do tipo void (sem retorno). Uma variável do tipo exemploDelegate pode receber o endereço de um método em tempo de execução.
Só reforçando: para uma variável apontar para um método com a assinatura declarada no delegate do exemplo acima, são necessárias duas coisas: uma instância desta classe e um método que tenha a mesma assinatura (lembrando que deve ser do tipo void e não receber quaisquer parâmetros). Veja o exemplo abaixo que ilustra melhor os conceitos:
public delegate void exemploDelegate();
static void MetodoUm()
{
//Comandos
}
exemploDelegate objInstancia = new exemploDelegate(MetodoUm);
void MetodoDois()
{
//Comandos
}
void MetodoTres()
{
objInstancia();
}
No exemplo acima, o MetodoUm é chamado através da variável objInstancia. Neste caso, não vemos muita vantagem, já que poderíamos chamar o método diretamente. Mais em casos específicos, os delegates oferecem meio elegantes de resolver problemas de lógica, principalmente quando o método a ser executado é desconhecido, ou mesmo quando depende de alguma ação do usuário.
Obs: note no exemplo acima que declarei o MetodoUm com o modificador static, indicando que o mesmo é estático. Veja abaixo o que acontece se eu não fizer isso:
Invocando um Delegate – Podemos invocar um delegate de duas formas:
· Por meio do operador de chamada “()”;
· Por meio do método Invoke.
O operador de chamada é convertido dentro de uma invocação do método Invoke, o qual possui assinatura igual ao do delegate e chama os ponteiros de função contidos no delegate. Esta conversão é feita pelo compilador do C#.
Importante destacar que os parâmetros do delegate tornam-se os parâmetros e a entrada para as chamadas de função. Existe ainda a possibilidade do delegate conter um ponteiro de função. Caso isto ocorra, o retorno daquela função torna-se o retorno do delegate.
Seguindo a ideia do exemplo apresentando anteriormente, podemos chamar o delegate de uma dessas duas maneiras:
void MetodoTres()
{
objInstancia();
//ou
objInstancia.Invoke();
}
Métodos Anônimos – Métodos anônimos são métodos que não tem um nome e são definidos diretamente através de um delegate. Eles não estão ligados a uma função ou método. Confira o exemplo a seguir que esclarece melhor:
private delegate void exemploDelegate();
private exemploDelegate objInstancia = delegate
{
Console.WriteLine("Exemplo de método anônimo");
};
Assim podemos chamar este método em qualquer parte do programa. A vantagem disso tudo é que a variável objInstancia pode assumir outro endereço no decorrer da execução do programa ou pode ser passada como parâmetro para um método.
O uso ou não de assinaturas por parte dos métodos anônimos pode ou não ter vantagens, conforme vemos abaixo:
· Quando um método anônimo não possui uma assinatura, a vantagem é que ele não obedece a quase nenhum delegate;
· Nessa situação, a desvantagem é que o método anônimo não tem permissão para acessar os parâmetros dos delegates, ou seja, os métodos anônimos não podem usar os parâmetros.
Finalizando, é importante sabermos que, sempre que um método anônimo for chamado por meio de delegates, os parâmetros devem ainda ser fornecidos. Isso deve ocorrer mesmo que os parâmetros sejam ignorados dentro do método. Caso o delegate não tenha parâmetros, logicamente nenhum parâmetro deverá ser informado.
Fonte de Consulta: Apostila de C#, da Impacta Tecnologia.
Assim finalizo o artigo. Na próxima parte veremos os conceitos dos Eventos, como divulgá-los e como subscrevê-los, não percam!
Um abraço, e até o próximo artigo.
Wellington Balbo de Camargo
