Comprendre la délégation C# (Délégué) est facile à comprendre et explique en termes simples
-
- Qu'est-ce qu'une commission ?
- Instancier le délégué (Délégué)
- Pour le dire franchement, c'est similaire à un pointeur vers une méthode fonction. On peut définir le type du délégué tout comme on définit le type du pointeur.
- Exemple d'utilisation simple
- Objet de la délégation
- multidiffusion
- Légende : scénarios d'utilisation de la délégation
- structure d'exécution
- Le mécanisme de la fonction de rappel
Qu'est-ce qu'une commission ?
Un délégué est avant tout un type de données. On peut définir un type délégué tout comme une structure. Un délégué (Delegate) est une variable de type référence qui contient une référence à une méthode. Les références peuvent être modifiées au moment de l'exécution
Définition de la délégation
//语法
delegate <return type> <delegate-name> <parameter list>
//实例
public delegate int MyDelegate (string s);
Instancier le délégué (Délégué)
Par exemple:
public delegate void printString(string s);
...
printString ps1 = new printString(WriteToScreen);
printString ps2 = new printString(WriteToFile);
Pour le dire franchement, c'est similaire à un pointeur vers une méthode fonction. On peut définir le type du délégué tout comme on définit le type du pointeur.
Lors de la définition d'un type délégué, vous devez spécifier le type de paramètre et la valeur de retour de la fonction. Une fois le type délégué déclaré, l'objet délégué doit être créé à l'aide du mot clé new et est lié à une méthode spécifique. Lors de la création d'un délégué, les paramètres passés à la nouvelle instruction sont écrits comme un appel de méthode, mais sans paramètres.
Exemple d'utilisation simple
using System;
delegate int NumberChanger(int n);
namespace DelegateAppl
{
class TestDelegate
{
static int num = 10;
public static int AddNum(int p)
{
num += p;
return num;
}
public static int MultNum(int q)
{
num *= q;
return num;
}
public static int getNum()
{
return num;
}
static void Main(string[] args)
{
// 创建委托实例
NumberChanger nc1 = new NumberChanger(AddNum);
NumberChanger nc2 = new NumberChanger(MultNum);
// 使用委托对象调用方法
nc1(25);
Console.WriteLine("Value of Num: {0}", getNum());
nc2(5);
Console.WriteLine("Value of Num: {0}", getNum());
Console.ReadKey();
}
}
}
Ceci n'est qu'une simple introduction à l'utilisation.On peut voir que ce n'est pas différent de l'appel de la méthode directement dans le programme principal, et ce n'est pas l'utilisation réelle.
Objet de la délégation
multidiffusion
Les objets délégués peuvent être combinés à l'aide de l'opérateur "+". Un délégué fusionné appelle les deux délégués qu'il fusionne. Seuls les délégués du même type peuvent être fusionnés. L'opérateur "-" peut être utilisé pour supprimer les délégués de composants des délégués fusionnés.
En utilisant cette fonctionnalité utile des délégués, vous pouvez créer une liste d'appels de méthodes à appeler lorsque le délégué est appelé. C'est ce qu'on appelle le multicasting délégué, également appelé multicast. Le programme suivant illustre la multidiffusion déléguée
static void Main(string[] args)
{
// 创建委托实例
NumberChanger nc;
NumberChanger nc1 = new NumberChanger(AddNum);
NumberChanger nc2 = new NumberChanger(MultNum);
nc = nc1;
nc += nc2;
// 调用多播
nc(5);
Console.WriteLine("Value of Num: {0}", getNum());
Console.ReadKey();
}
}
}
Légende : scénarios d'utilisation de la délégation
La délégation, d'où le nom, utilisons une métaphore vivante. Dans l'entreprise, le patron/l'appelant n'a pas besoin de me confier/d'activer la fonction de délégation, mais peut personnellement organiser le travail de Zhang San/func1 et Li Si/func2, c'est-à-dire , appelez directement, À ce stade, vous devrez peut-être préparer les paramètres de l'appel et le code de la méthode d'appel, comme un appel en boucle.
Le patron/l'appelant peut également organiser le travail de Zhang San et Li Si via la fonction de ma/délégation d'activation. En même temps, vous pouvez également spécifier Zhang San/func1 et Li Si/func2 ensemble. Work/ ±Multicast peut également être étendu avec de nouveaux employés/méthodes.
Il est similaire au polymorphisme d'héritage de classe, mais plus flexible. Pour activer la fonction déléguée, il n'est pas nécessaire de savoir quelle fonction elle souhaite appeler ni son implémentation spécifique. Elle doit simplement utiliser les paramètres donnés par l'appelant. La classe parent le fait. pas besoin de s'inquiéter de la façon dont la sous-classe l'implémente. , grâce à l'attribution de sous-types, les méthodes remplacées par les sous-classes peuvent être appelées.
//委托
// 委托声明
public delegate void doSomething(string s);
//定义 回调函数 ，公司里的员工 张三，李四.............
public static void ZangSan(string a) {
Console.WriteLine("zhangsan"+a);
}
public static void LiSi(string a)
{
Console.WriteLine("lisi"+a);
}
/// <summary>
/// 中介，委托处理 ,使用此方法触发委托回调
/// </summary>
/// <param name="from">开始</param>
/// <param name="to">结束</param>
/// <param name="fb">委托引用</param>
private static void handleDelegate(int from, int to, doSomething ds)
{
//一些预处理 ，这样使用委托就比直接调用方便了
for (int val = from; val <= to; val++)
{
if (ds != null)
{
ds(val.ToString());
}
//ds?.Invoke(val); 简化版本调用
}
}
//主函数，调用者 老板
public void testDelegate()
{
//老板通过我/中介 给张三安排工作，
doSomething dsZhangSan = new doSomething(ZangSan);
//给张三李四 按顺序安排工作 //按序执行
doSomething dsLisi = new doSomething(LiSi);
doSomething ds = dsZhangSan + dsLisi;
//在调用的时可以给张三,李四传参数，这里在handleDelegate里面给了 ds(val.ToString());
handleDelegate(0, 3, ds);
//方法的返回值，参数必须完全一样，符合委托类型的定义
}
structure d'exécution
Le mécanisme de la fonction de rappel
Considérez-moi comme un intermédiaire indépendant qui fournit des services, et le patron/la partie mettant en œuvre la fonction, Zhang San/func1, Li Si/func2 ~~~ sont de la même entreprise. Lorsque nous coopérons, le patron désigne Zhang San ou Li Si... , Et je n'ai pas besoin de m'en soucier, j'appelle juste Zhang San et Li Si lorsque les conditions particulières se présentent.
⑴定义一个回调函数；
⑵提供函数实现的一方在初始化的时候，将回调函数的函数指针注册给调用者；
⑶当特定的事件或条件发生的时候，调用者使用函数指针调用回调函数对事件进行处理。