Skip to content

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:

public delegate void EventHandler(object? sender, EventArgs e);

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:

static void Display(object? sender, EventArgs e) { ... }

Para criar um objeto do tipo [EventHandler] que referencia esse método, pode-se escrever:

EventHandler handler = new EventHandler(Display);

ou, de forma mais simples:

EventHandler handler = Display;

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:

// os tipos de delegate predefinidos do .NET

// 1 - o delegate EventHandler: void M(object? sender, EventArgs e)
EventHandler handler = new EventHandler(Display);
// forma curta: conversão de grupo de métodos
handler = Display;
// execução do delegate
handler("program", EventArgs.Empty);

// 2 - Func<T1, T2, TResult>: dois parâmetros int, um resultado int
Func<int, int, int> operation = Add;
Console.WriteLine($"operation(2, 3)={operation(2, 3)}");
// Func<TResult>: nenhum parâmetro, um resultado
Func<string> greet = Greet;
Console.WriteLine($"greet()={greet()}");

// 3 - Action<T>: um parâmetro, nenhum resultado
Action<string> write = Console.WriteLine;
write("Action<string> executed Console.WriteLine");

// 4 - Predicate<T>: um parâmetro, um resultado bool
Predicate<int> isEven = IsEven;
List<int> numbers = [3, 8, 1, 6, 5, 4];
// FindAll e RemoveAll de List<T> esperam um Predicate<T>
Console.WriteLine($"even: {string.Join(" ", numbers.FindAll(isEven))}");
int nbRemoved = numbers.RemoveAll(IsEven);
Console.WriteLine($"{nbRemoved} even numbers removed, remaining: {string.Join(" ", numbers)}");

// 5 - Comparison<T>: dois parâmetros T, um resultado int
List<string> names = ["Paul", "Mélanie", "Jo", "Sébastien"];
names.Sort(CompareLengths);
Console.WriteLine($"sorted by length: {string.Join(" ", names)}");

// 6 - um delegate é um objeto: seu tipo e o método que ele referencia
Console.WriteLine($"type: {operation.GetType()}");
Console.WriteLine($"method: {operation.Method.Name}, target: {operation.Target?.ToString() ?? "none (static method)"}");

// os métodos referenciados pelos delegates
static void Display(object? sender, EventArgs e)
{
    Console.WriteLine($"Display(sender={sender}, e={e.GetType().Name})");
}

static int Add(int n1, int n2) => n1 + n2;

static string Greet() => "Hello";

static bool IsEven(int n) => n % 2 == 0;

static int CompareLengths(string s1, string s2) => s1.Length.CompareTo(s2.Length);

Resultados:

> dotnet run delegates-01.cs
Display(sender=program, e=EventArgs)
operation(2, 3)=5
greet()=Hello
Action<string> executed Console.WriteLine
even: 8 6 4
3 even numbers removed, remaining: 3 1 5
sorted by length: Jo Paul Mélanie Sébastien
type: System.Func`3[System.Int32,System.Int32,System.Int32]
method: <<Main>$>g__Add|0_1, target: none (static method)

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:

public delegate int Operation(int n1, int n2);

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]:

// definição do seu próprio tipo de delegate

// definimos um objeto do tipo Operation para registrar métodos nele
// registramos o método estático Increase
Operation op = Calculations.Increase;
// executamos o delegate
int n = op(4, 7);
Console.WriteLine($"n={n}");

// criação de um objeto c1 do tipo Calculations
var c1 = new Calculations();
// registramos o método Add de c1 no delegate
op = c1.Add;
// execução do objeto delegate
n = op(2, 3);
Console.WriteLine($"n={n}");
// registramos o método Subtract de c1 no delegate
op = c1.Subtract;
n = op(2, 3);
Console.WriteLine($"n={n}");

// registro de dois métodos no delegate (delegate multicast)
op = c1.Add;
op += c1.Subtract;
// execução do objeto delegate: obtemos o resultado do último método
n = op(10, 4);
Console.WriteLine($"n={n}");
// os resultados de todos os métodos com a lista de invocação
foreach (Operation method in op.GetInvocationList().Cast<Operation>())
{
    Console.WriteLine($"{method.Method.Name} -> {method(10, 4)}");
}
// removemos um método do delegate: o resultado pode ser null (tipo Operation?)
Operation? rest = op - c1.Subtract;
// executamos o delegate se ele não for null
if (rest is not null)
{
    n = rest(1, 1);
    Console.WriteLine($"n={n}");
}
// removemos o último método: o delegate se torna null
Operation? empty = rest - c1.Add;
Console.WriteLine($"empty is null: {empty is null}");
// ?.Invoke executa o delegate somente se ele não for null
Console.WriteLine($"empty?.Invoke(1, 1)={empty?.Invoke(1, 1)}");

// uma classe cujos métodos têm a assinatura do delegate Operation
public class Calculations
{
    // dois métodos de instância
    public int Add(int n1, int n2)
    {
        Console.WriteLine($"Add({n1},{n2})");
        return n1 + n2;
    }

    public int Subtract(int n1, int n2)
    {
        Console.WriteLine($"Subtract({n1},{n2})");
        return n1 - n2;
    }

    // um método estático
    public static int Increase(int n1, int n2)
    {
        Console.WriteLine($"Increase({n1},{n2})");
        return n1 + 2 * n2;
    }
}

// definição de um tipo de delegate: um modelo de método
// que aceita dois inteiros como parâmetros e retorna um inteiro
public delegate int Operation(int n1, int n2);

Resultados:

> dotnet run delegates-02.cs
Increase(4,7)
n=18
Add(2,3)
n=5
Subtract(2,3)
n=-1
Add(10,4)
Subtract(10,4)
n=6
Add(10,4)
Add -> 14
Subtract(10,4)
Subtract -> 6
Add(1,1)
n=2
empty is null: True
empty?.Invoke(1, 1)=

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:

// de métodos anônimos a expressões lambda

// 1 - um método anônimo (C# 2): o corpo do método é escrito no local
Func<int, int, int> add = delegate (int n1, int n2)
{
    return n1 + n2;
};
Console.WriteLine($"anonymous method: add(2, 3)={add(2, 3)}");

// 2 - a mesma coisa com uma expressão lambda (C# 3): parâmetros => corpo
Func<int, int, int> subtract = (int n1, int n2) =>
{
    return n1 - n2;
};
Console.WriteLine($"block-bodied lambda: subtract(2, 3)={subtract(2, 3)}");

// 3 - os tipos dos parâmetros são inferidos a partir do tipo de delegate de destino
Func<int, int, int> multiply = (n1, n2) => n1 * n2;
Console.WriteLine($"expression-bodied lambda: multiply(2, 3)={multiply(2, 3)}");

// 4 - um único parâmetro: os parênteses são opcionais
Func<int, int> square = x => x * x;
Predicate<string> isEmpty = s => s.Length == 0;
Console.WriteLine($"square(7)={square(7)}, isEmpty(\"\")={isEmpty("")}");

// 5 - nenhum parâmetro: parênteses vazios
Func<string> greet = () => "Hello";
Action beep = () => Console.WriteLine("beep!");
Console.WriteLine(greet());
beep();

// 6 - um corpo em bloco com várias instruções
Action<string, int> repeat = (text, times) =>
{
    for (int i = 0; i < times; i++)
    {
        Console.Write(text);
    }
    Console.WriteLine();
};
repeat("ab", 3);

// 7 - parâmetros ignorados (discards): não precisamos de seus valores
EventHandler handler = (_, _) => Console.WriteLine("event received");
handler(null, EventArgs.Empty);

// 8 - uma lambda passada diretamente como parâmetro de um método
List<int> numbers = [3, 8, 1, 6, 5, 4];
Console.WriteLine($"even: {string.Join(" ", numbers.FindAll(n => n % 2 == 0))}");
numbers.Sort((n1, n2) => n2.CompareTo(n1));
Console.WriteLine($"descending order: {string.Join(" ", numbers)}");

Resultados:

> dotnet run delegates-03.cs
anonymous method: add(2, 3)=5
block-bodied lambda: subtract(2, 3)=-1
expression-bodied lambda: multiply(2, 3)=6
square(7)=49, isEmpty("")=True
Hello
beep!
ababab
event received
even: 8 6 4
descending order: 8 6 5 4 3 1

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:

// mais sobre expressões lambda (C# 9 a C# 14)

// 1 - tipo natural de uma lambda (C# 10): var é possível se os parâmetros tiverem tipo
var twice = (int x) => x * 2;
Console.WriteLine($"twice(21)={twice(21)}, type: {Name(twice)}");
var display = (string s) => Console.WriteLine($"[{s}]");
display("Action<string>");
Console.WriteLine($"type of display: {Name(display)}");
// um grupo de métodos também tem um tipo natural se tiver apenas uma sobrecarga
var isEven = IsEven;
Console.WriteLine($"isEven(4)={isEven(4)}, type: {Name(isEven)}");

// 2 - tipo de retorno explícito (C# 10): útil quando não pode ser inferido
var choose = object (bool b) => b ? 1 : "one";
Console.WriteLine($"choose(true)={choose(true)}, choose(false)={choose(false)}");

// 3 - parâmetros com valor padrão (C# 12)
var greet = (string name, string greeting = "Hello") => $"{greeting} {name}";
Console.WriteLine(greet("Pierre"));
Console.WriteLine(greet("Pierre", "Good evening"));
// assim como params
var sum = (params int[] values) => values.Sum();
Console.WriteLine($"sum()={sum()}, sum(1, 2, 3)={sum(1, 2, 3)}");
// o tipo dessas lambdas é um delegate anônimo gerado pelo compilador
Console.WriteLine($"type of greet: {Name(greet)}");

// 4 - lambda estática (C# 9): ela não pode usar nenhuma variável local nem this
const int Coefficient = 3;
Func<int, int> triple = static x => x * Coefficient; // uma constante é permitida
Console.WriteLine($"triple(5)={triple(5)}");

// 5 - modificadores ref / out / in sem tipo (C# 14)
// o tipo de delegate Incrementer fixa os tipos: a lambda não precisa repeti-los
Incrementer increment = (ref x) => x++;
int counter = 10;
increment(ref counter);
increment(ref counter);
Console.WriteLine($"counter={counter}");
Parser parse = (text, out value) => int.TryParse(text, out value);
Console.WriteLine($"parse(\"12\"): {parse("12", out int v1)} {v1}");
Console.WriteLine($"parse(\"x\"): {parse("x", out int v2)} {v2}");

// nome legível de um tipo de delegate: Func<Int32, Int32> em vez de Func`2
static string Name(Delegate d)
{
    Type t = d.GetType();
    if (!t.IsGenericType)
    {
        return t.Name;
    }
    string name = t.Name[..t.Name.IndexOf('`')];
    return $"{name}<{string.Join(", ", t.GetGenericArguments().Select(a => a.Name))}>";
}

static bool IsEven(int n) => n % 2 == 0;

// tipos de delegate com parâmetros ref e out
delegate void Incrementer(ref int x);
delegate bool Parser(string text, out int value);

Resultados:

> dotnet run delegates-04.cs
twice(21)=42, type: Func<Int32, Int32>
[Action<string>]
type of display: Action<String>
isEven(4)=True, type: Func<Int32, Boolean>
choose(true)=1, choose(false)=one
Hello Pierre
Good evening Pierre
sum()=0, sum(1, 2, 3)=6
type of greet: <>f__AnonymousDelegate0<String, String, String>
triple(5)=15
counter=12
parse("12"): True 12
parse("x"): False 0

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:

// captura de variáveis e closures

// 1 - uma lambda pode usar as variáveis locais que a cercam
int threshold = 5;
Func<int, bool> exceeds = n => n > threshold;
Console.WriteLine($"threshold={threshold}: exceeds(7)={exceeds(7)}");
// a variável é capturada, não o seu valor: a lambda vê a modificação
threshold = 10;
Console.WriteLine($"threshold={threshold}: exceeds(7)={exceeds(7)}");

// 2 - uma lambda também pode modificar uma variável capturada
int total = 0;
Action<int> accumulate = n => total += n;
accumulate(3);
accumulate(4);
Console.WriteLine($"total={total}");

// 3 - uma closure: a variável capturada sobrevive ao método que a criou
Func<int> counterA = CreateCounter();
Func<int> counterB = CreateCounter();
Console.WriteLine($"A: {counterA()} {counterA()} {counterA()}");
Console.WriteLine($"B: {counterB()} {counterB()}");

// 4 - a armadilha da captura em um laço for
List<Action> actions = [];
for (int i = 0; i < 3; i++)
{
    // as três lambdas capturam a mesma variável i
    actions.Add(() => Console.Write($"{i} "));
}
Console.Write("for, capture of i: ");
foreach (Action action in actions)
{
    action();
}
Console.WriteLine();

// a correção: uma cópia local, nova a cada iteração do laço
actions.Clear();
for (int i = 0; i < 3; i++)
{
    int copy = i;
    actions.Add(() => Console.Write($"{copy} "));
}
Console.Write("for, capture of a copy: ");
actions.ForEach(action => action());
Console.WriteLine();

// foreach (desde o C# 5) cria uma nova variável a cada iteração
actions.Clear();
foreach (int j in new[] { 0, 1, 2 })
{
    actions.Add(() => Console.Write($"{j} "));
}
Console.Write("foreach: ");
actions.ForEach(action => action());
Console.WriteLine();

// um método que retorna uma função
static Func<int> CreateCounter()
{
    // variável local capturada pela lambda retornada
    int value = 0;
    return () => ++value;
}

Resultados:

1
2
3
4
5
6
7
8
9
> dotnet run delegates-05.cs
threshold=5: exceeds(7)=True
threshold=10: exceeds(7)=False
total=7
A: 1 2 3
B: 1 2
for, capture of i: 3 3 3 
for, capture of a copy: 0 1 2 
foreach: 0 1 2 

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]:

// um parâmetro de tipo delegate

// execução do delegate Add
Console.WriteLine(Execute(Add, 2, 3));
// execução do delegate Subtract
Console.WriteLine(Execute(Subtract, 2, 3));
// execução de um delegate multicast
Operation op = Add;
op += Subtract;
Console.WriteLine(Execute(op, 2, 3));
// execução de uma lambda: nenhum método nomeado é necessário
Console.WriteLine(Execute((n1, n2) => n1 * n2, 2, 3));

// execução de um delegate
static int Execute(Operation op, int n1, int n2)
{
    return op(n1, n2);
}

// dois métodos com a assinatura do delegate Operation
static int Add(int n1, int n2)
{
    Console.WriteLine($"Add({n1},{n2})");
    return n1 + n2;
}

static int Subtract(int n1, int n2)
{
    Console.WriteLine($"Subtract({n1},{n2})");
    return n1 - n2;
}

// o tipo de delegate
delegate int Operation(int n1, int n2);

Resultados:

1
2
3
4
5
6
7
8
9
> dotnet run delegates-06.cs
Add(2,3)
5
Subtract(2,3)
-1
Add(2,3)
Subtract(2,3)
-1
6

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]:

// um parâmetro de tipo interface

// execução da operação Add
Console.WriteLine(Execute(new Add(), 2, 3));
// execução da operação Subtract
Console.WriteLine(Execute(new Subtract(), 2, 3));

// execução do único método da interface IOperation
static int Execute(IOperation op, int n1, int n2)
{
    return op.Operation(n1, n2);
}

// interface IOperation
public interface IOperation
{
    int Operation(int n1, int n2);
}

// classe Add
public class Add : IOperation
{
    public int Operation(int n1, int n2)
    {
        Console.WriteLine($"Add({n1},{n2})");
        return n1 + n2;
    }
}

// classe Subtract
public class Subtract : IOperation
{
    public int Operation(int n1, int n2)
    {
        Console.WriteLine($"Subtract({n1},{n2})");
        return n1 - n2;
    }
}

Resultados:

1
2
3
4
5
> dotnet run delegates-07.cs
Add(2,3)
5
Subtract(2,3)
-1

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]:

int Execute(IOperation op, int n1, int n2)
int Execute(Operation op, int n1, int n2)

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]:
delegate void Evt(T1 param1, T2 param2, ...);
  • A classe [C1] define um campo desse tipo delegate:
public Evt? Evt1;
  • 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:

public delegate void MyEventHandler(object? sender, EventArgs e);
  • [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:

1
2
3
4
5
public class C1
{
    public event MyEventHandler? Evt1;
    ...
}

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:

public delegate void EventHandler<TEventArgs>(object? sender, TEventArgs e);

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]:

// a informação transportada pelo evento
public class TemperatureTooHighEventArgs(decimal temperature) : EventArgs
{
    // temperatura no momento do evento
    public decimal Temperature { get; } = temperature;
    // hora do evento
    public DateTime Time { get; } = DateTime.Now;
}

// a classe que dispara o evento
public class Publisher(string name)
{
    // limite que dispara o evento
    public const decimal Threshold = 19;
    // nome do publicador
    public string Name { get; } = name;
    // o evento disparado
    public event EventHandler<TemperatureTooHighEventArgs>? TemperatureTooHigh;

    // temperatura observada
    public decimal Temperature
    {
        get;
        set
        {
            field = value;
            if (value > Threshold)
            {
                // disparamos o evento para os assinantes
                OnTemperatureTooHigh(new TemperatureTooHighEventArgs(value));
            }
        }
    }

    // disparo do evento
    protected virtual void OnTemperatureTooHigh(TemperatureTooHighEventArgs e)
    {
        // emissão do evento para os assinantes, se houver algum
        TemperatureTooHigh?.Invoke(this, e);
    }
}

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]:

// uma classe que assina o evento
public class Subscriber(string name, int nbAlertsMax)
{
    // nome do assinante
    public string Name { get; } = name;
    // número de alertas recebidos
    private int nbAlerts;

    // assinatura do evento de um publicador
    public void Subscribe(Publisher publisher)
    {
        publisher.TemperatureTooHigh += EvtTemperatureTooHigh;
    }

    // cancelamento da assinatura
    public void Unsubscribe(Publisher publisher)
    {
        publisher.TemperatureTooHigh -= EvtTemperatureTooHigh;
    }

    // manipulador do evento TemperatureTooHigh
    private void EvtTemperatureTooHigh(object? source, TemperatureTooHighEventArgs e)
    {
        if (source is not Publisher publisher)
        {
            return;
        }
        Console.WriteLine($"Subscriber [{Name}]: the source [{publisher.Name}] reported a temperature too high: [{e.Temperature}]");
        // além de nbAlertsMax alertas, o assinante cancela sua assinatura
        nbAlerts++;
        if (nbAlerts == nbAlertsMax)
        {
            Unsubscribe(publisher);
            Console.WriteLine($"Subscriber [{Name}]: unsubscribed after {nbAlerts} alert(s)");
        }
    }
}

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:

// tratamento de eventos: um publicador e assinantes

// criação de um publicador de eventos
var e1 = new Publisher("e");
// criação de dois assinantes do evento TemperatureTooHigh de e1
Subscriber[] subscribers = [new("s0", 3), new("s1", 1)];
foreach (Subscriber subscriber in subscribers)
{
    subscriber.Subscribe(e1);
}
// um terceiro assinante: uma lambda
e1.TemperatureTooHigh += (source, e) => Console.WriteLine($"Log: {e.Temperature} °C at {e.Time:HH:mm:ss}");

// lemos as temperaturas do teclado
while (true)
{
    Console.Write("Temperature (nothing to stop): ");
    string input = Console.ReadLine()?.Trim() ?? "";
    // fim da entrada?
    if (input == "")
    {
        break;
    }
    // a entrada é um número decimal?
    if (decimal.TryParse(input, out decimal temperature))
    {
        // temperatura correta - a armazenamos no publicador
        e1.Temperature = temperature;
    }
    else
    {
        // sinalizamos o erro
        Console.WriteLine("Incorrect temperature");
    }
}

Resultados:

> dotnet run delegates-08.cs
Temperature (nothing to stop): 17
Temperature (nothing to stop): 21
Subscriber [s0]: the source [e] reported a temperature too high: [21]
Subscriber [s1]: the source [e] reported a temperature too high: [21]
Subscriber [s1]: unsubscribed after 1 alert(s)
Log: 21 °C at 11:20:25
Temperature (nothing to stop): abc
Incorrect temperature
Temperature (nothing to stop): 22.5
Subscriber [s0]: the source [e] reported a temperature too high: [22.5]
Log: 22.5 °C at 11:20:27
Temperature (nothing to stop): 25
Subscriber [s0]: the source [e] reported a temperature too high: [25]
Subscriber [s0]: unsubscribed after 3 alert(s)
Log: 25 °C at 11:20:28
Temperature (nothing to stop): 30
Log: 30 °C at 11:20:28
Temperature (nothing to stop): 

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]:

public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)

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]:

// delegates e LINQ

int[] numbers = [3, 8, 1, 6, 5, 4, 9, 2];

// 1 - Where e Select esperam delegates Func<int, bool> e Func<int, TResult>
Func<int, bool> isEven = n => n % 2 == 0;
var evenSquares = numbers.Where(isEven).Select(n => n * n);
Console.WriteLine($"LINQ: {string.Join(" ", evenSquares)}");

// 2 - nosso próprio método de filtragem, chamado com uma lambda e depois com um grupo de métodos
Console.WriteLine($"Filter(n > 4): {string.Join(" ", Tools.Filter(numbers, n => n > 4))}");
Console.WriteLine($"Filter(IsOdd): {string.Join(" ", Tools.Filter(numbers, IsOdd))}");

// 3 - a execução é adiada: o predicado só é chamado durante a iteração
IEnumerable<int> large = Tools.Filter(numbers, n =>
{
    Console.Write($"[test {n}] ");
    return n > 7;
});
Console.WriteLine("the query is defined, nothing has been executed yet");
foreach (int n in large)
{
    Console.Write($"-> {n} ");
}
Console.WriteLine();

// 4 - com membros de extensão, nossos métodos se encadeiam como os do LINQ
string[] cities = ["Angers", "Paris", "Lyon", "Nantes", "Aix"];
var result = cities.Filter(v => v.Length <= 5).Transform(v => v.ToUpper());
Console.WriteLine($"extension: {string.Join(" ", result)}");

static bool IsOdd(int n) => n % 2 != 0;

public static class Tools
{
    // filtra uma sequência com um predicado: o equivalente de Where
    public static IEnumerable<T> Filter<T>(IEnumerable<T> source, Func<T, bool> predicate)
    {
        foreach (T element in source)
        {
            if (predicate(element))
            {
                // o elemento é retornado ao chamador; a iteração será retomada aqui
                yield return element;
            }
        }
    }
}

public static class Extensions
{
    // membros de extensão (C# 14) de IEnumerable<T>
    extension<T>(IEnumerable<T> source)
    {
        // Filter como método de extensão: reutilizamos Tools.Filter
        public IEnumerable<T> Filter(Func<T, bool> predicate) => Tools.Filter(source, predicate);

        // transforma cada elemento: o equivalente de Select
        public IEnumerable<TResult> Transform<TResult>(Func<T, TResult> transformation)
        {
            foreach (T element in source)
            {
                yield return transformation(element);
            }
        }
    }
}

Resultados:

1
2
3
4
5
6
7
> dotnet run delegates-09.cs
LINQ: 64 36 16 4
Filter(n > 4): 8 6 5 9
Filter(IsOdd): 3 1 5 9
the query is defined, nothing has been executed yet
[test 3] [test 8] -> 8 [test 1] [test 6] [test 5] [test 4] [test 9] -> 9 [test 2] 
extension: PARIS LYON AIX

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:

// árvores de expressão
using System.Linq.Expressions;

// a mesma lambda, compilada em um delegate ou mantida como dados
Func<int, bool> function = n => n > 5 && n % 2 == 0;
Expression<Func<int, bool>> expression = n => n > 5 && n % 2 == 0;

// um delegate executa, mas seu código não é legível
Console.WriteLine($"delegate: {function}");
// uma árvore de expressão pode ser percorrida e exibida
Console.WriteLine($"expression: {expression}");
Console.WriteLine($"parameter: {expression.Parameters[0].Name}, returned type: {expression.ReturnType.Name}");
Console.WriteLine("tree:");
Display(expression.Body, 1);

// uma árvore de expressão pode ser compilada em um delegate e depois executada
Func<int, bool> compiled = expression.Compile();
Console.WriteLine($"compiled(8)={compiled(8)}, compiled(7)={compiled(7)}");

// exibição recursiva de um nó da árvore e de seus filhos
static void Display(Expression node, int level)
{
    string margin = new(' ', 2 * level);
    switch (node)
    {
        case BinaryExpression binary:
            // operação com dois operandos: &&, >, ==, %...
            Console.WriteLine($"{margin}{binary.NodeType}");
            Display(binary.Left, level + 1);
            Display(binary.Right, level + 1);
            break;
        case ParameterExpression parameter:
            Console.WriteLine($"{margin}Parameter {parameter.Name}");
            break;
        case ConstantExpression constant:
            Console.WriteLine($"{margin}Constant {constant.Value}");
            break;
        default:
            Console.WriteLine($"{margin}{node.NodeType} {node}");
            break;
    }
}

Resultados:

> dotnet run delegates-10.cs
delegate: System.Func`2[System.Int32,System.Boolean]
expression: n => ((n > 5) AndAlso ((n % 2) == 0))
parameter: n, returned type: Boolean
tree:
  AndAlso
    GreaterThan
      Parameter n
      Constant 5
    Equal
      Modulo
        Parameter n
        Constant 2
      Constant 0
compiled(8)=True, compiled(7)=False

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).