Anonyme Methoden (C#-Programmierhandbuch)Anonymous Methods (C# Programming Guide)

In Versionen von C# vor 2.0 bestand die einzige Möglichkeit zum Deklarieren eines Delegaten in der Verwendung von benannten Methoden.In versions of C# before 2.0, the only way to declare a delegate was to use named methods. Mit C# 2.0 wurden anonyme Methoden eingeführt, und in C# 3.0 und höher lösen Lambdaausdrücke anonyme Methoden als bevorzugten Weg zum Schreiben von Inlinecode ab.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. Die Informationen zu anonymen Methoden in diesem Thema gelten jedoch auch für Lambdaausdrücke.However, the information about anonymous methods in this topic also applies to lambda expressions. In einem Fall bietet eine anonyme Methode eine Funktion, über die Lambdaausdrücke nicht verfügen.There is one case in which an anonymous method provides functionality not found in lambda expressions. Anonyme Methoden ermöglichen das Auslassen der Parameterliste.Anonymous methods enable you to omit the parameter list. Das bedeutet, dass eine anonyme Methode in Delegaten mit verschiedenen Signaturen konvertiert werden kann.This means that an anonymous method can be converted to delegates with a variety of signatures. Dies ist bei Lambdaausdrücken nicht möglich.This is not possible with lambda expressions. Weitere Informationen zu Lambdaausdrücken finden Sie unter Lambdaausdrücke.For more information specifically about lambda expressions, see Lambda Expressions.

Das Erstellen anonymer Methoden ist im Grunde genommen ein Weg, um einen Codeblock als Delegatparameter zu übergeben.Creating anonymous methods is essentially a way to pass a code block as a delegate parameter. Hier sind zwei Beispiele: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) { /* ... */ };

Mit anonymen Methoden verringern Sie den Mehraufwand an Codierung beim Instanziieren von Delegaten, da Sie keine separate Methode erstellen müssen.By using anonymous methods, you reduce the coding overhead in instantiating delegates because you do not have to create a separate method.

So kann es nützlich sein, einen Codeblock anstatt eines Delegaten anzugeben, wenn das Erstellen einer Methode mit unnötigem Aufwand verbunden scheint.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. Ein gutes Beispiel ist das Starten eines neuen Threads.A good example would be when you start a new thread. Diese Klasse erstellt einen Thread und enthält zudem den Code, den der Thread ausführt, ohne dass eine zusätzliche Methode für den Delegaten erstellt wird.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();
}

HinweiseRemarks

Der Bereich der Parameter einer anonymen Methode ist der anonyme Methodenblock.The scope of the parameters of an anonymous method is the anonymous-method-block.

Es ist ein Fehler, wenn sich eine Sprunganweisung wie goto, break oder continue innerhalb des anonymen Methodenblocks befindet, wenn das Ziel außerhalb des Blocks liegt.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. Es ist auch ein Fehler, wenn sich eine Sprunganweisung wie goto, break oder continue außerhalb des anonymen Methodenblocks befindet, wenn das Ziel innerhalb des Blocks liegt.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.

Die lokalen Variablen und Parameter, deren Bereich eine anonyme Methodendeklaration enthält, werden als äußere Variablen der anonymen Methode bezeichnet.The local variables and parameters whose scope contains an anonymous method declaration are called outer variables of the anonymous method. Beispielsweise ist im folgenden Codesegment n eine äußere Variable:For example, in the following code segment, n is an outer variable:

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

Ein Verweis auf die äußere Variable n gilt als erfasst, wenn der Delegat erstellt wird.A reference to the outer variable n is said to be captured when the delegate is created. Anders als bei lokalen Variablen erstreckt sich die Lebensdauer einer erfassten Variablen so lange, bis die Delegaten, die auf die anonymen Methoden verweisen, für die automatische Speicherbereinigung verfügbar sind.Unlike local variables, the lifetime of a captured variable extends until the delegates that reference the anonymous methods are eligible for garbage collection.

Eine anonyme Methode kann nicht auf die Parameter ref oder out eines äußeren Bereichs zugreifen.An anonymous method cannot access the ref or out parameters of an outer scope.

Auf unsicheren Code kann nicht innerhalb des anonymen Methodenblocks zugegriffen werden.No unsafe code can be accessed within the anonymous-method-block.

Anonyme Methoden sind auf der linken Seite des is-Operators nicht zulässig.Anonymous methods are not allowed on the left side of the is operator.

BeispielExample

Im folgenden Beispiel werden zwei Möglichkeiten veranschaulicht, um einen Delegaten zu instanziieren:The following example demonstrates two ways of instantiating a delegate:

  • Zuordnen des Delegaten zu einer anonymen Methode.Associating the delegate with an anonymous method.

  • Zuordnen des Delegaten zu einer benannten Methode (DoWork).Associating the delegate with a named method (DoWork).

In beiden Fällen wird eine Meldung angezeigt, wenn der Delegat aufgerufen wird.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.
*/

Siehe auchSee Also

C#-ReferenzC# Reference
C#-ProgrammierhandbuchC# Programming Guide
DelegatenDelegates
Lambda-AusdrückeLambda Expressions
Unsicherer Code und ZeigerUnsafe Code and Pointers
MethodenMethods
Delegate mit benannten im Vergleich zu anonymen MethodenDelegates with Named vs. Anonymous Methods