operador delegate

O delegate operador cria um método anônimo que você pode converter em um tipo delegado.

A linguagem C# faz referência a documentos da versão mais recentemente lançada da linguagem C#. Ele também contém a documentação inicial para funcionalidades em pré-visualizações públicas para o próximo lançamento do idioma.

A documentação identifica qualquer recurso introduzido pela primeira vez nas três últimas versões do idioma ou nas versões prévias públicas atuais.

Dica

Para descobrir quando um recurso foi introduzido pela primeira vez em C#, consulte o artigo sobre o histórico de versão da linguagem C#.

Você pode converter um método anônimo em tipos como System.Action e System.Func<TResult>. Muitos métodos usam esses 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 obter mais informações sobre recursos de expressões lambda, como capturar variáveis externas, consulte expressões Lambda.

Ao usar o delegate operador, você pode omitir a lista de parâmetros. Se você omitir a lista de parâmetros, criará um método anônimo que poderá converter em um tipo delegado com qualquer lista de parâmetros, como mostra o exemplo a seguir:

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!

Essa funcionalidade é o único recurso de métodos anônimos que as expressões lambda não dão suporte. Em todos os outros casos, use uma expressão lambda para escrever código embutido. Você pode usar descartes para especificar dois ou mais parâmetros de entrada de um método anônimo que o método não usa:

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

Para compatibilidade com versões anteriores, se apenas um único parâmetro for nomeado _, o compilador tratará _ como o nome desse parâmetro dentro de um método anônimo.

Use o static modificador ao 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 de escopos delimitantes.

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

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

static void StaticFunction() { }

Quando você 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ônima da especificação da linguagem C#.

Consulte também

• Operadores e expressões C#
• Operador =>