Métodos anônimos (Guia de Programação em C#)Anonymous Methods (C# Programming Guide)

Nas versões anteriores ao C# 2.0, a única maneira de declarar um delegado era usar métodos nomeados.In versions of C# before 2.0, the only way to declare a delegate was to use named methods. O C# 2.0 apresentou os métodos anônimos e no C# 3.0 e versões posteriores, as expressões lambda substituem os métodos anônimos como a melhor maneira de gravar código embutido.C# 2.0 introduced anonymous methods and in C# 3.0 and later, lambda expressions supersede anonymous methods as the preferred way to write inline code. No entanto, as informações sobre os métodos anônimos apresentadas neste tópico também se aplicam às expressões lambda.However, the information about anonymous methods in this topic also applies to lambda expressions. Há um caso em que um método anônimo fornece uma funcionalidade não encontrada em expressões lambda.There is one case in which an anonymous method provides functionality not found in lambda expressions. Métodos anônimos habilitam a omissão da lista de parâmetros.Anonymous methods enable you to omit the parameter list. Isso significa que um método anônimo pode ser convertido em delegados com uma variedade de assinaturas.This means that an anonymous method can be converted to delegates with a variety of signatures. Isso não é possível com expressões lambda.This is not possible with lambda expressions. Para obter mais informações específicas sobre as expressões lambda, consulte Expressões Lambda.For more information specifically about lambda expressions, see Lambda Expressions.

Essencialmente, criar métodos anônimos é uma forma de passar um bloco de código como um parâmetro delegado.Creating anonymous methods is essentially a way to pass a code block as a delegate parameter. Veja dois exemplos:Here are two examples:

// Create a handler for a click event.
button1.Click += delegate(System.Object o, System.EventArgs e)
                   { System.Windows.Forms.MessageBox.Show("Click!"); };
// Create a delegate.
delegate void Del(int x);

// Instantiate the delegate using an anonymous method.
Del d = delegate(int k) { /* ... */ };

Ao usar métodos anônimos, a sobrecarga de codificação será reduzida nos delegados instanciados, pois não é necessário criar um método separado.By using anonymous methods, you reduce the coding overhead in instantiating delegates because you do not have to create a separate method.

Por exemplo, especificar um bloco de código em vez de um delegado pode ser útil em uma situação em que a criação de um método parece ser uma sobrecarga desnecessária.For example, specifying a code block instead of a delegate can be useful in a situation when having to create a method might seem an unnecessary overhead. Um bom exemplo é quando um novo thread é iniciado.A good example would be when you start a new thread. Essa classe cria um thread e também contém o código executado pelo thread sem criar um método adicional para o delegado.This class creates a thread and also contains the code that the thread executes without creating an additional method for the delegate.

void StartThread()
{
    System.Threading.Thread t1 = new System.Threading.Thread
      (delegate()
            {
                System.Console.Write("Hello, ");
                System.Console.WriteLine("World!");
            });
    t1.Start();
}

ComentáriosRemarks

O escopo dos parâmetros de um método anônimo é o bloco de método anônimo.The scope of the parameters of an anonymous method is the anonymous-method-block.

É um erro ter uma instrução de hiperlink, como goto, break ou continue, dentro do bloco de método anônimo se o destino estiver fora do bloco.It is an error to have a jump statement, such as goto, break, or continue, inside the anonymous method block if the target is outside the block. Também é um erro ter uma instrução de hiperlink, como goto, break ou continue, fora do bloco de método anônimo se o destino estiver dentro do bloco.It is also an error to have a jump statement, such as goto, break, or continue, outside the anonymous method block if the target is inside the block.

As variáveis locais e parâmetros cujo escopo contém uma declaração de método anônimo são chamados variáveis externas do método anônimo.The local variables and parameters whose scope contains an anonymous method declaration are called outer variables of the anonymous method. Por exemplo, no segmento de código a seguir, n é uma variável externa:For example, in the following code segment, n is an outer variable:

int n = 0;
Del d = delegate() { System.Console.WriteLine("Copy #:{0}", ++n); };

Uma referência à variável externa n é considerada capturada quando o delegado é criado.A reference to the outer variable n is said to be captured when the delegate is created. Ao contrário de variáveis locais, o tempo de vida de uma variável capturada se estende até os delegados que referenciam os métodos anônimos se tornarem elegíveis para a coleta de lixo.Unlike local variables, the lifetime of a captured variable extends until the delegates that reference the anonymous methods are eligible for garbage collection.

Um método anônimo não pode acessar os parâmetros in, ref e out de um escopo externo.An anonymous method cannot access the in, ref or out parameters of an outer scope.

Nenhum código não seguro pode ser acessado dentro do bloco de método anônimo.No unsafe code can be accessed within the anonymous-method-block.

Os métodos anônimos não são permitidos no lado esquerdo do operador is.Anonymous methods are not allowed on the left side of the is operator.

ExemploExample

O exemplo a seguir demonstra duas maneiras de criar uma instância para um delegado:The following example demonstrates two ways of instantiating a delegate:

  • Associando o delegado a um método anônimo.Associating the delegate with an anonymous method.

  • Associando o delegado a um método nomeado (DoWork).Associating the delegate with a named method (DoWork).

Em cada caso, uma mensagem será exibida quando o delegado for invocado.In each case, a message is displayed when the delegate is invoked.

// Declare a delegate.
delegate void Printer(string s);

class TestClass
{
    static void Main()
    {
        // Instantiate the delegate type using an anonymous method.
        Printer p = delegate(string j)
        {
            System.Console.WriteLine(j);
        };

        // Results from the anonymous delegate call.
        p("The delegate using the anonymous method is called.");

        // The delegate instantiation using a named method "DoWork".
        p = new Printer(TestClass.DoWork);

        // Results from the old style delegate call.
        p("The delegate using the named method is called.");
    }

    // The method associated with the named delegate.
    static void DoWork(string k)
    {
        System.Console.WriteLine(k);
    }
}
/* Output:
    The delegate using the anonymous method is called.
    The delegate using the named method is called.
*/

Consulte tambémSee Also

Referência de C#C# Reference
Guia de Programação em C#C# Programming Guide
DelegadosDelegates
Expressões LambdaLambda Expressions
Código não seguro e ponteirosUnsafe Code and Pointers
MétodosMethods
Delegados com métodos nomeados vs. métodos anônimosDelegates with Named vs. Anonymous Methods