DelegatenDelegates

Ein Delegattyp stellt Verweise auf Methoden mit einer bestimmten Parameterliste und dem Rückgabetyp dar.A delegate type represents references to methods with a particular parameter list and return type. Delegate ermöglichen die Behandlung von Methoden als Entitäten, die Variablen zugewiesen und als Parameter übergeben werden können.Delegates make it possible to treat methods as entities that can be assigned to variables and passed as parameters. Delegate ähneln dem Konzept von Funktionszeigern, die Sie in einigen anderen Sprachen finden. Im Gegensatz zu Funktionszeigern sind Delegate allerdings objektorientiert und typsicher.Delegates are similar to the concept of function pointers found in some other languages, but unlike function pointers, delegates are object-oriented and type-safe.

Im folgenden Beispiel wird ein Delegattyp namens Function deklariert und verwendet.The following example declares and uses a delegate type named Function.

using System;
delegate double Function(double x);
class Multiplier
{
    double factor;
    public Multiplier(double factor) 
    {
        this.factor = factor;
    }
    public double Multiply(double x) 
    {
        return x * factor;
    }
}
class DelegateExample
{
    static double Square(double x) 
    {
        return x * x;
    }
    static double[] Apply(double[] a, Function f) 
    {
        double[] result = new double[a.Length];
        for (int i = 0; i < a.Length; i++) result[i] = f(a[i]);
        return result;
    }
    static void Main() 
    {
        double[] a = {0.0, 0.5, 1.0};
        double[] squares = Apply(a, Square);
        double[] sines = Apply(a, Math.Sin);
        Multiplier m = new Multiplier(2.0);
        double[] doubles =  Apply(a, m.Multiply);
    }
}

Eine Instanz des Delegattyps Function kann auf jede Methode verweisen, die ein double-Argument und einen double-Wert akzeptiert.An instance of the Function delegate type can reference any method that takes a double argument and returns a double value. Die Apply-Methode wendet eine bestimmte Funktion auf die Elemente eines double[] an, wobei ein double[] mit den Ergebnissen zurückgegeben wird.The Apply method applies a given Function to the elements of a double[], returning a double[] with the results. In der Main-Methode wird Apply verwendet, um drei verschiedene Funktionen auf ein double[] anzuwenden.In the Main method, Apply is used to apply three different functions to a double[].

Ein Delegat kann entweder auf eine statische Methode verweisen (z.B. Square oder Math.Sin im vorherigen Beispiel) oder eine Instanzmethode (z.B. m.Multiply im vorherigen Beispiel).A delegate can reference either a static method (such as Square or Math.Sin in the previous example) or an instance method (such as m.Multiply in the previous example). Ein Delegat, der auf eine Instanzmethode verweist, verweist auch auf ein bestimmtes Objekt, und wenn die Instanzmethode durch den Delegaten aufgerufen wird, wird das Objekt this im Aufruf.A delegate that references an instance method also references a particular object, and when the instance method is invoked through the delegate, that object becomes this in the invocation.

Delegaten können auch mit anonymen Funktionen erstellt werden, die dynamisch erstellte „Inlinemethoden“ sind.Delegates can also be created using anonymous functions, which are "inline methods" that are created on the fly. Anonyme Funktionen können die lokalen Variablen der umgebenden Methoden sehen.Anonymous functions can see the local variables of the surrounding methods. Folglich kann das obige Multiplikatorbeispiel ohne Verwendung einer Multiplikatorklasse leichter geschrieben werden:Thus, the multiplier example above can be written more easily without using a Multiplier class:

double[] doubles =  Apply(a, (double x) => x * 2.0);

Eine interessante und nützliche Eigenschaft eines Delegaten ist, dass er die Klasse der Methode, auf die er verweist, nicht kennt oder sie ignoriert; wichtig ist nur, dass die referenzierte Methode die gleichen Parameter und den gleichen Rückgabetyp hat wie der Delegat.An interesting and useful property of a delegate is that it does not know or care about the class of the method it references; all that matters is that the referenced method has the same parameters and return type as the delegate.