一:什么叫委托
通过反射发现,委托其实是一个类,继承自System.MulticastDelegate,但是System.MulticastDelegate这个类是特殊类,不能被继承
二:委托的声明
public delegate void NoReturnNoParaOutClass();
public class MyDelete
{
public delegate void NoReturnNoPara<T>(T t);
public delegate void NoReturnNoPara();
public delegate void NoReturnWithPara(int x, int y);
public delegate int WithReturnNoPara();
public delegate string WithReturnWithPara(out int x, ref int y);
}
委托可以声明在类外面,可以声明再类里面
三:委托的实例和调用
private int GetSomething()
{
return 1;
}
private int GetSomething2()
{
return 2;
}
private int GetSomething3()
{
return 3;
}
private void DoNothing()
{
Console.WriteLine("This is DoNothing");
}
private static void DoNothingStatic()
{
Console.WriteLine("This is DoNothingStatic");
}
public string ParaReturn(out int x, ref int y)
{
throw new Exception();
}
//多种途径实例化,要求传递一个参数类型,返回值都跟委托一致的方法
{
WithReturnWithPara method = new WithReturnWithPara(ParaReturn);
int x = 0;
int y = 0;
var dd = method.Invoke(out x, ref y);
}
//begininvoke
{
WithReturnNoPara method = new WithReturnNoPara(this.GetSomething);
int iResult = method.Invoke();
iResult = method();
var result = method.BeginInvoke(null, null);//异步调用
method.EndInvoke(result);
}
{
NoReturnNoPara method = new NoReturnNoPara(this.DoNothing);
//委托实力的调用,参数和委托约束的一致
method.Invoke(); //1
//method(); //2
//method.BeginInvoke(null, null); //3
//this.DoNothing(); //1,2,3都等同于this.DoNothing
}
{
NoReturnNoPara method = new NoReturnNoPara(DoNothingStatic);
}
{
NoReturnNoPara method = new NoReturnNoPara(Student.StudyAdvanced);
}
{
NoReturnNoPara method = new NoReturnNoPara(new Student().Study);
}
四:为什么要使用委托
有时候我们声明一个方法,直接调用蛮好的,为啥还要使用委托,然后还要先声明,再实例化,再inovke调用呢?
下面我们举个例子,比如一个人问好这件事情,不同人问候方式不一样,我们会先定义一个类型,如枚举
public enum PeopleType { Chinese, America, Japanese }
然后通过不同的类型来判断问候方式不同,如下
/// 为不同的人,进行不同的问候
/// 传递变量--判断一下----执行对应的逻辑
/// </summary>
/// <param name="name"></param>
/// <param name="peopleType"></param>
public void SayHi(string name, PeopleType peopleType)
{
switch (peopleType)
{
case PeopleType.Chinese:
Console.WriteLine($"{name}晚上好");
break;
case PeopleType.America:
Console.WriteLine($"{name},good evening");
break;
case PeopleType.Japanese:
Console.WriteLine($"{name},&&%*^^***@@@&&&&");
break;
default:
throw new Exception("wrong peopleType"); //遇到异常报错
}
}
这样做的好处是:以后如果增加公共逻辑等比较容易,但是如果类型比较多,这个方法会变成无限制改动,导致方法难以维护,于是很多人想着增加分支,就增加方法--不影响别的方法的思路来改善
public void SayHiChinese(string name)
{
Console.WriteLine($"{name}晚上好");
}
public void SayHiJapanese(string name)
{
Console.WriteLine($"{name},&&%*^^***@@@&&&&");
}
public void SayHiAmerican(string name)
{
Console.WriteLine($"{name},good evening");
}
然后上层判断调用
这样做的好处是:修改某个方法--不影响别的方法 ,但是缺点却是:增加公共逻辑---多个方法就有很多重复代码
那么我们想:既增加逻辑方便,又维护简单,鱼肉熊掌,如何兼得呢?
我们可以把相应的逻辑做为参数传进来,这样就解决了我们的问题
具体我们可以按照以下来做:
public void SayHiPerfact(string name, SayHiDeletegate method)
{
Console.WriteLine("增加开始日志");
method.Invoke(name);
Console.WriteLine("增加结束日志");
}
public delegate void SayHiDeletegate(string name);
然后调用的时候如下:
SayHiDeletegate method = new SayHiDeletegate(SayHiChinese);
这样就做到了
1:逻辑解耦,方便维护
2:代码重构,去掉重复
其实这也是我们选择使用委托的两大优点
注意:以上我们纯粹为了定义委托而定义委托,其实框架已经我们帮我们定义了Action 和Func这两个委托,Action是没有返回值,Func是有返回值的,这两个委托类已经足够我们使用了,所以有时候我们使用的时候,没有必要自己再去定义,而直接使用即可