C# Learning Diary 25 --- Méthodes anonymes, délégués Func et expressions lambda

Dans les versions de C# antérieures à 2.0, la seule façon de déclarer un délégué était d'utiliser une méthode nommée. C# 2.0 a introduit les méthodes anonymes (délégué), et dans C# 3.0 et versions ultérieures, les expressions lambda ont remplacé les méthodes anonymes comme moyen préféré d'écrire du code en ligne.

Délégué anonyme (méthode) :

Le nom du délégué anonyme n'est pas exact. Il devrait être appelé plus précisément méthode anonyme (en bref, les deux signifient la même chose. chose). J'ai déjà mentionné dans Delegate Type qu'un délégué est utilisé pour faire référence à une méthode qui a la même étiquette qu'elle. En d’autres termes, vous pouvez utiliser un objet délégué pour appeler une méthode pouvant être référencée par le délégué (le paramètre est le nom de la méthode). Les méthodes anonymes, en revanche, prennent un bloc de code comme paramètre de délégué (le paramètre est le code qui implémente la fonction). En utilisant des méthodes anonymes, vous réduisez la surcharge de codage requise pour instancier le délégué car vous n'en avez pas. pour créer une méthode distincte.

Modifier la méthode anonyme :

La méthode anonyme est-elle directement montée dans le bloc de code au sein du délégué, ou elle doit être déclarée en utilisant le mot-clé délégué pour créer un délégué exemple.

　 　　delegate void MyDelegate(int i); //Déclarer un délégué

      MyDelegate my = délégué(int i){/* Code block＊／} //En créant une instance de délégué Implémenter une méthode anonyme

Instance de méthode anonyme :

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace Test1  
{  
    class Program  
    { //声明一个委托  
        delegate void MyDelegate(string str);   
        //定义一个实名方法  
        public static void fun(string str)    
        {  
            Console.WriteLine("这是一个 {0} 方法", str);  
        }  
        static void Main(string[] args)  
        {  
            //创建一个委托实例，里面包含一个匿名方法  
            MyDelegate examp1 = delegate(string name)   
            {  
              Console.WriteLine("这是一个 {0} 方法",name); //代码块  
            };  
            examp1("匿名");  //调用匿名方法  
  
            MyDelegate examp2 = new MyDelegate(fun); //在委托中实名注册一个fun命名方法  
            examp2("实名");  //调用命名方法  
        }  
    }  
}

Résultat :

Paramètres de la méthode anonyme La portée est le « bloc de méthode anonyme ».

C'est une erreur d'utiliser des instructions de saut (telles que goto, break ou continue) à l'intérieur d'un bloc de méthode anonyme si la cible est en dehors du bloc. C'est également une erreur d'utiliser des instructions de saut (telles que goto, break ou continue) en dehors d'un bloc de méthode anonyme si la cible est à l'intérieur du bloc.

Func Délégué :

Dans le passé, lorsque nous utilisions le délégué délégué, nous devions déclarer une classe de délégué à l'avance puis enregistrer le méthode avec le délégué, telle que :

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace Test1  
{  
    class Program  
    {  
        delegate string MyDelegate(string s);//声明委托  
        public static string Toup(string str) //定义方法  
        {  
            return str.ToUpper();  
        }  
        static void Main(string[] args)  
        {  
            string str = "abc";  
              
            MyDelegate my = Toup; //注册方法  
            Console.WriteLine(my(str));//调用方法 结果 ABC  
              
        }  
    }  
}

Si les conditions ne nous permettent pas de déclarer une classe de délégué dans le programme, mais que nous devons utiliser un délégué, que devons-nous faire ? À ce stade, nous pouvons envisager d'utiliser le délégué Func. FuncLe dernier paramètre dans <> est le type de valeur de retour. Les précédents sont tous les types de paramètres de méthode entrants. Leurs fonctions sont similaires aux délégués, mais aucune déclaration n'est requise. Délégué Func :

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace Test1  
{  
    class Program  
    {  
        public static string Toup(string str) //定义方法  
        {  
            return str.ToUpper();  
        }  
        static void Main(string[] args)  
        {  
            string str = "abc";  
  
            Func<string, string> change = Toup; //泛型委托  
            Console.WriteLine(change(str));//调用方法 结果 ABC  
              
        }  
    }  
}

En comparaison, les résultats des deux sont les mêmes, mais Func est beaucoup plus simple que Delegate, mais Delegate peut charger des méthodes anonymes. Par exemple, dans l'exemple ci-dessus, nous utilisons des méthodes anonymes. :

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace Test1  
{  
    class Program  
    {  
        delegate string MyDelegate(string s);//声明委托  
  
        static void Main(string[] args)  
        {  
            string str = "abc";  
            //创建匿名方法  
            MyDelegate my = delegate(string s) { return s.ToUpper(); };   
            Console.WriteLine(my(str)); //结果 ABC  
              
        }  
    }  
}

Func Ça va aussi ? Func peut également créer des méthodes anonymes, et il n'est pas nécessaire de les déclarer, comme suit :

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace Test1  
{  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            string str = "abc";  
            //创建匿名方法  
            Func<string, string> change = delegate(string s) { return s.ToUpper(); };  
            Console.WriteLine(change(str)); //结果 ABC  
              
        }  
    }  
}

Par rapport aux méthodes anonymes ci-dessus, nous constatons que lors de la création de méthodes anonymes, les deux sont implémentées via des délégués (Delegate est toujours utilisé), ne pouvons-nous pas utiliser un délégué ? est une méthode anonyme qui peut être utilisée pour créer un type d'arborescence de délégué ou d'expression. En utilisant des expressions lambda, vous pouvez écrire des fonctions locales qui peuvent être transmises comme arguments ou renvoyées comme valeur d'un appel de fonction. Pour créer une expression Lambda, vous spécifiez les paramètres d'entrée (le cas échéant) sur le côté gauche de l'opérateur Lambda =>, puis entrez une expression ou un bloc d'instructions de l'autre côté. Par exemple, l'expression lambda x => x * x spécifie un argument nommé x et renvoie le carré de x .

Ainsi, dans l'exemple ci-dessus, nous utilisons l'expression lambda pour créer une méthode anonyme et la modifions en :

Dans le type délégué délégué, nous pouvons également utiliser l'expression lambda pour créer des méthodes anonymes :

Ce qui précède est le contenu du journal d'apprentissage C# 25 --- Méthodes anonymes, délégués Func et expressions lambda. Pour plus de contenu connexe, veuillez faire attention. vers le site Web PHP chinois (www.php. cn) !

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace Test1  
{  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            string str = "abc";  
            //lambda 表达式  
            Func<string, string> change = s => s.ToUpper(); //传入string 类型s 返回s.ToUpper();  
            Console.WriteLine(change(str)); //结果 ABC  
              
        }  
    }  
}