Fork me on GitHub

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

这篇博文我不讲委托和事件的概念,因为大段的文字概念没有任何意义。

具体想了解,委托和事件的概念可以MSDN查阅。

我这篇文章的主题思路是委托如何一步步进化成事件:

何为委托--->委托来实现事件--->用方法对委托的封装--->Event的

add,remove方法的引入--->标准事件写法--->反编译探究竟。

用几个例子以及Reflector反编译探究委托和事件的关系。不足之处,还望多多指教... 

何为委托:

首先,委托是一种类型,是一种定义了方法签名的类型。

委托可以理解为函数指针(安全),并且委托约束了方法的签名(由返回类型和参数组成),

所以实例化委托时,可以将其实例与任何具有相同签名(由返回类型和参数组成)得方法相关联,

如果按照C语言函数指针理解,即委托实例指向某个方法。

为什么要用委托:

举个简单的例子:

例如,需要判断一个数是为奇数还是偶数?

可能我们会这样实现:

     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);
         
        }
    }

上面代码可以看出,程序员并不知道委托实例到底指向那个函数,但他可以确定,指向的那个方法必定是受ChangeDelegate约束的。

再看一个例子,我们要对数组进行操作:

 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);

 

 所以,static List<int> Filter(int[] value, FilterDelegate f),这儿只需要传过来一个方法,

而我们程序员并不关心这是个什么方法,能替我们做什么,这就是委托的好处。

 

 

 

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

 

    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();//调用事件的响应函数
                }
            }
        }
    }
}

然后我们在Form1中托入一个我们自定义的DoubleClickButton:

这儿我们可以仿照普通Button按钮监听Click事件:  this.button1.Click += new System.EventHandler(this.button1_Click);来那样做:对DoubleClickButton的

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;

再对私有的委托用一个AddDoubleClick进行对外界的过滤,所以完整代码应该是这样的:

 //把委托申明为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();//调用事件的响应函数
                }
            }
        }

上面这样处理之后,我们的控件就不会被外界干扰了。

但是这样操作太复杂,所以微软为我们提供了更为简便的方式既 Event:

对上面的双击火枪手按钮在做稍微修改:

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;
            }
        }
    }
}

再将定义好的暴走控件拖到Form1中:

后台代码是这样的:

       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("极地冰雨");
        }

现在还能干扰吗?当然不行:

 

 

 

OK,到目前为止,大家对委托和事件肯定有一个深刻的认识:

我们对事件进行反编译之后,相信一切疑问皆是浮云:

我们举一个标准的事件案例:

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)
        {

        }
    }

通过反编译看看:

 

 

点击进入看看:

 

委托和事件没有可比性,因为委托是类型,事件是对象,上面说的是委托的对象(用委托方式实现的事件)和(标准的event方式实现)事件的区别。事件的内部是用委托实现的。 因为对于事件来讲,外部只能“注册自己+=、注销自己-=”,外界不可以注销其他的注册者,外界不可以主动触发事件,因此如果用Delegate就没法进行上面的控制,因此诞生了事件这种语法。add、remove。

事件是用来阉割委托实例的。事件只能add、remove自己,不能赋值。事件只能+=、-=,不能=、不能外部触发事件。

posted @ 2012-07-03 14:01 木宛城主 阅读(...) 评论(...) 编辑 收藏
multifunction lasers
访问人数