Suche…


Syntax

  • public delegate TResult Func<in T, out TResult>(T arg)
  • public delegate TResult Func<in T1, in T2, out TResult>(T1 arg1, T2 arg2)
  • public delegate TResult Func<in T1, in T2, in T3, out TResult>(T1 arg1, T2 arg2, T3 arg3)
  • public delegate TResult Func<in T1, in T2, in T3, in T4, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4)

Parameter

Parameter Einzelheiten
arg oder arg1 der (erste) Parameter der Methode
arg2 der zweite Parameter der Methode
arg3 der dritte Parameter der Methode
arg4 der vierte Parameter der Methode
T oder T1 der Typ des (ersten) Parameters der Methode
T2 der Typ des zweiten Parameters der Methode
T3 der Typ des dritten Parameters der Methode
T4 der Typ des vierten Parameters der Methode
TResult der Rückgabetyp der Methode

Ohne Parameter

Dieses Beispiel zeigt, wie ein Delegat erstellt wird, der die Methode kapselt, die die aktuelle Uhrzeit zurückgibt

static DateTime UTCNow()
{
    return DateTime.UtcNow;
}

static DateTime LocalNow()
{
    return DateTime.Now;
}

static void Main(string[] args)
{
    Func<DateTime> method = UTCNow;
    // method points to the UTCNow method
    // that retuns current UTC time  
    DateTime utcNow = method();

    method = LocalNow;
    // now method points to the LocalNow method
    // that returns local time

    DateTime localNow = method();
}

Mit mehreren Variablen

static int Sum(int a, int b)
{
    return a + b;
}

static int Multiplication(int a, int b)
{
    return a * b;
}

static void Main(string[] args)
{
    Func<int, int, int> method = Sum;
    // method points to the Sum method
    // that retuns 1 int variable and takes 2 int variables  
    int sum = method(1, 1);

    method = Multiplication;
    // now method points to the Multiplication method

    int multiplication = method(1, 1);
}

Lambda & anonyme Methoden

Eine anonyme Methode kann überall dort zugewiesen werden, wo ein Delegat erwartet wird:

Func<int, int> square = delegate (int x) { return x * x; }

Lambda-Ausdrücke können verwendet werden, um dasselbe auszudrücken:

Func<int, int> square = x => x * x;

In beiden Fällen können wir nun die in square gespeicherte Methode wie folgt aufrufen:

var sq = square.Invoke(2);

Oder als Abkürzung:

var sq = square(2);

Beachten Sie, dass für die typsichere Zuweisung die Parametertypen und der Rückgabetyp der anonymen Methode mit denen des Delegattyps übereinstimmen müssen:

Func<int, int> sum = delegate (int x, int y) { return x + y; } // error
Func<int, int> sum = (x, y) => x + y; // error

Parameter für Covariante und Kontravariante Typen

Func unterstützt auch Covariant & Contravariant

// Simple hierarchy of classes.
public class Person { }
public class Employee : Person { }

class Program
{
    static Employee FindByTitle(String title)
    {
        // This is a stub for a method that returns
        // an employee that has the specified title.
        return new Employee();
    }

    static void Test()
    {
        // Create an instance of the delegate without using variance.
        Func<String, Employee> findEmployee = FindByTitle;

        // The delegate expects a method to return Person,
        // but you can assign it a method that returns Employee.
        Func<String, Person> findPerson = FindByTitle;

        // You can also assign a delegate 
        // that returns a more derived type 
        // to a delegate that returns a less derived type.
        findPerson = findEmployee;

    }
}


Modified text is an extract of the original Stack Overflow Documentation
Lizenziert unter CC BY-SA 3.0
Nicht angeschlossen an Stack Overflow