庖丁解牛——深入解析委托和事件

何为委托：

　　　　 static void Main(string[] args)
{
Console.WriteLine((4 % 2 == 0) ? "偶数" : "奇数");
Console.WriteLine((5 % 2 == 0) ? "偶数" : "奇数");
Console.ReadKey();
}

static void Main(string[] args)
{
Console.WriteLine("请输入一个数字:");
int i = int.Parse(Console.ReadLine());
Console.WriteLine((i%2==0)?"偶数":"奇数");
Console.ReadKey();
}

//委托是一种定义方法签名的类型。 当实例化委托时，可以将其实例与任何具有兼容签名的方法相关联。 可以通过委托实例调用方法。
//一个委托声明：
public delegate void ChangeDelegate(int i);
class Program
{
static void Main(string[] args)
{
ChangeDelegate c = null;
if (DateTime.Now.Second%2==0)
{
c = Even;//委托可以理解为函数指针(安全)，并且委托类型ChangeDelegate约束了参数类型，所以c可以指向Even方法
c(DateTime.Now.Second);
}
else
{
//c = Odd;
c = new ChangeDelegate(Odd);//标准写法
c(DateTime.Now.Second);
}
Console.ReadKey();

}
static void Even(int i)
{
Console.WriteLine("{0}是偶数",i);
}
static void Odd(int i)
{
Console.WriteLine("{0}是奇数",i);

}
}

class Program
{
static void Main(string[] args)
{
int[] arr = { 1,2,3,4,5,6,7,8,9};
List<int> newList=Filter(arr,IsOdd);
Console.WriteLine(string.Join("-",newList.ToArray()));
Console.ReadKey();

}
/// <summary>
/// 判断是否为偶数
/// </summary>
/// <param name="i"></param>
/// <returns></returns>
static bool IsEven(int i)
{
return i%2==0;
}
/// <summary>
/// 判断是否为奇数
/// </summary>
/// <param name="i"></param>
/// <returns></returns>
static bool IsOdd(int i)
{
return i%2==1;

}

static List<int> Filter(int[] value, FilterDelegate f)
{
List<int> list=new List<int> ();
foreach (var item in value)
{
if (f(item))
{
list.Add(item);
}
}
return list;
}
}
delegate bool FilterDelegate(int i);

　　事件和委托的联系：学习事件之前，先来用委托来模拟实现事件:

class Program
{
static void Main(string[] args)
{
Counter c = new Counter();
c.onCount = Count;//相当于订阅了一个事件
c.onCount += Count_2;//可以多个人同时监听了
int j = 0;
while (j<=100)
{
j++;
c.Next();
}
Console.ReadKey();
}
static void Count(int value)
{
Console.WriteLine("Count监听了{0}是偶数", value);
}
static void Count_2(int value)
{
Console.WriteLine("Count_2监听了{0}是偶数", value);
}
}
class Counter
{
public OnCountDelegate onCount;//把委托对象声明为一个字段
private int i = 0;
public void Next()
{
i++;
if (i%2==0)
{
if (onCount!=null)
{
//解耦：解除耦合。
//不用关心到底指向谁，调用就行
onCount(i);//触发事件，调用onCount指向的函数，相当于把事件通知出去
}
}
}
}
public delegate void OnCountDelegate(int value);

c.onCount = Count;
c.onCount += Count_2;
　相当于监听事件，触发事件时，只要哦调用onCount指向的函数，这样相当于把事件通知出去。所以上面这个Demo之后，我们再可以对委托来实现事件进行扩展：
　我们自定义一个双击火箭手按钮[用户控件]：
　

namespace 双击火箭手按钮
{
//声明一个委托
public delegate void DoubleClickDelegate();
public partial class DoubleClickButton : UserControl
{
public DoubleClickButton()
{
InitializeComponent();
}

private int i;
//把一个的委托对象定义为Public字段
public DoubleClickDelegate OnDoubleClick;

private void button1_Click(object sender, EventArgs e)
{

i++;
if (i==2)
{
i = 0;
if (OnDoubleClick!=null)
{
OnDoubleClick();//调用事件的响应函数
}
}
}
}
}

OnDoubleClick事件进行监听:

private void Form1_Load(object sender, EventArgs e)
{
doubleClickButton1.OnDoubleClick = doFire;
doubleClickButton1.OnDoubleClick += doIce;        }
void doFire()
{
MessageBox.Show("双击火枪手开火");
}
void doIce()
{
MessageBox.Show("双击火枪手下冰雨");
}

这样一个简单的用户控件就完成了，双击两下触发了OnDoubleClick事件，并且去执行相关联的响应函数(doFire,doIce)。

接着我们在对这个程序进行修改，来干扰我们的双击火枪手按钮：

private void button1_Click(object sender, EventArgs e)
{
doubleClickButton1.OnDoubleClick = null;
}

上面的操作意味着我们把委托变量指向了NULL，这就破坏了之前我们的监听事件。
再比如：在模拟执行这个按钮中写入：

private void button2_Click(object sender, EventArgs e)
{
doubleClickButton1.OnDoubleClick();
}

public OnCountDelegate onCount;//把委托对象声明为一个字段

//把委托申明为Private,防止外界直接=NULL或者OnDoubleClick()仿照事件
　private DoubleClickDelegate OnDoubleClick;

//把委托申明为Private,防止外界直接=NULL或者OnDoubleClick()仿照事件
private DoubleClickDelegate _OnDoubleClick;
public void AddDoubleClick(DoubleClickDelegate d)
{
_OnDoubleClick += d;
}

private void button1_Click(object sender, EventArgs e)
{

i++;
if (i==2)
{
i = 0;
if (_OnDoubleClick!=null)
{
_OnDoubleClick();//调用事件的响应函数
}
}
}

namespace 三击暴走按钮
{
public delegate void RampageDelegate();
public partial class RampageThreeClickButton : UserControl
{

//定义一个私有的委托类型字段
private RampageDelegate onRampage;
//类似于属性那样对委托进行了封装
public event RampageDelegate OnRampage
{
add { onRampage += value; }
remove { onRampage -= value; }

}
private int count;
public RampageThreeClickButton()
{
InitializeComponent();
}

private void button1_Click(object sender, EventArgs e)
{
count++;
if (count==3)
{
if (onRampage!=null)
{
onRampage();
}
count = 0;
}
}
}
}

public Form1()
{
InitializeComponent();
}

private void rampageThreeClickButton1_Load(object sender, EventArgs e)
{
//对事件进行注册，即监听事件，只能用+=,不用用=,这样防止了外界=NULL干扰
rampageThreeClickButton1.OnRampage += doFire;
//同理
rampageThreeClickButton1.OnRampage += new RampageDelegate(doThunder);
rampageThreeClickButton1.OnRampage += new RampageDelegate(doIce);

}
void doFire()
{
MessageBox.Show("烈焰之怒");
}
void doThunder()
{
MessageBox.Show("上古雷霆");
}
void doIce()
{
MessageBox.Show("极地冰雨");
}

namespace DoubleKissinUButton
{
public delegate void KissinUDelegate();//委托别忘记
public partial class KissinUButton : UserControl
{
public event KissinUDelegate onKissinU;//用Event关键字来申明一个事件
public KissinUButton()
{
InitializeComponent();
}
private int i = 0;

private void button1_Click(object sender, EventArgs e)
{
i++;
if (i==2)
{
if (onKissinU!=null)
{
onKissinU();
}
}
}
}
}

public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
kissinUButton1.onKissinU += new KissinUDelegate(kissinUButton1_onKissinU);
}

void kissinUButton1_onKissinU()
{
MessageBox.Show("点我我就吻吻你");
}

private void Form1_Load(object sender, EventArgs e)
{

}
}

通过反编译看看：