在C#中我们经常会碰到事件,尤其是在WPF或者WinForm中,窗体加载、或者点击一个按钮,都会触发事件。实际上,事件是对委托的封装。如果不进行封装,让委托暴露给调用者,调用者就可以把委托变量重新引用到新的委托对象,也就删除了当前要调用的方法列表;更糟糕的是,公共的委托成员打破了封装不仅导致代码难以维护和调试,而且会导致应用程序有安全风险。下面分别说明。
1、委托
委托可以理解为一种协议。委托,是什么意思呢?举个例子,你碰到一件事,你需要让别人来帮你做(可能你还有别的事情要做),这就是委托,把你现在不能做的事让别人去做。为什么说委托就像一个协议呢,因为你不想把事情搞砸了,所以你“委托”的这个人做的这件事,你需要给他定一个标准。在C#中就是给所委托的对象定义好签名,参数有几个,分别是什么类型,委托方法需要反馈给你什么东西(或者不反馈)。从这种意义上理解,委托就像是一种协议。下面是例子。
public delegate int MyDelegate(int x, int y);
class Delegate_Demo {
static void Main(string[] args) {
//实例化被委托者
Helper helper = new Helper();
//创建委托对象
MyDelegate myDele = new MyDelegate(helper.Add);
int sum = myDele(1, 2);
Console.WriteLine(sum);
}
}
class Helper {
public Helper() {}
public int Add(int num1, int num2) {
return num1 + num2;
}
}
上述例子中public delegate int MyDelegate(int x, int y);声明了一个委托,告诉被委托者这件事你要这么干,我给你两个整数,你计算他们的和,怎么计算我不管,计算完之后你把和给我。
泛型委托
泛型的委托,就是然参数的类型不确定,例如代码改写为
using System;
using System.Collections.Generic;
using System.Text;
namespace TestApp
{
/// <summary>
/// 委托
/// </summary>
/// <param name="s1"></param>
/// <param name="s2"></param>
/// <returns></returns>
public delegate string ProcessDelegate<T,S>(T s1, S s2);
class Program
{
static void Main(string[] args)
{
/* 调用方法 */
ProcessDelegate<string,int> pd = new ProcessDelegate<string,int>(new Test().Process);
Console.WriteLine(pd("Text1", 100));
}
}
public class Test
{
/// <summary>
/// 方法
/// </summary>
/// <param name="s1"></param>
/// <param name="s2"></param>
/// <returns></returns>
public string Process(string s1,int s2)
{
return s1 + s2;
}
}
}
2、事件
在某件事情发生时,一个对象可以通过事件通知另一个对象。比如,前台界面一个求和按钮被点击了,他通知你,可以把a和b这两个数相加了。这就是一个事件。可以看出事件是在一个时间节点去触发另外一件事情,而另外一件事情怎么去做,他不会关心。就事件来说,关键点就是什么时候,让谁去做。
在编译器处理event关键字时,会自动提供注册和注销方法以及任何必要的委托类型成员变量(私有的),因此不能从触发事件的对象去调用它们,event关键字就像一个语法糖,节省了我们打字的时间。
定义一个事件有两步,首先定义一个委托,它包括了这件事的“协议”和委托方法(由谁去做);其次,用event关键字和相关委托声明这个事件。事件像是一个接口,封装了委托所定的“协议”。由于委托已经定义了协议,剩下的就是按这个协议去办事,至于怎么做它并不关心。下面是一个例子。
public delegate int MyDelegate(int x, int y);
class Delegate_Demo {
//声明事件
static event MyDelegate myEvent;
static void Main(string[] args) {
//交代事件
myEvent += new Helper().Add;
int sum = myEvent(3, 4);
Console.WriteLine(sum);
}
}
class Helper {
public Helper() {}
public int Add(int num1, int num2) {
return num1 + num2;
}
}
从上面可以看出,调用者无法访问委托对象。
参考代码2
using System;
using System.Collections.Generic;
using System.Text;
namespace TestApp
{
/// <summary>
/// 委托
/// </summary>
/// <param name="s1"></param>
/// <param name="s2"></param>
/// <returns></returns>
public delegate void ProcessDelegate(object sender, EventArgs e);
class Program
{
static void Main(string[] args)
{
/* 第一步执行 */
Test t = new Test();
/* 关联事件方法,相当于寻找到了委托人 */
t.ProcessEvent += new ProcessDelegate(t_ProcessEvent);
/* 进入Process方法 */
Console.WriteLine(t.Process());
Console.Read();
}
static void t_ProcessEvent(object sender, EventArgs e)
{
Test t = (Test)sender;
t.Text1 = "Hello";
t.Text2 = "World";
}
}
public class Test
{
private string s1;
public string Text1
{
get { return s1; }
set { s1 = value; }
}
private string s2;
public string Text2
{
get { return s2; }
set { s2 = value; }
}
public event ProcessDelegate ProcessEvent;
void ProcessAction(object sender, EventArgs e)
{
if (ProcessEvent == null)
ProcessEvent += new ProcessDelegate(t_ProcessEvent);
ProcessEvent(sender, e);
}
//如果没有自己指定关联方法,将会调用该方法抛出错误
void t_ProcessEvent(object sender, EventArgs e)
{
throw new Exception("The method or operation is not implemented.");
}
void OnProcess()
{
ProcessAction(this, EventArgs.Empty);
}
public string Process()
{
OnProcess();
return s1 + s2;
}
}
}
感觉到了什么?是不是和代码注入了差不多,相当于是可以用任意符合委托接口(委托确实很像接口)的代码,注入到Process过程。在他返回之前给他赋值。
3、回调函数
回调函数就是把一个方法的传给另外一个方法去执行。回调函数只是一个功能片段,由用户按照回调函数的调用约定来实现的一个函数。先看一个例子。
public delegate int MyDelegate(int x, int y);
class Delegate_Demo {
//声明事件
static event MyDelegate myEvent;
static void Main(string[] args) {
int sum = MyAdd(1, 2, new Helper().Add);
Console.WriteLine(sum);
}
private static int MyAdd(int a, int b, MyDelegate myDele) {
return myDele(a, b);
}
}
class Helper {
public Helper() {}
public int Add(int num1, int num2) {
return num1 + num2;
}
}
参考代码2
using System;
using System.Collections.Generic;
using System.Text;
namespace TestApp
{
/// <summary>
/// 委托
/// </summary>
/// <param name="s1"></param>
/// <param name="s2"></param>
/// <returns></returns>
public delegate string ProcessDelegate(string s1, string s2);
class Program
{
static void Main(string[] args)
{
/* 调用方法 */
Test t = new Test();
string r1 = t.Process("Text1", "Text2", new ProcessDelegate(t.Process1));
string r2 = t.Process("Text1", "Text2", new ProcessDelegate(t.Process2));
string r3 = t.Process("Text1", "Text2", new ProcessDelegate(t.Process3));
Console.WriteLine(r1);
Console.WriteLine(r2);
Console.WriteLine(r3);
}
}
public class Test
{
public string Process(string s1,string s2,ProcessDelegate process)
{
return process(s1, s2);
}
public string Process1(string s1, string s2)
{
return s1 + s2;
}
public string Process2(string s1, string s2)
{
return s1 + Environment.NewLine + s2;
}
public string Process3(string s1, string s2)
{
return s2 + s1;
}
}
}
可以看出,可以把任意一个符合这个委托的方法传递进去,意思就是说这部分代码是可变的。而设计上有一个抽离出可变部分代码的原则,这种用法无疑可以用到那种场合了。