Partilhar via

Operador delegado

O delegate operador cria um método anónimo que pode converter num tipo de delegado.

A referência da linguagem C# documenta a versão mais recentemente lançada da linguagem C#. Contém também documentação inicial para funcionalidades em versões preliminares públicas para a próxima versão da linguagem.

A documentação identifica qualquer funcionalidade introduzida pela primeira vez nas últimas três versões da língua ou em pré-visualizações públicas atuais.

Sugestão

Para saber quando uma funcionalidade foi introduzida pela primeira vez em C#, consulte o artigo sobre o histórico de versões da linguagem C#.

Pode converter um método anónimo para tipos como System.Action e System.Func<TResult>. Muitos métodos usam estes tipos como argumentos.

Func<int, int, int> sum = delegate (int a, int b) { return a + b; };
Console.WriteLine(sum(3, 4));  // output: 7

Observação

As expressões lambda fornecem uma maneira mais concisa e expressiva de criar uma função anônima. Use o operador => para construir uma expressão lambda:

Func<int, int, int> sum = (a, b) => a + b;
Console.WriteLine(sum(3, 4));  // output: 7

Para mais informações sobre características das expressões lambda, como a captura de variáveis exteriores, veja expressões lambda.

Quando usas o delegate operador, podes omitir a lista de parâmetros. Se omitir a lista de parâmetros, cria um método anónimo que pode converter para um tipo delegado com qualquer lista de parâmetros, como mostra o exemplo seguinte:

Action greet = delegate { Console.WriteLine("Hello!"); };
greet();

Action<int, double> introduce = delegate { Console.WriteLine("This is world!"); };
introduce(42, 2.7);

// Output:
// Hello!
// This is world!

Esta funcionalidade é a única funcionalidade dos métodos anónimos que as expressões lambda não suportam. Em todos os outros casos, use uma expressão lambda para escrever código inline. Pode usar descartes para especificar dois ou mais parâmetros de entrada de um método anónimo que o método não utiliza:

Func<int, int, int> constant = delegate (int _, int _) { return 42; };
Console.WriteLine(constant(3, 4));  // output: 42

Para compatibilidade retroativa, se apenas um único parâmetro for nomeado _, o compilador trata _ como o nome desse parâmetro dentro de um método anónimo.

Use o static modificador quando declarar um método anónimo:

Func<int, int, int> sum = static delegate (int a, int b) { return a + b; };
Console.WriteLine(sum(10, 4));  // output: 14

Um método anônimo estático não pode capturar variáveis locais ou o estado da instância a partir do fechamento de escopos.

Use a delegate palavra-chave para declarar um tipo de delegado.

O compilador pode armazenar em cache o objeto delegado que cria a partir de um grupo de métodos. Considere o seguinte método:

static void StaticFunction() { }

Quando atribui o grupo de métodos a um delegado, o compilador armazena em cache o delegado:

Action a = StaticFunction;

Especificação da linguagem C#

Para obter mais informações, consulte a seção Expressões de Função Anónimas da Especificação da Linguagem C#.

Ver também

  • Last updated on