Métodos anónimos (Guía de programación de C#)Anonymous Methods (C# Programming Guide)

En las versiones de C# anteriores a 2.0, la única manera de declarar un delegado era usar métodos con nombre.In versions of C# before 2.0, the only way to declare a delegate was to use named methods. C# 2.0 introdujo los métodos anónimos y en C# 3.0 y versiones posteriores, las expresiones lambda reemplazan a los métodos anónimos como la manera preferida de escribir código en línea.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. En cambio, la información sobre los métodos anónimos de este tema también se aplica a las expresiones lambda.However, the information about anonymous methods in this topic also applies to lambda expressions. Existe un caso en el que un método anónimo proporciona funciones que no se encuentran en las expresiones lambda.There is one case in which an anonymous method provides functionality not found in lambda expressions. Los métodos anónimos le permiten omitir la lista de parámetros.Anonymous methods enable you to omit the parameter list. Esto significa que un método anónimo puede convertirse en delegados con una variedad de firmas.This means that an anonymous method can be converted to delegates with a variety of signatures. Esto no es posible con las expresiones lambda.This is not possible with lambda expressions. Para obtener más información específica sobre las expresiones lambda, vea Expresiones lambda.For more information specifically about lambda expressions, see Lambda Expressions.

Crear métodos anónimos es básicamente una manera de pasar un bloque de código como un parámetro de delegado.Creating anonymous methods is essentially a way to pass a code block as a delegate parameter. Dos ejemplos: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) { /* ... */ };

Mediante los métodos anónimos, reduce la sobrecarga de codificación al crear instancias de delegados porque no tiene que crear un método independiente.By using anonymous methods, you reduce the coding overhead in instantiating delegates because you do not have to create a separate method.

Por ejemplo, especificar un bloque de código en lugar de un delegado puede ser útil en una situación en la que tener que crear un método puede parecer una sobrecarga innecesaria.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. Un buen ejemplo sería cuando inicia un nuevo subproceso.A good example would be when you start a new thread. Esta clase crea un subproceso y también contiene el código que el subproceso ejecuta sin crear un método adicional para el 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();
}

ComentariosRemarks

El ámbito de los parámetros de un método anónimo es el bloque de método anónimo.The scope of the parameters of an anonymous method is the anonymous-method-block.

Es un error tener una instrucción de salto, como goto, break o continue, dentro del bloque de método anónimo si el destino está fuera del bloque.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. También es un error tener una instrucción de salto, como goto, break o continue, fuera del bloque de método anónimo si el destino está dentro del bloque.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.

Las variables locales y los parámetros cuyo ámbito contiene una declaración de método anónimo se denominan variables externas del 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 ejemplo, en el siguiente segmento de código, n es una variable 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); };

Una referencia a la variable externa n se dice que está capturada cuando se crea el delegado.A reference to the outer variable n is said to be captured when the delegate is created. A diferencia de las variables locales, la duración de una variable capturada se extiende hasta que los delegados que hacen referencia a los métodos anónimos son aptos para la recolección de elementos no utilizados.Unlike local variables, the lifetime of a captured variable extends until the delegates that reference the anonymous methods are eligible for garbage collection.

Un método anónimo no puede tener acceso a los parámetros in, ref o out de un ámbito externo.An anonymous method cannot access the in, ref or out parameters of an outer scope.

No se puede tener acceso a ningún código no seguro dentro del bloque de método anónimo.No unsafe code can be accessed within the anonymous-method-block.

Los métodos anónimos no se permiten en el lado izquierdo del operador is.Anonymous methods are not allowed on the left side of the is operator.

EjemploExample

En el ejemplo siguiente se muestran dos maneras de crear instancias de un delegado:The following example demonstrates two ways of instantiating a delegate:

  • Asociar el delegado con un método anónimo.Associating the delegate with an anonymous method.

  • Asociar el delegado con un método con nombre (DoWork).Associating the delegate with a named method (DoWork).

En cada caso, se muestra un mensaje cuando se invoca al delegado.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 = 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.
*/

Vea tambiénSee also