1.委托
1.1什么是委托
委托委托 官网解释: 委托是安全封装方法的类型,类似于 C 和 C++ 中的函数指针。 与 C 函数指针不同的是,委托是面向对象的、类型安全的和可靠的。 委托的类型由委托的名称确定。
个人理解:委托就是一个方法的模板。它可以接收签名(签名一致就是方法的参数与返回值类型与其一致)与它一致的方法作为参数传递给它执行。
1.2 如何定义委托
使用关键字 delegate 声明委托
public delegate int GetNum(int a, int b);
除了使用delegate 定义 委托以外C#提供两个定义好的泛型委托 (Action 与 Func) (当然你也可以使用delegate自定义泛型委托)
这里先介绍两个C#定义的委托,相信很多人都在使用,不管你清不清楚什么是委托
Action:是无返回值的泛型委托。
下面action 表示无参,无返回值的委托
private void WTBtn_Click(object sender, EventArgs e)
{
Action action = new Action(AA);//定义委托
action();//使用方式1
action.Invoke();//使用方式2
}
private void AA()
{
Console.WriteLine("我是传入的无参无返回值的委托方法");
}
下面action 表示有传入参数int,string无返回值的委托
private void WTBtn_Click(object sender, EventArgs e)
{
Action<int,string> action = new Action<int, string>(AA);
action(1,"");//使用方式1
action.Invoke(1, "");//使用方式2
}
private void AA(int a,string b)
{
Console.WriteLine("我是传入的有参无返回值的委托方法");
}
Func:是有返回值的泛型委托。Func<object,string,int> object,string为参数。int为返回值
下面action 表示有传入参数int返回值string的委托
private void WTBtn_Click(object sender, EventArgs e)
{
Func<int,string> action = new Func<int, string>(AA);
//a=b="我是传入的有参无返回值的委托方法"
var a = action(1);//使用方式1
var b= action.Invoke(1);//使用方式2
}
private string AA(int a)
{
Console.WriteLine("我是传入的有参无返回值的委托方法");
return "我是传入的有参无返回值的委托方法";
}
运行结果如下图:
下面action 表示有无参数有返回值string的委托
private void WTBtn_Click(object sender, EventArgs e)
{
Func<string> action = new Func<string>(AA);
//a=b="我是传入的有参无返回值的委托方法"
var a = action();//使用方式1
var b= action.Invoke();//使用方式2
}
private string AA()
{
Console.WriteLine("我是传入的有参无返回值的委托方法");
return "我是传入的有参无返回值的委托方法";
}
C#自带的委托说完了,下面说 delegate 自定义的委托
下面代码定义了一个委托和一个静态类的方法。委托的级别与类等同,所以可以定义在命名空间里,当然也能定义在类里。
/// <summary>
/// 定义委托
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns>
public delegate int GetNum(int a, int b);
public static class WTModel
{
/// <summary>
/// 加法
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns>
public static int Add(int a,int b)
{
Console.WriteLine("执行Add了方法");
return a + b;
}
/// <summary>
/// 减法
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns>
public static int Sub(int a, int b)
{
Console.WriteLine("执行Sub了方法");
return a - b;
}
/// <summary>
/// 乘法
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns>
public static int Multi(int a, int b)
{
Console.WriteLine("执行Multi了方法");
return a * b;
}
/// <summary>
/// 除法
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns>
public static int Division(int a, int b)
{
Console.WriteLine("执行Division了方法");
if (b == 0)
{
return 0;
}
return a / b;
}
}
定义的GetNum委托与C#自带的两个委托是同级的,使用方式也是一页,只不C#自带的是泛型的,GetNum却是固定了两个参数为int类型且返回值是int类型的签名。故此能传入GetNum的方法的参数与返回值必须与GetNum保持一致。
使用方式:下面将上面Add方法传入委托并执行。
private void WTBtn_Click(object sender, EventArgs e)
{
//实例化方式1
GetNum num = new GetNum(WTModel.Add);
//使用方法1
var a = num(1, 2);
//使用方法2
var b = num.Invoke(1, 2);
}
执行结果:
值得注意的是,上述的委托执行方式都是同步的,并不是说把方法给到委托就会自动开启新的线程。看下面执行例子:
private void WTBtn_Click(object sender, EventArgs e)
{
//实例化方式1
GetNum num = new GetNum(WTModel.Add);
//使用方法1
var a = num(1, 2);
//使用方法2
var b = num.Invoke(1, 2);
Console.WriteLine("我是一定是最后执行的");
}
执行结果可初步看出是在委托执行了两次Add方法调用后才打印最后一段文字的(当然此处并不严谨,用于说明同步足够了):
那么如何异步执行呢 ,这里就不得不提BeginInvoke了 ,如下:
private void WTBtn_Click(object sender, EventArgs e)
{
//实例化方式1
GetNum num = new GetNum(WTModel.Add);
//使用方法1
var a = num(1, 2);
//使用方法2
//倒数第二个参数为回调函数,暂用null,
//最后一个参数是给回调函数传入参数的参数,暂用null
//IAsyncResult result = num.BeginInvoke(1, 2, null, null);
var b = num.BeginInvoke(1,2,null,null);
Console.WriteLine("我是不一定是最后执行的了");
}
运行结果你看第二次调用Add就不一样了吧:
BeginInvoke在NetCore不支持,NetFamework支持 NetCore有更好的多线程功能来支持实现类似功能。所以在NET Core中需要自己手动去开启线程和实现异步。例如下面(在Famework里也可以这样使用异步):
/// <summary>
/// 定义委托
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns>
public delegate Task<int> GetNum(int a, int b);
public static class WTModel
{
/// <summary>
/// 加法
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns>
public static Task<int> Add(int a, int b)
{
return Task.Run(() =>
{
Console.WriteLine("执行Add了方法");
return a + b;
});
}
}
private void WTBtn_Click(object sender, EventArgs e)
{
//实例化方式1
GetNum num = new GetNum(WTModel.Add);
//使用方法1
var a = num(1, 2);
//使用方法2
var b = num.Invoke(1,2);
Console.WriteLine("我是不一定是最后执行的了");
}
执行结果:
1.3:多播委托
所谓多播委托就是给委托传了多个方法,执行委托的时候会按照传入的顺序依次执行方法,当然传入的方法要注意错误处理,否则中件某个方法异常会导致后续方法无法执行,若委托有返回值,返回的值是最后一个方法的返回值。
定义多播(+=或者-=):
private void WTBtn_Click(object sender, EventArgs e)
{
//多播委托
//实例化方式1
GetNum num = new GetNum(WTModel.Add);
GetNum num1 = WTModel.Multi;//实例化方式2
num += num1;
num += WTModel.Sub;
var c = num(1, 2);//调用一次会依次执行Add、Multi、Sub方法最终返回的值是最后一个委托的方法的返回值。
}
1.4 实际应用
说了这么多,委托到底好在哪里呢,很多人都有这个疑问吧。下面举个例子就知道了 。
仍以上面定义的GetNum委托和其四个方法为基础。
正常我们要算加法直接使用Add方法不久一步到位了吗,为何还需要多此一举定义个委托来完成调用呢,这应该是很多看到这里的人的疑惑。
场景一:委托作为参数执行不同的方法,这样在WTBtn_Click方法中就只用调用Use1就能计算不同的值:
private void WTBtn_Click(object sender, EventArgs e)
{
Use1(1, 2, WTModel.Add);
Use1(1, 2, WTModel.Sub);
Use1(1, 2, WTModel.Multi);
Use1(1, 2, WTModel.Division);
}
private void Use1(int a, int b, GetNum num)
{
var A = num(1, 2);
}
场景2:实现根据不同地方输出产出的水果是啥
方法1:if或者switch以switch为例:
private string Use(string name)
{
string a = "";
switch (name)
{
case "广州": a = "苹果"; break;
case "重庆": a = "香蕉"; break;
case "四川": a = "梨"; break;
case "广西": a = "西瓜"; break;
default: break;
}
return a;
}
使用:
Console.WriteLine(Use("广州"));
方法2:定义四个方法,分别调用方法
public static class WTModel
{
public static void GZ(string name)
{
if (name == "广州")
{
Console.WriteLine("苹果");
}
}
public static void CQ(string name)
{
if (name == "重庆")
{
Console.WriteLine("香蕉");
}
}
public static void SC(string name)
{
if (name == "四川")
{
Console.WriteLine("梨");
}
}
public static void GX(string name)
{
if (name == "广西")
{
Console.WriteLine("西瓜");
}
}
}
使用:
private void WTBtn_Click(object sender, EventArgs e)
{
string name = "广州";
WTModel.GZ(name);
WTModel.GX(name);
WTModel.CQ(name);
WTModel.SC(name);
}
方法3、使用委托:
定义委托和其四个方法
/// <summary>
/// 定义委托
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns>
public delegate void GetName(string name);
public static class WTModel
{
public static void GZ(string name)
{
if (name == "广州")
{
Console.WriteLine("苹果");
}
}
public static void CQ(string name)
{
if (name == "重庆")
{
Console.WriteLine("香蕉");
}
}
public static void SC(string name)
{
if (name == "四川")
{
Console.WriteLine("梨");
}
}
public static void GX(string name)
{
if (name == "广西")
{
Console.WriteLine("西瓜");
}
}
}
使用委托:
private void WTBtn_Click(object sender, EventArgs e)
{
GetName get = WTModel.GZ;
get += WTModel.GX;
get += WTModel.CQ;
get += WTModel.SC;
Use("广州", get);
}
private void Use(string name, GetName get)
{
get.Invoke(name);
}
三个方法都可以实现根据地方不同输出相应水果。调用结果都是如下;
从三个方法写法和调用来看似乎方法一最为简单。
那么,现在你的程序已经是开发好了,这个时候突然来了两个需求。
需求1:新增一个地方的水果:
方法一需要新增一行case代码 。
方法二需要新增一个方法。
方法三需要新增一个方法。
看起来仍是方法一简单,但是 如果你使用的是是打包好的DLL文件,那么你就没办法直接增加代码,除非能重写方法。
需求2:在输出水果前先输出产地。
方法一 需要编辑每行case代码 。
方法二 需要编辑每个方法。
方法三 仅需在Use方法里新增一行即可。
若你使用的是是打包好的DLL文件且方法无法被重写,那似乎仅方法三能满足需求。
1.5 事件
本来准备单独说的,但事件本质是基于委托实现的观察者模式的应用。贴两个觉得可以的链接自行去看吧。
事件的理论即使用注意:C# 事件(event)_c# event-CSDN博客
事件的应用理解:分分钟用上C#中的委托和事件 - 雾中人 - 博客园
结语:个人认为委托的主要作用在于实现代码的重用,业务的解耦,保持代码的稳定性以及扩展性。暂时就说这么多吧,仅个人理解。