Nehmen Sie an der Überprüfung von C#-Delegaten, anonymen Methoden, Lambda, generischen Delegaten und Codebeispielen für Ausdrucksbäume teil

Nehmen Sie eine Übersicht über C#-Delegierte, anonyme Methoden, Lambda, generische Delegaten und Codebeispiele für Ausdrucksbäume:

Das sind Klischees für die ältere Generation von Programmierern, nichts Neues. Es ist voller Charme für die neue Generation von Programmierern. In der Vergangenheit mussten viele Mitglieder der neuen Generation einen langen Prozess des Lernens, Verstehens und Übens durchlaufen, um Anwendungen wie Delegations- und Ausdrucksbäume zu beherrschen. Heute versuche ich es auf einfache Weise zu beschreiben, damit jeder diesen Blog in fünf Minuten lesen kann.

Die erste Minute: Delegation

In einigen Lehrbüchern und Blogs werden Ereignisse erwähnt, wenn es um Delegation geht. Um das Verständnis zu erleichtern, werden wir heute nur über Delegation und nicht über Ereignisse sprechen. Zuerst ein Stück Code:

Der folgende Code vervollständigt eine Demonstration einer delegierten Anwendung. Eine Provision besteht aus drei Schritten:

public partial class WebForm3 : System.Web.UI.Page
{
    //step01：首先用delegate定义一个委托 。
    public delegate int CalculatorAdd(int x, int y);

    protected void Page_Load(object sender, EventArgs e)
    {
        //step03：用这个方法来实例化这个委托。
        CalculatorAdd cAdd = new CalculatorAdd(Add);
        //int result = cAdd(5, 6);
        int result = cAdd.Invoke(5,6);
    }
    // step02：声明一个方法来对应委托。
    public int Add(int x, int y)
    {
        return x + y;
    }
}

Schritt 01: Definieren Sie zunächst mit Delegat einen Delegaten.

Schritt 02: Deklarieren Sie eine Methode, die dem Delegaten entspricht.

Schritt 03: Verwenden Sie diese Methode, um diesen Delegaten zu instanziieren.

Zu diesem Zeitpunkt sollte ein Delegate abgeschlossen sein und Sie können den Delegaten anrufen.

Zweite Minute: Anonyme Methode

Wie Sie bereits in letzter Minute wissen, gibt es drei Schritte, um einen Auftragsantrag abzuschließen. Sie können es nicht tun, ohne einen großen Schritt zu machen. Seien Sie vorsichtig, wenn Sie einen großen Schritt machen verletzt deine Eier. Aber Microsoft scheut sich nicht davor, die Strippen zu ziehen, und besteht darauf, aus drei Schritten zwei Schritte zu machen! Daher verwendet Microsoft eine anonyme Methode, um die oben genannten drei Schritte zu vereinfachen. Was halten Sie von anonymen Methoden? Sie sind in C# völlig entbehrlich. Sie sind nur das i-Tüpfelchen für C#.

public partial class WebForm3 : System.Web.UI.Page
{
    //step01：首先用delegate定义一个委托 
    public delegate int CalculatorAdd(int x, int y);

    protected void Page_Load(object sender, EventArgs e)
    {
        //step02：用这样的写法 delegate(int x, int y) { return x + y; }，把一个方法赋值给委托
        CalculatorAdd cAdd = delegate(int x, int y) { return x + y; };
        int result = cAdd.Invoke(5, 6);
    }
}

Schritt 01: Definieren Sie zunächst mit Delegat einen Delegaten.

Schritt 02: Verwenden Sie diese Schreibmethode „delegate(int x, int y) { return x + y;“, um dem Delegaten eine Methode zuzuweisen. Tatsächlich ist diese Schreibmethode eine anonyme Methode.

Zu diesem Zeitpunkt werden Sie überrascht sein, dass dies nicht drei Schritte vor zwei Schritten sind?

Dritte Minute: Lambda-Ausdruck

Durch das Hinzufügen einiger Delegate-Schlüsselwörter zu einem ursprünglich einfachen Programm wird der Code plötzlich tiefgreifender und weniger Menschen verstehen die tiefgreifenden Dinge, sodass dies auch als Verhandlungsgrundlage für eine Gehaltserhöhung verwendet werden kann. Die Designphilosophie von Microsoft für C# ist jedoch Einfachheit und Benutzerfreundlichkeit. Microsoft hat alle Mittel ausprobiert, um die anonyme Methode Delegate(int x, int y) { return x + y } zu vereinfachen, und Lambda erschien. Lassen Sie mich verschiedene Möglichkeiten zum Schreiben von Lambda-Ausdrücken betrachten:

public partial class WebForm3 : System.Web.UI.Page
{
    public delegate int CalculatorAdd(int x, int y);

    protected void Page_Load(object sender, EventArgs e)
    {
        //方法一：
        CalculatorAdd cAdd1 = (int x, int y) => { return x + y; };
        int result1 = cAdd1(5, 6);

        //方法二：
        CalculatorAdd cAdd2 = (x, y) => { return x + y; };
        int result2 = cAdd2(5, 6);

        //方法三：
        CalculatorAdd cAdd3 = (x, y) => x + y;
        int result3 = cAdd2(5, 6);
    }
}

Methode 1: Entfernen Sie einfach den Delegaten und fügen Sie „=>“ zwischen () und {} hinzu.

Methode 2: Eliminieren Sie basierend auf Methode 1 alle Parametertypen.

Methode Drei: Wenn Sie es tun möchten, gehen Sie gründlicher vor und entfernen Sie {} und das Schlüsselwort return.

Sie können jede dieser Methoden schreiben, aber für Anfänger ist es nur ein Ärgernis. Manchmal sehen sie diese Art des Schreibens, und manchmal sehen sie diese Art des Schreibens, was die Leute fasziniert wirklich verwirrt und schwierig sein.

Vierte Minute: Allgemeiner Delegat

Da die .net-Version nicht aktualisiert wird, muss sich die neue Version von der alten Version unterscheiden. Wie können Microsoft-Ingenieure sonst ihrem Chef Bericht erstatten? Microsoft hat also wieder etwas Neues vor.

public partial class WebForm3 : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        //方法一：
        Func<int,int,int> cAdd1 = (int x, int y) => { return x + y; };
        int result1 = cAdd1(5, 6);

        //方法二：
        Func<int, int, int> cAdd2 = (x, y) => { return x + y; };
        int result2 = cAdd2(5, 6);

        //方法三：
        Func<int, int, int> cAdd3 = (x, y) => x + y;
        int result3 = cAdd2(5, 6);
    }
}

Unabhängig davon, ob es sich um eine anonyme Methode oder einen Lambda-Ausdruck handelt, gibt es zwei Schritte, um die Anwendung eines Delegaten abzuschließen. Der eine besteht darin, einen Delegaten zu definieren, und der andere darin, eine Methode zum Instanziieren eines Delegaten zu verwenden. Microsoft hat diese beiden Schritte einfach zu einem Schritt zusammengefasst. Verwenden Sie Func, um die Definition eines Delegaten zu vereinfachen.

An diesem Punkt kann die Anwendung eines Delegaten mit Func abgeschlossen werden, wobei Func der sogenannte generische Delegat ist.

Fünfte Minute: Ausdrucksbaum

Tatsächlich hat der Ausdrucksbaum nichts mit der Delegation zu tun. Wenn eine Beziehung bestehen muss, sagen wir einfach, dass der Ausdrucksbaum ein Container zum Speichern der Delegation ist. Wenn Sie professioneller sprechen müssen, ist der Ausdrucksbaum eine Datenstruktur für den Zugriff auf Lambda-Ausdrücke. Wenn Sie einen Lambda-Ausdruck verwenden, rufen Sie ihn direkt aus dem Ausdruck ab und verwenden Sie Compile() direkt. Der folgende Code:

public partial class WebForm3 : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        Expression<Func<int, int, int>> exp = (x, y) => x + y;
        Func<int, int, int> fun = exp.Compile();
        int result = fun(2, 3);
    }
}

Was ich erwähnt habe, ist sehr oberflächlich, aber zumindest hat es jedem ermöglicht, einen weiteren Artikel über Delegation, anonyme Methoden, Lambda, generische Delegation und Ausdrucksbäume zu lesen.

Das obige ist der detaillierte Inhalt vonNehmen Sie an der Überprüfung von C#-Delegaten, anonymen Methoden, Lambda, generischen Delegaten und Codebeispielen für Ausdrucksbäume teil. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!