C# Delegates

Até agora, as variáveis guardavam dados: um número, um texto, uma lista. Um delegate ("delegado", "representante") é uma variável que guarda um método. Com ele, você pode trocar a regra de um programa sem mexer no resto, e passar um comportamento para outro método do mesmo jeito que passa um número. É a base das lambdas, dos eventos e do LINQ, os próximos assuntos do guia.

Todos os programas desta aula rodaram com o .NET 10 (C# 14) na máquina da Ana (usuária ana, computador notebook), na pasta ~/cs, com dotnet run arquivo.cs (veja Rodar com dotnet run). Você pode repetir cada um no editor do guia, que compila e roda C# de verdade no navegador.

A ideia: a etiqueta de preço que muda de regra

Na lojinha da Ana, o caixa calcula o preço de cada produto. Num dia comum, o preço é o da etiqueta. Na Black Friday, tudo sai com 30% de desconto. Para os clientes de atacado, 10%.

A Ana não quer reescrever o caixa a cada promoção. Ela quer um caixa com um encaixe, onde ela pluga a regra do dia: "hoje a regra é a da Black Friday". O caixa não sabe qual é a regra; ele só sabe que a regra recebe um preço e devolve um preço.

Esse encaixe é um delegate. Ele tem um formato (recebe decimal, devolve decimal), e qualquer método com esse formato pode ser plugado nele. O nome vem do verbo "delegar": o caixa delega a conta para o método que estiver plugado.

1. Declarar um tipo delegate e guardar um método

O primeiro programa cria o formato do encaixe, pluga a regra normal, usa, troca pela regra da Black Friday e usa de novo:

RegraDePreco regra = PrecoNormal;
Console.WriteLine($"Normal: {regra(50m):C}");

regra = BlackFriday;
Console.WriteLine($"Black Friday: {regra(50m):C}");
Console.WriteLine($"Com Invoke: {regra.Invoke(50m):C}");

static decimal PrecoNormal(decimal preco) => preco;
static decimal BlackFriday(decimal preco) => preco * 0.7m;

delegate decimal RegraDePreco(decimal preco);

$ dotnet run regras.cs
Normal: R$ 50,00
Black Friday: R$ 35,00
Com Invoke: R$ 35,00

Comece pela última linha, que cria o formato. Ela parece a primeira linha de um método, com a palavra delegate na frente e um ; no lugar do corpo:

delegate

Palavra-chave: "o que vem a seguir é um tipo de delegate", um formato de método. Não é um método; é um molde.

decimal

O tipo de retorno que os métodos plugados precisam ter.

RegraDePreco

O nome do tipo, em PascalCase, como o de uma classe. Depois desta linha, RegraDePreco é um tipo, como int ou string.

(decimal preco)

Os parâmetros que os métodos plugados precisam receber. O nome preco só documenta; os métodos podem usar outro nome.

;

Não tem corpo: o delegate só descreve o formato. Quem faz a conta são os métodos.

Agora o resto, linha a linha:

O delegate não sabe qual regra está plugada

A linha Console.WriteLine($"Black Friday: {regra(50m):C}"); não menciona a Black Friday em lugar nenhum: ela só diz regra(50m). Quem decide o que acontece é o método guardado em regra naquele momento. É exatamente o encaixe do caixa da Ana.

RegraDePreco regra = PrecoNormal;
Console.WriteLine($"Normal: {regra(50m):C}");

// troque a regra aqui
Console.WriteLine($"Atacado: {regra(50m):C}");

static decimal PrecoNormal(decimal preco) => preco;
// crie o método Atacado aqui

delegate decimal RegraDePreco(decimal preco);

RegraDePreco regra = PrecoNormal;
Console.WriteLine($"Normal: {regra(50m):C}");

regra = Atacado;
Console.WriteLine($"Atacado: {regra(50m):C}");

static decimal PrecoNormal(decimal preco) => preco;
static decimal Atacado(decimal preco) => preco * 0.9m;

delegate decimal RegraDePreco(decimal preco);

2. Passar um método como parâmetro

Guardar o método numa variável já é útil, mas o grande poder do delegate é outro: um delegate pode ser parâmetro de um método. Assim, quem chama decide a regra.

decimal[] precos = [12.50m, 30m, 7.90m];

MostrarPrecos(precos, PrecoNormal);
MostrarPrecos(precos, BlackFriday);

void MostrarPrecos(decimal[] lista, RegraDePreco regra)
{
    foreach (decimal p in lista)
    {
        Console.WriteLine($"{p:C} -> {regra(p):C}");
    }
    Console.WriteLine("---");
}

static decimal PrecoNormal(decimal preco) => preco;
static decimal BlackFriday(decimal preco) => preco * 0.7m;

delegate decimal RegraDePreco(decimal preco);

$ dotnet run mostrar.cs
R$ 12,50 -> R$ 12,50
R$ 30,00 -> R$ 30,00
R$ 7,90 -> R$ 7,90
---
R$ 12,50 -> R$ 8,75
R$ 30,00 -> R$ 21,00
R$ 7,90 -> R$ 5,53
---

RegraDePreco regra

Um parâmetro como outro qualquer, só que o tipo é o delegate. Quem chamar MostrarPrecos tem de mandar um método com o formato certo.

regra(p)

Dentro do método, a regra recebida é chamada para cada preço. MostrarPrecos nunca sabe se está dando desconto ou não.

MostrarPrecos(precos, BlackFriday)

Na chamada, o método vai sem parênteses: você está entregando a regra, não o resultado dela.

O 7,90 × 0,7 dá 5,53 exatos, e o formato C (de currency, "moeda") mostra os centavos com o R$ da cultura brasileira (veja Formatar Números).

Sem delegate, a Ana precisaria de dois métodos quase iguais (MostrarPrecosNormais e MostrarPrecosBlackFriday), e um terceiro a cada promoção nova. Com o delegate, o laço é escrito uma vez só, e cada promoção é um método pequeno.

3. Vários métodos num delegate só (+= e -=)

Um delegate pode guardar uma lista de métodos. Quando você chama o delegate, todos rodam, na ordem em que foram adicionados. Isso se chama delegate multicast ("transmissão para vários"). É útil para avisos: quando a Ana vende um produto, o caixa e o estoque precisam saber.

Aviso? avisos = null;
avisos += AvisarCaixa;
avisos += AvisarEstoque;
avisos("Caderno vendido");

Console.WriteLine("---");
avisos -= AvisarCaixa;
avisos?.Invoke("Lápis vendido");

Console.WriteLine("---");
avisos -= AvisarEstoque;
Console.WriteLine(avisos is null);
avisos?.Invoke("Borracha vendida");
Console.WriteLine("fim");

static void AvisarCaixa(string msg) => Console.WriteLine($"[caixa] {msg}");
static void AvisarEstoque(string msg) => Console.WriteLine($"[estoque] {msg}");

delegate void Aviso(string mensagem);

$ dotnet run avisos.cs
[caixa] Caderno vendido
[estoque] Caderno vendido
---
[estoque] Lápis vendido
---
True
fim

E se o delegate devolve um valor?

Com vários métodos que devolvem algo, todos rodam, mas a chamada devolve só o resultado do último:

Calculo c = Dobro;
c += Triplo;
Console.WriteLine(c(10));
Console.WriteLine(c.GetInvocationList().Length);
Console.WriteLine(c.GetType().BaseType);

static int Dobro(int x) { Console.WriteLine("Dobro rodou"); return x * 2; }
static int Triplo(int x) { Console.WriteLine("Triplo rodou"); return x * 3; }

delegate int Calculo(int x);

$ dotnet run multicast.cs
Dobro rodou
Triplo rodou
30                        « só o resultado do último (Triplo); o 20 do Dobro se perdeu
2                         « GetInvocationList: a lista tem 2 métodos
System.MulticastDelegate  « todo tipo delegate é, por baixo, uma classe que herda daqui

Por isso, na prática, o multicast é usado com delegates void, como o Aviso. É assim que funcionam os eventos.

4. O delegate vazio: NullReferenceException

Chamar um delegate que está null (sem nenhum método) derruba o programa. O compilador avisa antes:

Este código tem um erro de propósito.

Aviso? avisos = null;
avisos("Caderno vendido");

delegate void Aviso(string mensagem);

$ dotnet run nulo.cs
/home/ana/cs/nulo.cs(2,1): warning CS8602: Desreferência de uma referência possivelmente nula.
Unhandled exception. System.NullReferenceException: Object reference not set to an instance of an object.
   at Program.<Main>$(String[] args) in /home/ana/cs/nulo.cs:line 2
$ echo $?
134

• O aviso CS8602 (do compilador, em português): "desreferência de uma referência possivelmente nula", ou seja, você está usando algo que pode ser null.
• A exceção (do programa rodando, em inglês): "referência de objeto não definida para uma instância de um objeto". Não havia método nenhum para chamar.
• O código de saída 134 é o de um programa que terminou com uma exceção não tratada.

Como consertar: chame com avisos?.Invoke("Caderno vendido");. O ?. só chama se houver método; se não houver, a linha não faz nada. Repare que avisos?("…") não existe em C#: com o ?., use sempre o Invoke.

Delegate próprio, Func ou lambda: qual usar

Você acabou de ver a forma "completa": declarar o tipo e escrever um método com nome para cada regra. Ela é a base de tudo, mas no dia a dia o C# oferece dois atalhos, cada um com aula própria:

Quando dá errado

RegraDePreco regra = Desconto;
Console.WriteLine(regra(50m));

static decimal Desconto(int porcento) => porcento;

delegate decimal RegraDePreco(decimal preco);

$ dotnet run assinatura.cs
/home/ana/cs/assinatura.cs(1,22): error CS0123: Nenhuma sobrecarga de "Desconto" corresponde ao representante "RegraDePreco"

Ocorreu uma falha no build. Corrija os erros de build e execute novamente.

RegraDePreco regra = Arredondar;
Console.WriteLine(regra(9.99m));

static int Arredondar(decimal preco) => (int)preco;

delegate decimal RegraDePreco(decimal preco);

$ dotnet run retorno.cs
/home/ana/cs/retorno.cs(1,22): error CS0407: "int Arredondar(decimal)" tem o tipo de retorno incorreto

Ocorreu uma falha no build. Corrija os erros de build e execute novamente.

RegraDePreco regra = PrecoNormal();
Console.WriteLine(regra(50m));

static decimal PrecoNormal(decimal preco) => preco;

delegate decimal RegraDePreco(decimal preco);

$ dotnet run parenteses.cs
/home/ana/cs/parenteses.cs(1,22): error CS7036: Não há nenhum argumento fornecido que corresponda ao parâmetro necessário 'preco' de 'PrecoNormal(decimal)'

Ocorreu uma falha no build. Corrija os erros de build e execute novamente.

RegraDePreco regra = PrecoNormal;
Console.WriteLine(regra(50m, 10));

static decimal PrecoNormal(decimal preco) => preco;

delegate decimal RegraDePreco(decimal preco);

$ dotnet run argumentos.cs
/home/ana/cs/argumentos.cs(2,19): error CS1593: Delegado "RegraDePreco" não obtém 2 argumentos

Ocorreu uma falha no build. Corrija os erros de build e execute novamente.

delegate decimal RegraDePreco(decimal preco);

RegraDePreco regra = PrecoNormal;
Console.WriteLine(regra(50m));

static decimal PrecoNormal(decimal preco) => preco;

$ dotnet run ordem.cs
/home/ana/cs/ordem.cs(3,1): error CS8803: As instruções de nível superior precisam preceder as declarações de namespace e de tipo.

Ocorreu uma falha no build. Corrija os erros de build e execute novamente.

Referência

Exercícios

decimal[] carrinho = [12.50m, 30m, 7.90m];

Console.WriteLine($"Total normal: {Total(carrinho):C}");

decimal Total(decimal[] precos)
{
    decimal soma = 0m;
    foreach (decimal p in precos)
    {
        soma += p;
    }
    return soma;
}

static decimal PrecoNormal(decimal preco) => preco;
static decimal BlackFriday(decimal preco) => preco * 0.7m;

delegate decimal RegraDePreco(decimal preco);

decimal[] carrinho = [12.50m, 30m, 7.90m];

Console.WriteLine($"Total normal: {Total(carrinho, PrecoNormal):C}");
Console.WriteLine($"Total Black Friday: {Total(carrinho, BlackFriday):C}");

decimal Total(decimal[] precos, RegraDePreco regra)
{
    decimal soma = 0m;
    foreach (decimal p in precos)
    {
        soma += regra(p);
    }
    return soma;
}

static decimal PrecoNormal(decimal preco) => preco;
static decimal BlackFriday(decimal preco) => preco * 0.7m;

delegate decimal RegraDePreco(decimal preco);

No código inicial, o compilador avisa CS8321 ("a função local 'PrecoNormal' está declarada, mas nunca é usada"), porque ninguém usa as regras ainda. O aviso some quando você as passa para o Total.

Resumo

• Um delegate é uma variável que guarda um método. O tipo dele descreve o formato: delegate decimal RegraDePreco(decimal preco);.
• Guarde o método sem parênteses (regra = BlackFriday;) e chame com regra(50m) ou regra.Invoke(50m).
• O método precisa ter os mesmos parâmetros (CS0123) e o mesmo retorno (CS0407) do delegate.
• Um delegate pode ser parâmetro: quem chama decide a regra, e o laço é escrito uma vez só.
• += e -= juntam e tiram métodos (multicast). Todos rodam na ordem; com retorno, vale o do último.
• Um delegate sem métodos é null; chamá-lo dá NullReferenceException. Use ?.Invoke(…).
• Num arquivo com instruções soltas, a declaração delegate fica no fim (CS8803).

Próxima aula: Lambdas, o jeito curto de escrever a regra direto onde ela é usada: p => p * 0.7m.