C# - Tratando um evento com uma função anônima
Hoje veremos como podemos tratar um evento sem definir um método mas usando um delegate anônimo ou uma expressão lambda.

Suponha que você deseja tratar um evento em seu programa mas não quer definir um método para fazer isso. 

Qual a alternativa viável ?

Podemos criar um delegate para um manipulador de eventos anônimo, e assim não precisamos definir um método separado para o delegate invocar.

Para adicionar um delegate anônimo, passe os argumentos do método para a palavra-chave delegate e implemente o corpo do método entre chaves.

O trecho de código a  seguir demonstra como se registrar para um evento usando um delegate anônimo:

MeuEvento+ = new EventHandler (delegate (object sender, EventArgs eventargs)
{
     //... implementar corpo do método ...
});

Os delegates anônimos simplificam o código-fonte onde você não precisa compartilhar uma implementação entre manipuladores e onde você não precisa se registrar para o evento - não é possível cancelar o registro porque você não tem uma referência para cancelar o registro ao usar delegados anônimos.

Você também pode manipular eventos usando uma expressão lambda, que é outra forma de função anônima.

As expressões lambda usam o operador lambda, =>, que é lido como "vai para".

À esquerda da expressão, você lista nomes para as variáveis ​​que serão passadas para sua expressão e, à direita, escreve o código que você deseja executar, consultando as variáveis ​​que você definiu conforme necessário.

A seguir temos um exemplo de como usar uma expressão lambda para manipular um evento:

MeuEvento+ = new EventHandler ( (sender, eventargs) =>
{
     //... implementar corpo do método ...
});

Com uma expressão lambda, o compilador calcula quais os tipos de variáveis à esquerda do sinal (=>) "vai para" deve ser, portanto; você só precisa especificar os nomes que deseja usar.

Lembrando que na abordagem padrão, para assinar eventos via código precisamos definir um método de manipulador de eventos cuja assinatura corresponda à assinatura de delegate para o evento.

A seguir temos o método:

void TrataEvento(object sender, CustomEventArgs a)  
{  
   //--corpo do método...
}  

A seguir usamos o operador de atribuição de adição (+=) para anexar um manipulador de eventos ao evento.

recursos usados:

  • Visual Basic 2019 Community Edition

Criando o projeto C# no VS 2019

Crie um projeto Console do tipo .NET Core chamado CShp_TrataEvento1;

No método Main da classe Program vamos incluir o código a seguir onde usamos a abordagem padrão com um método nomeado para manipular um evento e também como usar um delegate anônimo e uma expressão lambda:

Executando o projeto teremos:

Concluindo...

Se você não precisar cancelar a inscrição em um evento posteriormente, poderá usar o operador de atribuição de adição (+=) para anexar um método anônimo ao evento ou usar uma expressão lambda.

Agora muita atenção...!!!

É uma boa prática cancelar a inscrição de um evento antes de descartar o objeto assinante para evitar vazamento de recursos.

Até você cancelar a inscrição de um evento, o delegate multicast subjacente ao evento no objeto de publicação tem uma referência ao delegate que encapsula o manipulador de eventos do assinante. Enquanto o objeto de publicação contiver essa referência, a coleta de lixo não excluirá o objeto de assinante.

Para cancelar a inscrição em um evento use o operador ( -= ) :


   MeuEvento -= new EventHandler(EventHandlerMethod);
 

E estamos conversados...

"Se o mundo vos odeia, sabei que, primeiro do que a vós, me odiou a mim.
Se vós fôsseis do mundo, o mundo amaria o que era seu, mas porque não sois do mundo, antes eu vos escolhi do mundo, por isso é que o mundo vos odeia."

João 15:18,19

Referências:


José Carlos Macoratti