7. Delegates, lambdas e eventos
No curso de 2008, este capítulo vinha depois do capítulo sobre interfaces gráficas Windows Forms: os eventos eram introduzidos primeiro no contexto de botões e formulários, e só depois os alunos aprendiam a criar eventos em suas próprias classes. O capítulo sobre interfaces gráficas foi removido desta versão do curso. Começamos, portanto, diretamente pelo conceito que sustenta todo o mecanismo: o delegate, isto é, um objeto que referencia um ou mais métodos. Todos os exemplos são programas de console.
Nos últimos vinte anos, os delegates tornaram-se uma das ferramentas mais usadas da linguagem. Escrevê-los ficou consideravelmente mais simples com as expressões lambda (C# 3), que já usamos — sem entrar em detalhes — com o LINQ no Capítulo 5: [Where(n => n > 5)] passa uma lambda — e portanto um delegate — ao método [Where]. Este capítulo explica o que há por trás dessa sintaxe. Ele termina com os eventos, que também se baseiam em delegates. As interfaces gráficas do .NET (Windows Forms, WPF, .NET MAUI), assim como os frameworks web, baseiam-se nesse mecanismo: um clique de botão ou a chegada de uma requisição HTTP são sinalizados aos métodos inscritos.
Os programas deste capítulo são aplicações de arquivo único localizadas na pasta [07-delegates]. Eles são executados com [dotnet run delegates-NN.cs].
7.1. Tipos de delegate predefinidos
7.1.1. O conceito de delegate
Um tipo de delegate descreve um modelo (também chamado de protótipo ou assinatura) de método: os tipos de seus parâmetros e o tipo de seu valor de retorno. Uma variável de um tipo de delegate pode então referenciar qualquer método que corresponda a esse modelo e executá-lo.
O framework .NET define numerosos tipos de delegate. O mais antigo é [EventHandler], usado por todos os eventos de que trataremos no final deste capítulo. Ele é definido da seguinte forma:
A palavra-chave [delegate] faz de [EventHandler] um tipo de delegate. Esse tipo designa um padrão de método:
- cujo primeiro parâmetro é um objeto do tipo [object?] (o objeto que disparou o evento, possivelmente [null]);
- cujo segundo parâmetro é um objeto do tipo [EventArgs] (informações sobre o evento);
- que não retorna resultado ([void]).
Um método que corresponde ao modelo definido por [EventHandler] poderia ser o seguinte:
Para criar um objeto do tipo [EventHandler] que referencia esse método, pode-se escrever:
ou, de forma mais simples:
Nesta segunda notação, o nome do método [Display] (um grupo de métodos, já que um método pode ter várias sobrecargas) é convertido automaticamente pelo compilador em um objeto [EventHandler]: trata-se da conversão de grupo de métodos, possível desde o C# 2. O compilador seleciona, entre as sobrecargas de [Display], a que corresponde à assinatura do delegate. O delegate é então executado como um método: [handler("program", EventArgs.Empty)].
7.1.2. Os delegates genéricos Func, Action e Predicate
Antes dos genéricos (C# 2), era preciso definir um tipo de delegate para cada assinatura de método. Hoje, o framework fornece tipos de delegate genéricos que cobrem quase todas as necessidades:
Tipo de delegate | Métodos referenciados |
[Action] | Sem parâmetros, sem valor de retorno: [void M()] |
[Action<T1, ..., T16>] | De 1 a 16 parâmetros, sem resultado: [void M(T1 p1, ...)] |
[Func<TResult>] | Sem parâmetros, com um resultado: [TResult M()] |
[Func<T1, ..., T16, TResult>] | De 1 a 16 parâmetros, com um resultado do tipo [TResult] (sempre o último tipo) |
[Predicate<T>] | um parâmetro, com resultado booleano: [bool M(T p)] |
[Comparison<T>] | dois parâmetros do mesmo tipo, com resultado inteiro: [int M(T x, T y)] |
[Predicate<T>] e [Func<T, bool>] descrevem a mesma assinatura, mas são dois tipos diferentes: [Predicate<T>] data do .NET 2 e é usado pelos métodos de [List<T>] e [Array] ([FindAll], [RemoveAll], [Exists]…), ao passo que o LINQ, introduzido com o .NET 3.5, usa [Func<T, bool>].
O programa [delegates-01.cs] usa esses tipos de delegate:
Resultados:
Comentários:
- linha 4: criação de um delegate [EventHandler] com o operador [new]. Essa era a sintaxe obrigatória no C# 1;
- linha 6: a mesma coisa com uma conversão de grupo de métodos. Essa é hoje a sintaxe padrão;
- linha 8: o delegate é executado como um método. O método [Display] da linha 39 é executado, com os parâmetros passados ao delegate;
- linha 11: [Func<int, int, int>] refere-se a um método com dois parâmetros, [int], e que retorna um [int] (o último tipo genérico). O método [Add] da linha 44 é adequado;
- linha 14: [Func<string>] refere-se a um método sem parâmetros que retorna uma string;
- linha 18: [Action<string>] refere-se a um método com um parâmetro, [string], e sem valor de retorno. [Console.WriteLine] tem muitas sobrecargas; o compilador escolhe [WriteLine(string)];
- linha 22: um predicado é um método que retorna um booleano. O método [FindAll] da classe [List<T>] (linha 25) espera um parâmetro do tipo [Predicate<T>]: ele retorna a lista dos elementos para os quais o predicado retorna [true]. Linha 26: o nome do método
[IsEven]é passado diretamente; o compilador o converte em*[Predicate<int>]*; - linha 31: o método [Sort] aceita um delegate [Comparison<T>] que compara dois elementos (resultando em valor negativo, zero ou positivo, como [CompareTo]). Aqui, os nomes são ordenados em ordem crescente de comprimento;
- linhas 35–36: um delegate é um objeto. Seu tipo, exibido na linha 9 dos resultados, é [System.Func`3[System.Int32,System.Int32,System.Int32]]: o nome técnico de um tipo genérico com três parâmetros de tipo. Todo tipo de delegate deriva da classe [System.Delegate], que fornece, em particular, as propriedades [Method] (o método referenciado) e [Target] (o objeto sobre o qual o método é chamado, [null] para um método estático);
- o nome do método, na linha 10 da saída, é surpreendente: os métodos das linhas 39–50 são funções locais do programa principal (veja o Capítulo 3). O compilador os transforma em métodos estáticos de uma classe que ele gera, com um nome que nenhum programa C# pode escrever.
7.2. Definição de tipos de delegate
Os tipos predefinidos costumam bastar, mas você pode definir seus próprios tipos de delegate. A instrução:
define um tipo chamado [Operation], que representa um modelo de método que recebe dois inteiros e retorna um inteiro. Em comparação com [Func<int, int, int>], o tipo [Operation] tem um nome que descreve sua finalidade, e seus parâmetros têm nomes ([n1], [n2]) que as ferramentas de desenvolvimento exibem.
Uma variável [op] do tipo [Operation] serve para armazenar uma lista de métodos correspondentes ao modelo [Operation]: fala-se então de um delegate multicast.
- Um método do tipo [f] é armazenado na variável [op] com [op = new Operation(f)] ou, mais simplesmente, [op = f];
- Para adicionar um método [g] à lista de métodos já registrados, escreva [op += g];
- Para remover um método [h] já registrado, escreva [op -= h];
- A instrução [n = op(n1, n2)] executa, na ordem em que foram registrados, todos os métodos registrados em [op], usando os parâmetros [n1] e [n2]. O resultado retornado [n] é o do último método executado.
O curso de 2008 afirmava que não é possível obter os resultados de todos os métodos. É possível, mas não com uma única chamada: é preciso percorrer a lista de métodos retornada por [GetInvocationList] e chamá-los um a um. Na prática, os métodos registrados em um delegate multicast quase sempre retornam [void].
Considere o exemplo [delegates-02.cs]:
Resultados:
Comentários:
- linha 73: definição do tipo de delegate [Operation]. Em uma aplicação com instruções de nível superior, as declarações de tipos (classes, interfaces, delegates etc.) são colocadas depois das instruções do programa principal;
- linhas 48–67: a classe [Calculations] tem dois métodos de instância, [Add] e [Subtract], e um método estático, [Increase], todos os três com a assinatura do tipo [Operation];
- linha 5: a variável [op] é do tipo [Operation]. Atribui-se a ela uma primeira referência de método, a do método estático [Calculations.Increase];
- linha 7: o delegate [op] é executado. Todos os métodos referenciados por [op] são executados, com os parâmetros passados a [op]. Aqui, apenas o método [Calculations.Increase] é executado;
- linha 11: é criada uma instância [c1] da classe [Calculations] ;
- linha 13: o método de instância [c1.Add] é atribuído ao delegate [op]. [Increase] era um método estático, [Add] é um método de instância: não faz diferença. No segundo caso, o delegate também armazena o objeto [c1] (sua propriedade [Target]) sobre o qual o método será chamado;
- linha 18: fazemos o mesmo para o método de instância [Subtract];
- linhas 23–24: registramos os dois métodos [Add] e [Subtract] no delegate [op];
- linha 26: os dois métodos são executados (linhas 8–9 dos resultados). O resultado obtido, 6, é o de [Subtract], o último método executado;
- linhas 29–31: [GetInvocationList] retorna a lista de métodos do delegate como um array [Delegate[]]. O método LINQ [Cast<Operation>()] converte cada um de seus elementos em [Operation], o que permite chamá-los um a um e recuperar cada resultado;
- linha 34: o método
[Subtract]é removido do delegate. A notação***[op -= c1.Subtract]equivale a***[op = op - c1.Subtract]***. O resultado do operador [-] é do tipo [Operation?]: se removermos o último método de um delegate, obtemos [null]*, e não um delegate vazio. O compilador, que acompanha os tipos anuláveis (veja o Capítulo 3), emitiria avisos se você escrevesse [op -= c1.Subtract] seguido de [op(1, 1)]: [CS8601] ao atribuir um valor potencialmente nulo à variável não anulável [op], e [CS8602] ao chamar o método. Por isso armazenamos o resultado em uma variável do tipo [Operation?] e o verificamos antes de executá-lo (linha 36); - linha 42: removemos o último método; o delegate resultante é [null] (linha 17 dos resultados);
- linha 45: um delegate também pode ser executado por meio de seu método [Invoke]: [op(1, 1)] e [op.Invoke(1, 1)] são equivalentes. Com o operador [?.] (C# 6), [empty?.Invoke(1, 1)] executa o delegate somente se ele não for [null]; caso contrário, a expressão resulta em [null] e nada é executado. A interpolação de strings representa [null] como uma string vazia. Voltaremos a essa sintaxe ao tratar de eventos.
Um delegate é um objeto imutável: as operações [+] e [-] (e, portanto, [+=] e [-=]) não modificam o delegate existente; elas criam um novo. Essa propriedade será importante ao tratarmos de eventos.
7.3. Métodos anônimos e expressões lambda
7.3.1. Dos métodos anônimos às lambdas
Nos exemplos anteriores, cada delegate referencia um método nomeado escrito em outro ponto do programa. Para métodos curtos usados uma só vez, isso é trabalhoso. O C# 2 introduziu os métodos anônimos: o corpo do método é escrito no ponto exato em que o delegate é criado. O C# 3 introduziu uma sintaxe ainda mais concisa — as expressões lambda —, que praticamente substituíram os métodos anônimos. O programa [delegates-03.cs] demonstra as diferentes formas:
Resultados:
Comentários:
- linhas 4–6: um método anônimo. A palavra-chave [delegate] é seguida da lista de parâmetros e do corpo do método. O compilador gera um método (com um nome de sua escolha) e cria um delegate [Func<int, int, int>] que o referencia. Não há nome de método nem tipo de retorno: o tipo de retorno é inferido das instruções [return];
- linhas 11–13: a mesma coisa com uma expressão lambda. Escrevemos a lista de parâmetros, o operador [=>] (que se lê “resulta em” ou “tal que”) e, em seguida, o corpo. Uma lambda cujo corpo é um bloco delimitado por chaves é uma lambda com corpo em bloco (statement lambda);
- linha 18: os tipos dos parâmetros estão ausentes. O compilador os infere a partir do tipo de delegate de destino [Func<int, int, int>]: [n1] e [n2] são do tipo [int]. O corpo se reduz a uma expressão, cujo valor é o resultado da lambda: trata-se de uma lambda com corpo de expressão (lambda expression). Esta é a forma mais comum;
- linha 22: com um único parâmetro cujo tipo não é especificado, os parênteses são opcionais. [x => x * x] lê-se “x resulta em x vezes x”. Linha 23: a mesma lambda de parâmetro único, do tipo [string], retorna um booleano: é um [Predicate<string>];
- linhas 27–28: sem parâmetros, usam-se parênteses vazios. Uma lambda cujo corpo é uma chamada de método ([void]) é adequada para um delegate ([Action]);
- linhas 33–39: uma lambda com corpo em bloco pode conter quaisquer instruções: declarações, laços, testes etc.;
- linha 44: o caractere sublinhado [_] designa um parâmetro ignorado (discard, C# 9). Ele é usado quando a assinatura do delegate exige parâmetros de que a lambda não precisa, o que é comum em manipuladores de eventos;
- linha 49: o uso mais comum das lambdas é passá-las diretamente como parâmetros a um método que espera um delegate. Compare com [delegates-01.cs]: não é mais necessário escrever um método [IsEven];
- linha 50: uma lambda do tipo [Comparison<int>] que inverte a comparação usual: a lista é ordenada em ordem decrescente.
Vamos rever as formas de uma expressão lambda:
Forma | Exemplo |
parâmetros tipados, corpo em bloco | [(int a, int b) => { return a + b; }] |
parâmetros sem tipo, corpo de expressão | [(a, b) => a + b] |
um único parâmetro sem tipo | [x => x * x] |
sem parâmetros | [() => "Hello"] |
parâmetros ignorados | [(_, _) => Console.WriteLine("received")] |
Os parâmetros são todos tipados ou todos sem tipo: não é possível misturar os dois. Neste curso, usaremos lambdas em vez de métodos anônimos, que hoje só têm utilidade em casos raros.
7.3.2. Mais sobre lambdas
As versões recentes do C# aprimoraram as lambdas. O programa [delegates-04.cs] demonstra esses novos recursos:
Resultados:
Comentários:
- linha 4: até o C# 9, uma lambda não tinha um tipo próprio: era sempre preciso especificar o tipo de delegate de destino ([Func<int, int> twice = x => x * 2]). Desde o C# 10, uma lambda com parâmetros tipados tem um tipo natural: aqui, [Func<int, int>], como mostra a linha 2 dos resultados. Podemos, portanto, escrever [var]. No entanto, [var twice = x => x * 2;] é rejeitado pelo compilador, que não consegue inferir o tipo de [x];
- linha 6: o tipo natural de uma lambda que não retorna nada é um [Action<...>];
- linha 10: um grupo de métodos também tem um tipo natural, desde que exista apenas um método com esse nome. [var write = Console.WriteLine;] seria rejeitado: [WriteLine] tem cerca de vinte sobrecargas;
- linha 14: desde o C# 10, é possível especificar o tipo de retorno antes da lista de parâmetros. Isso é necessário aqui: os dois ramos do operador condicional têm tipos diferentes ([int] e [string]), e o compilador não saberia qual tipo de retorno escolher;
- linha 18: a partir do C# 12, os parâmetros de uma lambda podem ter valores padrão, assim como os parâmetros de métodos. As linhas 19–20 chamam a lambda com e sem o segundo parâmetro;
- linha 22: da mesma forma, o último parâmetro de uma lambda pode ser [params];
- linha 25: nem os tipos [Func] nem [Action] conseguem representar um parâmetro opcional ou [params]. O compilador gera então um tipo de delegate anônimo, neste caso [<>f__AnonymousDelegate0] (linha 10 dos resultados). Ele só pode ser usado com [var];
- linha 29: uma lambda declarada como [static] (C# 9) não pode usar as variáveis locais do método que a contém nem [this]. Ela pode usar constantes, como [Coefficient] na linha 28. Veremos na próxima seção o que significa “usar uma variável local”; a palavra-chave [static] garante que uma lambda não captura nenhuma, o que evita alocação de memória e erros;
- linha 58: um tipo de delegate cujo parâmetro é passado por referência ([ref], veja o Capítulo 3). Os tipos [Func] e [Action] não admitem parâmetros dos tipos [ref] ou [out]: é preciso definir seu próprio tipo de delegate;
- linha 34: até o C# 13, uma lambda cujo parâmetro fosse [ref], [out], ou [in] precisava tipar explicitamente todos os seus parâmetros, como em [(ref int x) => x++]. A partir do C# 14, o modificador sozinho basta, pois o tipo é inferido do delegate de destino. As linhas 36–37 incrementam duas vezes a variável [counter];
- linha 39: a mesma coisa com um parâmetro [out]. A lambda passa seu parâmetro [out] a [int.TryParse];
- linhas 44–52: uma função utilitária que exibe o nome de um tipo de delegate genérico em formato legível ([Func<Int32, Int32>] em vez de [Func`2]). Ela mesma usa uma lambda, na linha 52.
7.3.3. Captura de variáveis e closures
Uma lambda pode usar as variáveis locais do método em que é escrita. Diz-se que ela captura essas variáveis. Esse mecanismo, muito poderoso, reserva algumas surpresas. O programa [delegates-05.cs] as destaca:
Resultados:
Comentários:
- linha 5: a lambda usa a variável local
[threshold]declarada na linha 4.[threshold]não é um parâmetro da lambda: é uma variável capturada; - linha 8: [threshold] é modificada depois que a lambda é criada. Os resultados (linhas 2–3) mostram que a lambda enxerga o novo valor: [exceeds(7)] retorna [True] e depois [False]. A lambda não copiou o valor de [threshold] no momento de sua criação; ela compartilha com o método que a contém a própria variável;
- linha 13: uma lambda também pode modificar uma variável capturada. Após as duas chamadas das linhas 14–15, a variável [total] é igual a 7;
- linhas 60–64: a função [CreateCounter] retorna uma lambda que captura sua variável local [value]. Normalmente, uma variável local desaparece quando o método termina. Aqui, a variável [value] sobrevive a [CreateCounter] porque a lambda retornada ainda a usa. A combinação da lambda com as variáveis que ela captura é chamada de closure. Para implementá-la, o compilador transforma as variáveis capturadas em campos de um objeto que ele gera, e a lambda em um método desse objeto;
- linhas 19–20: cada chamada a [CreateCounter] cria uma nova variável [value] — e, portanto, um novo contador — independente dos demais. Os resultados (linhas 5–6) confirmam isso;
- linhas 26–29: a armadilha clássica. Criamos três lambdas em um laço [for], esperando que imprimam 0, 1 e 2. Todas imprimem 3 (linha 7 dos resultados). Na verdade, o laço [for] tem uma única variável, [i], compartilhada pelas três lambdas. Quando essas lambdas são executadas, o laço já terminou, e [i] é igual a 3;
- linhas 42–43: a correção. A variável [copy] é declarada dentro do corpo do laço: uma nova variável é criada a cada iteração, e cada lambda captura a sua;
- linhas 51–53: com [foreach], o problema não ocorre. Até o C# 4, a variável de um laço [foreach] era única, assim como a de um laço [for], e este código imprimia 2 2 2. O C# 5 mudou essa regra (é uma das poucas mudanças incompatíveis com versões anteriores na história da linguagem): a variável [j] agora é inicializada novamente a cada iteração. O laço [for] não foi modificado;
- linha 46: o método [ForEach] de [List<T>] espera um [Action<T>] e o executa sobre cada elemento. Aqui, cada elemento é, ele próprio, um delegate [Action], que a lambda executa.
A armadilha do laço [for] ocorre principalmente com processamento adiado: uma lambda registrada como manipulador de evento ou iniciada em outra thread (Capítulo 8) é executada depois que o laço que a criou terminou.
7.4. Delegates ou interfaces?
Os conceitos de delegate e de interface podem parecer bastante semelhantes, e é natural perguntar quais são exatamente as diferenças entre eles. Tomemos o exemplo [delegates-06.cs], semelhante a [delegates-02.cs]:
Resultados:
Na linha 15, o método [Execute] espera uma referência a um objeto do tipo de delegate [Operation] definido na linha 34. Isso permite passar métodos diferentes ao método [Execute] (linhas 4, 6, 10 e 12). A última linha chega a passar-lhe uma lambda: não foi necessário escrever um método de multiplicação. Esse polimorfismo também pode ser obtido com uma interface, como mostra [delegates-07.cs]:
Resultados:
Comentários:
- linhas 15–17: a interface [IOperation] define um método [Operation];
- linhas 21–26 e 31–36: as classes [Add] e [Subtract] implementam a interface [IOperation];
- linhas 9–11: o método [Execute], cujo primeiro parâmetro é do tipo definido pela interface [IOperation]. Ele recebe, sucessivamente, uma instância da classe [Add] como primeiro parâmetro, seguida de uma instância da classe [Subtract].
Isso demonstra claramente a natureza polimórfica do parâmetro de tipo delegate do exemplo anterior. Ao mesmo tempo, os dois exemplos evidenciam as diferenças entre esses dois conceitos. Os tipos delegate e interface são intercambiáveis:
- se a interface tem apenas um método. De fato, o tipo delegate é um invólucro para um único método, ao passo que uma interface pode definir vários métodos;
- se o recurso de multicast do delegate não é utilizado. Esse conceito de multicast não existe para uma interface.
Se essas duas condições forem atendidas, você pode escolher entre as duas assinaturas a seguir para o método [Execute]:
A segunda, que usa o delegate, é mais flexível de usar. Na primeira assinatura, o primeiro parâmetro deve implementar a interface [IOperation]: isso exige criar uma classe para definir o método a ser passado a [Execute]. Na segunda abordagem, qualquer método existente com a assinatura correta serve, e uma expressão lambda até permite definir esse método no próprio local da chamada. Nenhum código adicional é necessário. Essa flexibilidade explica por que as bibliotecas modernas (LINQ, programação assíncrona, ASP.NET Core) fazem amplo uso de delegates.
A interface volta a levar vantagem assim que o comportamento a ser passado envolve vários métodos inter-relacionados ou exige estado e identidade próprios. É o caso da interface [ITaxDao] da camada [dao] do Capítulo 6: embora tenha um único membro, suas implementações têm estado (as faixas lidas, o nome do arquivo), são criadas pelo contêiner de injeção de dependência e representam um papel claramente nomeado dentro da aplicação. Um delegate [Func<TaxBracket[]>] teria bastado tecnicamente, mas seria muito menos descritivo.
7.5. Tratamento de eventos
7.5.1. O modelo de eventos do .NET
Os delegates são usados para definir eventos. Uma classe [C1] pode definir um evento [Evt1] da seguinte forma:
- Um tipo delegate é definido dentro ou fora da classe [C1]:
- A classe [C1] define um campo desse tipo delegate:
- Quando uma instância [c1] da classe [C1] quer sinalizar um evento, ela executa seu delegate [Evt1] passando a ele os parâmetros definidos pelo tipo [Evt]. Todos os métodos registrados no delegate [Evt1] são então executados com esses parâmetros. Pode-se dizer que foram notificados do evento [Evt1];
- se um objeto [c2] que usa o objeto [c1] quer ser notificado do evento [Evt1] do objeto [c1], ele registra um de seus métodos, [c2.M], no delegate [c1.Evt1]. Seu método [c2.M] será então executado toda vez que o evento [Evt1] ocorrer no objeto [c1]. Ele também pode cancelar a inscrição quando não quiser mais ser notificado;
- como o delegate [c1.Evt1] pode registrar vários métodos, diferentes objetos [ci] podem se registrar em [c1.Evt1] para ser notificados do evento.
Nesse cenário, temos:
- uma classe que sinaliza (também dito "publica" ou "emite") um evento;
- classes que são notificadas desse evento. Diz-se que elas se inscrevem no evento;
- um tipo delegate que define a assinatura dos métodos que serão notificados do evento. Esses métodos são chamados de manipuladores de evento.
Esse é o padrão de projeto Observer: o emissor não conhece seus assinantes; ele apenas os notifica.
O framework .NET define uma assinatura padrão para um delegate de evento:
- [sender]: o objeto que disparou o evento;
- [e]: um objeto do tipo [EventArgs] ou de um tipo derivado, que fornece informações sobre o evento;
- Por convenção, o nome do tipo delegate termina com [EventHandler].
Ele também define uma forma padrão de declarar um evento do tipo [MyEventHandler] em uma classe:
O campo [Evt1] é do tipo delegate. A palavra-chave [event] restringe as operações que podem ser realizadas sobre ele:
- Fora da classe [C1], somente as operações [+=] e [-=] são permitidas. Isso impede que os métodos inscritos sejam sobrescritos ou removidos (por engano, por exemplo, escrevendo [=] em vez de [+=]) por outros objetos. Só é possível se inscrever ([+=]) ou cancelar a inscrição ([-=]);
- somente a classe [C1] pode executar o delegate, isto é, disparar o evento: [Evt1?.Invoke(this, e)].
Se você tentar, de fora da classe, escrever [c1.Evt1 = null;] ou [c1.Evt1(null, EventArgs.Empty);], o compilador responde com: [error CS0070: The event 'C1.Evt1' can only appear on the left hand side of += or -= (except when used from within the type 'C1')].
Em vez de definir um tipo delegate para cada evento, usamos o delegate genérico predefinido:
O tipo [TEventArgs] é o do segundo parâmetro, o objeto que descreve o evento. Com esse delegate genérico, a declaração de um evento [X] em uma classe [C] segue o padrão recomendado abaixo:
- definir um tipo [XEventArgs] derivado de [EventArgs] para encapsular informações sobre o evento [X];
- definir um evento do tipo [EventHandler<XEventArgs>] na classe [C];
- definir na classe [C] um método protegido e virtual [protected virtual void OnX(XEventArgs e)] destinado a publicar o evento [X] aos assinantes. Ele é virtual para que uma classe derivada possa modificar a forma como o evento é publicado.
Em 2008, o tipo [TEventArgs] era obrigado a derivar de [EventArgs] (restrição [where TEventArgs : EventArgs]). Essa restrição foi removida no .NET Framework 4.5: qualquer tipo é aceito, inclusive um [record]. Contudo, por convenção, continua-se derivando de [EventArgs]. Observe que um [record] não pode derivar de [EventArgs]: um [record] só pode herdar de outro [record] (erro: [CS8864: Records may only inherit from object or another record]). Usaremos, portanto, uma classe comum.
7.5.2. Um exemplo: a temperatura está alta demais
Considere o exemplo a seguir:
- Uma classe [Publisher] encapsula uma temperatura. Quando essa temperatura ultrapassa um certo limite, um evento deve ser disparado. Chamaremos esse evento de [TemperatureTooHigh]. As informações sobre esse evento serão encapsuladas em um tipo [TemperatureTooHighEventArgs];
- uma classe chamada [Subscriber] se inscreve no evento anterior. Quando é notificada do evento, ela exibe uma mensagem no console. Diferentemente da versão de 2008, um assinante cancela a inscrição automaticamente após receber um número determinado de alertas;
- um programa de console cria um publicador e dois assinantes. Ele lê temperaturas pelo teclado e as armazena no publicador. Se alguma delas for alta demais, o publicador publica o evento [TemperatureTooHigh].
O curso de 2008 distribuía essas classes por quatro arquivos de um projeto. Nós as reunimos na aplicação de arquivo único [delegates-08.cs], que apresentamos em três partes. Primeiro, a classe de informações do evento e a classe [Publisher]:
Comentários:
- Linhas 38–43: a classe [TemperatureTooHighEventArgs] deriva de [EventArgs], conforme a convenção. Ela usa um construtor primário (C# 12, ver Capítulo 4): o parâmetro [temperature] inicializa a propriedade somente leitura [Temperature], que representa a temperatura que disparou o evento. Acrescentamos o horário do evento, [Time]. As informações do evento são somente leitura: um assinante não deve poder modificá-las para os assinantes seguintes;
- linha 50: o limite de temperatura acima do qual o evento [TemperatureTooHigh] é publicado;
- linha 52: o emissor tem um nome para fins de identificação;
- linha 54: o evento [TemperatureTooHigh], do tipo [EventHandler<TemperatureTooHighEventArgs>]. O tipo permite nulo ([?]): enquanto ninguém se inscrever, o delegate vale [null];
- linhas 57–66: a propriedade [Temperature]. Seu acessador [set], dispara o evento se a temperatura registrada ultrapassar o limite. Ele usa a palavra-chave do C# 14 [field] (ver Capítulo 4), que se refere ao campo oculto de uma propriedade automática: não é mais necessário declarar um campo privado [temperature] como era preciso em 2008;
- Linha 66: a publicação é feita pelo método [OnTemperatureTooHigh], ao qual é passado um objeto [TemperatureTooHighEventArgs] contendo a temperatura que ultrapassou o limite;
- Linhas 72–75: o evento é publicado com o próprio emissor ([this]) como primeiro parâmetro e o objeto recebido pelo método como segundo parâmetro. O operador [?.] é essencial: se não houver assinantes, [TemperatureTooHigh] equivale a [null]. O código de 2008 usava [TemperatureTooHigh(this, evt)], o que provocava uma [NullReferenceException] se não houvesse assinantes. A notação [TemperatureTooHigh?.Invoke(this, e)] também é mais segura em um programa com várias threads (Capítulo 8): o delegate é lido uma única vez, depois verificado e executado; um cancelamento de inscrição simultâneo em outra thread não pode fazê-lo se tornar [null] entre a verificação e a chamada.
Eis a classe [Subscriber]:
Comentários:
- linha 80: cada assinante é identificado por um nome ([Name]) e recebe o número máximo de alertas que aceita ([nbAlertsMax]);
- Linhas 88–90: inscrição no evento de um publicador. O método do assinante [EvtTemperatureTooHigh] é registrado no evento: trata-se de uma conversão de grupo de métodos. Em 2008, a inscrição era feita pelo programa principal; aqui, ela é responsabilidade do assinante, que precisa saber qual método remover para cancelar a inscrição;
- Linhas 94–96: o cancelamento da inscrição remove o mesmo método usando [-=]. Para o delegate, o método [EvtTemperatureTooHigh] de [s0] e o de [s1] são dois métodos diferentes, pois não têm o mesmo alvo ([Target]): [-=] remove apenas o do assinante em questão;
- linha 100: o manipulador de evento. Ele tem a assinatura imposta pelo delegate [EventHandler<TemperatureTooHighEventArgs>]: um [object?] e um [TemperatureTooHighEventArgs]. É privado: somente o assinante pode registrá-lo em um publicador;
- Linha 102: o parâmetro [source] é do tipo [object?]. O filtro de padrão verifica que ele é de fato um [Publisher] e o armazena na variável [publisher]. O código de 2008 usava uma conversão de tipo para [((Publisher)source).Name];
- linha 106: o manipulador exibe o nome do assinante, o nome do emissor que informou o evento e a temperatura que o disparou;
- linhas 108–111: após [nbAlertsMax] alertas, o assinante cancela a inscrição no publicador. O assinante faz isso enquanto o evento está sendo publicado, a partir de seu próprio manipulador. Isso é seguro: vimos que um delegate é imutável. [-=] cria um novo delegate e o armazena no campo do evento, mas a publicação em andamento continua percorrendo a lista antiga.
Eis, por fim, o programa principal:
Resultados:
Comentários:
- linha 4: criação do emissor;
- Linhas 6–9: criação de dois assinantes, [s0] (até 3 alertas) e [s1] (1 alerta), que se inscrevem no evento [TemperatureTooHigh] do emissor. A expressão de coleção [new("s0", 3), new("s1", 1)] usa o operador [new] sem tipo (C# 9), pois o tipo é inferido a partir do tipo do array;
- linha 12: um terceiro assinante, um lambda, que funciona como um log. Os tipos de [source] e [e] são inferidos a partir do tipo do evento. Um lambda não pode ser desinscrito com facilidade: seria preciso armazená-lo em uma variável para removê-lo com [-=], pois dois lambdas escritos da mesma forma são dois delegates diferentes. Os lambdas ficam, portanto, reservados para inscrições que duram tanto quanto o emissor;
- Linhas 15–33: laço de leitura de temperaturas pelo teclado. [Console.ReadLine()] retorna [null] se a entrada padrão estiver fechada; [?.Trim() ?? ""] trata esse caso como uma entrada vazia;
- linha 28: se a temperatura digitada for válida, ela é enviada ao emissor [e1], que dispara o evento [TemperatureTooHigh] se ela for maior que 19 °C.
Os resultados mostram:
- linha 2: 17 °C não ultrapassa o limite: nenhum evento;
- linhas 3–7: 21 °C dispara o evento. Os três assinantes são notificados na ordem de suas inscrições. [s1], que aceita apenas um alerta, cancela a inscrição imediatamente, mas isso não impede que o log — que se inscreveu depois dele — seja notificado;
- linhas 10–12: [s1] não é mais notificado;
- linhas 13–16: [s0] recebe seu terceiro alerta e cancela a inscrição por sua vez;
- linha 17: resta apenas o log.
7.6. Os delegates e o LINQ
No Capítulo 5, usamos os métodos do LINQ ([Where], [Select], [OrderBy]…) passando lambdas a eles. Agora sabemos o que são esses parâmetros: o método [Where] é declarado da seguinte forma na classe [System.Linq.Enumerable]:
Seu parâmetro [predicate] é um delegate [Func<TSource, bool>]: qualquer método ou lambda que receba um elemento e retorne um booleano serve. Para entender plenamente como o LINQ funciona, vamos escrever nós mesmos um método de filtragem. Este é o programa [delegates-09.cs]:
Resultados:
Comentários:
- Linhas 6–7: o lambda de [Where] é primeiro armazenado em uma variável do tipo [Func<int, bool>] para revelar seu tipo. [Select], por sua vez, recebe um delegate [Func<int, int>] que transforma cada elemento: o resultado são os quadrados dos números pares;
- linhas 37–44: nosso método [Filter]. Ele é genérico: filtra uma sequência de elementos de qualquer tipo [T], usando um predicado do tipo [Func<T, bool>]. Ele percorre a sequência e chama o predicado (linha 41) para cada elemento;
- linha 44: a instrução [yield return] transforma [Filter] em um iterador: o método não constrói uma lista; em vez disso, retorna os elementos selecionados um a um, conforme solicitado pelo programa que itera sobre o resultado. Após cada chamada a [yield return], a execução de [Filter] é suspensa; ela retoma no mesmo ponto quando o próximo elemento é solicitado;
- linha 11: chamada a [Filter] com um lambda. O tipo [T] é inferido a partir do array: [int]. Na linha 12, um grupo de métodos é passado a ele;
- Linhas 15–18: um predicado verboso que imprime cada elemento que testa. O resultado (linhas 5–6) mostra que criar a consulta não executa nada: a mensagem da linha 20 é exibida antes do primeiro teste. Somente durante o laço [foreach] é que [Filter] é executado, e os testes se alternam com as impressões do laço. Essa é a execução adiada, a mesma das consultas LINQ;
- linhas 53–63: um bloco de membros de extensão (C# 14, apresentado no Capítulo 4) acrescenta dois métodos ao tipo [IEnumerable<T>]: [Filter], que reutiliza [Tools.Filter], e [Transform], o equivalente a [Select]. [Transform] é duplamente genérico: [T] é o tipo dos elementos da sequência, e [TResult] é o tipo dos elementos produzidos pela transformação;
- Linha 29: graças aos métodos de extensão, nossos métodos são chamados exatamente como os métodos da sequência e se encadeiam como os do LINQ: mantemos as cidades com 5 letras ou menos e depois as colocamos em maiúsculas.
Toda a biblioteca LINQ é construída sobre esse modelo: métodos de extensão de [IEnumerable<T>] que aceitam delegates e retornam novas sequências, calculadas sob demanda por iteradores.
7.7. Árvores de expressão
Uma expressão lambda pode ser convertida em um delegate, como fizemos ao longo deste capítulo. Ela também pode ser convertida em uma árvore de expressão: em vez de compilar o lambda em código executável, o compilador gera instruções que constroem, em tempo de execução, uma estrutura de dados que descreve o lambda. Para isso, basta usar o tipo [Expression<TDelegate>] do namespace [System.Linq.Expressions] no lugar do tipo delegate. O programa [delegates-10.cs] compara os dois:
Resultados:
Comentários:
- linha 2: o namespace [System.Linq.Expressions] não faz parte dos [using] implícitos;
- Linhas 5–6: o mesmo lambda é atribuído a um delegate [Func<int, bool>] e depois a uma árvore de expressão [Expression<Func<int, bool>>];
- linha 9: um delegate só pode exibir seu tipo; seu código está compilado e ilegível;
- linha 11: uma árvore de expressão, por outro lado, pode ser exibida. O resultado (linha 3) reproduz o lambda: [AndAlso] é o nome do operador [&&];
- linha 12: podemos consultar a árvore: seus parâmetros, o tipo de seu resultado e seu corpo ([Body]);
- linhas 21–39: um método recursivo que exibe a árvore. Cada nó é um objeto derivado da classe [Expression]: [BinaryExpression] para uma operação de dois operandos ([&&], [>], [==], [%]), [ParameterExpression] para um parâmetro, [ConstantExpression] para uma constante. Um [switch], com filtragem de padrão baseada no tipo, trata cada caso. Os resultados (linhas 6–14) mostram a estrutura da expressão [n > 5 && n % 2 == 0];
- linha 17: uma árvore de expressão pode ser compilada em tempo de execução em um delegate e depois executada.
Qual é a utilidade disso? Um delegate só pode ser executado dentro do programa. Uma árvore de expressão pode ser analisada e traduzida para outra linguagem. É o que faz o Entity Framework Core, que exploraremos no Capítulo 11. Ao escrever uma consulta LINQ sobre uma tabela de banco de dados, por exemplo [context.Brackets.Where(t => t.Limit > 20000)], o método [Where] usado não é o de [IEnumerable<T>] , mas o de [IQueryable<T>], cujo parâmetro é uma [Expression<Func<T, bool>>]. O EF Core percorre essa árvore, exatamente como nosso método [Display], e a traduz em uma cláusula SQL [WHERE limits > 20000] executada pelo servidor de banco de dados. O mesmo lambda, escrito da mesma forma, torna-se assim código .NET ou código SQL, dependendo do tipo do parâmetro que recebe.
7.8. Conclusão
Principais pontos deste capítulo:
- Um delegate é um objeto que referencia um ou mais métodos com uma determinada assinatura. Os tipos predefinidos [Func<>], [Action<>], e [Predicate<T>] costumam dispensar a definição de tipos delegate próprios;
- as expressões lambda permitem escrever o método exatamente onde se cria o delegate. Elas capturam as variáveis ao seu redor (cuidado com os laços [for]);
- Um delegate pode substituir uma interface de um único método, oferecendo maior flexibilidade;
- um evento é um delegate protegido pela palavra-chave [event]: você se inscreve nele com [+=], cancela a inscrição com [-=], e somente a classe que o declara o dispara, com [Evt?.Invoke(this, e)];
- O LINQ é construído sobre métodos que aceitam delegates, e o EF Core, sobre árvores de expressão.
Os delegates voltarão a ser abordados nos capítulos seguintes: uma tarefa ([Task.Run]) executa um delegate em outra thread (Capítulos 8 e 9), e os serviços web do ASP.NET Core associam lambdas a endereços HTTP (Capítulo 13).