Vous amène à passer en revue les délégués C#, les méthodes anonymes, Lambda, les délégués génériques, les exemples de code d'arborescence d'expression

Vous amène à revoir les délégués C#, les méthodes anonymes, Lambda, les délégués génériques, les exemples de code d'arbre d'expression :

Ce sont des clichés pour l'ancienne génération de programmeurs, rien de nouveau. C'est plein de charme. pour la nouvelle génération de programmeurs. Dans le passé, une grande partie de la nouvelle génération devait passer par un long processus d'étude, de compréhension et de pratique pour maîtriser des applications telles que la délégation et les arbres d'expression. Aujourd’hui j’essaie de le décrire de manière simple pour que tout le monde puisse lire ce blog en cinq minutes.

La première minute : Délégation

Certains manuels et blogs mentionneront des événements lorsqu'ils parleront de délégation. Bien que les événements soient une instance de délégation, afin de faciliter la compréhension, nous ne parlerons aujourd'hui que de délégation et non d'événements. Tout d'abord un morceau de code :

Le code ci-dessous complète une démonstration d'une application déléguée. Une commission se compose de trois étapes :

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;
    }
}

Étape 01 : Définissez d’abord un délégué à l’aide d’un délégué.

Étape 02 : Déclarez une méthode pour correspondre au délégué.

Étape 03 : utilisez cette méthode pour instancier ce délégué.

À ce stade, un délégué doit être complété et vous pouvez appeler le délégué.

Deuxième minute : Méthode anonyme

Comme vous le savez déjà à la dernière minute, il y a trois étapes pour compléter une candidature commandée. Vous ne pouvez pas le faire sans manquer une étape. Si vous voulez faire un grand pas, soyez prudent si vous faites un grand pas et ce sera le cas. blesser vos œufs. Mais Microsoft n'a pas peur de tirer les ficelles, et insiste pour transformer trois étapes en deux étapes ! Par conséquent, Microsoft utilise une méthode anonyme pour simplifier les trois étapes ci-dessus. Que dites-vous des méthodes anonymes ? Elles sont totalement inutiles en C#. Elles ne sont que la cerise sur le gâteau pour C#. Certaines personnes les ont ingénieusement nommées sucre syntaxique.

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);
    }
}

Étape 01 : utilisez d’abord un délégué pour définir un délégué.

Étape 02 : Utilisez cette méthode d'écriture délégué(int x, int y) { return x y; } pour attribuer une méthode au délégué. En fait, cette méthode d'écriture est une méthode anonyme.

A ce moment-là, vous serez surpris de constater qu'il ne s'agit pas de trois pas devant deux pas ?

Troisième minute : expression lambda

Avec l'ajout de quelques mots-clés de délégué à un programme initialement simple, le code devient soudainement profond et moins de gens comprennent les choses profondes, cela peut donc également être utilisé comme monnaie d'échange pour une augmentation de salaire. Mais la philosophie de conception de Microsoft pour C# est la simplicité et la facilité d'utilisation. Microsoft a essayé par tous les moyens de simplifier la méthode anonyme délégué(int x, int y) { return x y }, et Lambda est apparu. Permettez-moi d'examiner plusieurs façons d'écrire des expressions lambda :

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);
    }
}

Méthode 1 : supprimez simplement le délégué et ajoutez "=>" entre () et {}.

Méthode 2 : sur la base de la méthode 1, tous les types de paramètres sont éliminés.

Troisième méthode : si vous souhaitez le faire, faites-le de manière plus approfondie et supprimez {} et le mot-clé return.

Vous pouvez écrire n'importe laquelle de ces méthodes, mais ce n'est qu'une nuisance pour les débutants. Parfois, ils voient cette façon d'écrire, et parfois ils voient cette façon d'écrire, ce qui fascine les gens s'il n'y a personne pour les guider. vraiment confus et difficile. C'est là toute la difficulté.

Quatrième minute : Délégué générique

Comme la version .net n'est pas mise à jour, la nouvelle version doit être différente de l'ancienne version. Sinon, comment les ingénieurs Microsoft peuvent-ils rendre compte à leur patron ? Microsoft prépare donc à nouveau quelque chose de nouveau.

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);
    }
}

Qu'il s'agisse d'une méthode anonyme ou d'une expression Lambda, il existe deux étapes pour finaliser l'application d'un délégué. L'une consiste à définir un délégué et l'autre consiste à utiliser une méthode pour instancier un délégué. Microsoft a simplement combiné ces deux étapes en une seule. Utilisez Func pour simplifier la définition d'un délégué.

À ce stade, la candidature d'un délégué peut être complétée avec Func cAdd3 = (x, y) => où Func est ce qu'on appelle le délégué générique.

Cinquième minute : Arbre d'expression

En fait, l'arbre d'expression n'a rien à voir avec la délégation. Si cela doit être lié, disons simplement que l'arbre d'expression est un conteneur pour stocker la délégation. Si vous devez parler de manière plus professionnelle, l'arborescence d'expressions est une structure de données permettant d'accéder aux expressions Lambda. Lorsque vous utilisez une expression Lambda, récupérez-la directement à partir de l'expression et utilisez directement Compile(). Le code suivant :

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);
    }
}

Ce que j'ai mentionné est très superficiel, mais au moins cela a permis à tout le monde de consulter un autre article sur la délégation, les méthodes anonymes, Lambda, la délégation générique et les arbres d'expression.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!