看看这个常常被初级程序员弄不懂的 “事件”

2018-06-17 20:00:05来源:未知 阅读 ()

新老客户大回馈,云服务器低至5折

       众所周知在面试中,经常有些崽子面试官会问些“事件和委托”的关系,也许一路走来的程序员大多都会被问到这个,那么对于这个

高频的”事件和委托“问题,如何回击呢?首先我从最经典的一套面试题说起,用事件来实现 “猫爪老鼠“,这是一个从网上copy过来的一

个例子。

        static void Main(string[] args)
        {
            Mouse mouse = new Mouse();

            Cat cat = new Cat();

            cat.OnCry();

            Console.ReadLine();
        }
    }

    public delegate void CryEventHandler();

    public class Cat
    {
        public static event CryEventHandler Cry;

        public Cat()
        {
            Console.WriteLine("Cat:I'm coming.");
        }

        public virtual void OnCry()
        {
            Console.WriteLine("Cat:MiaoMiao");
            if (Cry != null)
            {
                Cry.Invoke();
            }
        }
    }

    public class Mouse
    {
        public Mouse()
        {
            Cat.Cry += new CryEventHandler(Run);
            Console.WriteLine("Mouse:I go to find something,and I must always listen cat's crying.");
        }

        public void Run()
        {
            Console.WriteLine("Mouse:A cat is coming,I must go back!");
        }
    }

 事件定义啥的什么玩意这个我就不说了,没什么意思,为了了解这个跟委托有什么关系,下面我们来看看这段代码最后生成的IL是什么样的。

 

1:CryEventHandler委托

1 public delegate void CryEventHandler();

    这个我想大家都清楚,委托本质上是一个继承于MulticastDelegate的类,同时会生成仅有的4个方法,看下IL即知。

 

2:Cat类

 1 public class Cat
 2     {
 3         public static event CryEventHandler Cry;
 4 
 5         public Cat()
 6         {
 7             Console.WriteLine("Cat:I'm coming.");
 8         }
 9 
10         public virtual void OnCry()
11         {
12             Console.WriteLine("Cat:MiaoMiao");
13             if (Cry != null)
14             {
15                 Cry.Invoke();
16             }
17         }
18     }

从这个类中,我们看到了一个Cry事件,然后就是一个Cry.Invoke(),不过当你看到Invoke的时候,你是不是很怀疑Cry是不是一个委托字段呢?

其实你怀疑的是一点问题都没有,32个赞,看下IL。

 

从上图中我们看到了两个好玩的东西:

① field Cry 字段,完整定义如下,然来所谓的“事件字段” 其实在IL下面蜕变成了委托字段,如果你觉得很奇怪,请看第二点。

.field private static class Sample.CryEventHandler Cry

② add_Cry,remove_Cry,如果仅仅将事件字段变成委托字段,那确实是编译器在发什么神经,然来编译器还给事件配备了两个方法,这个

    其实也就是事件里面+=,-=的奥秘所在,下面我们挑add_Cry方法说下,看看方法定义的IL代码是怎么样的。

 

很新奇,我们找到了Combine方法,这个我们都知道,原来事件中的+=,其实就是利用Combine来将当前的委托实例放到Delegate的

委托链表中(其实里面是array实现的),为了方便理解,我把上面的IL代码翻译成C#代码。

 

 1  public class Cat
 2     {
 3         /// <summary>
 4         /// 私有的委托变量
 5         /// </summary>
 6         private static CryEventHandler Cry;
 7 
 8         /// <summary>
 9         /// 事件生成的方法
10         /// </summary>
11         /// <param name="cryEventHandler"></param>
12         public void Add_Cry(CryEventHandler cryEventHandler)
13         {
14             var result = (CryEventHandler)Delegate.Combine(Cry, cryEventHandler);
15 
16             Interlocked.CompareExchange<CryEventHandler>(ref Cry, result, Cry);
17         }
18 
19         public void Remove_Cry(CryEventHandler cryEventHandler)
20         {
21             var result = (CryEventHandler)Delegate.Remove(Cry, cryEventHandler);
22 
23             Interlocked.CompareExchange<CryEventHandler>(ref Cry, result, Cry);
24         }
25 
26         public Cat()
27         {
28             Console.WriteLine("Cat:I'm coming.");
29         }
30 
31         public virtual void OnCry()
32         {
33             Console.WriteLine("Cat:MiaoMiao");
34 
35             if (Cry != null)
36             {
37                 //委托专用的四个方法,invoke,begininvoke,endinvoke,ctor
38                 Cry.Invoke();
39             }
40         }
41     }

可能有些同学对IL指令不是很熟悉,没关系,我也一样,咱博客园上面有位大神飞鸟的一篇IL指令集的博文或许能帮得到你。

 

3:Mouse类

    如果你对Cat类的IL代码琢磨的差不多的话,下面这个Mouse类就非常简单了,仅仅调用而已嘛。

 1     public class Mouse
 2     {
 3         public Mouse()
 4         {
 5             Cat.Cry += new CryEventHandler(Run);
 6             Console.WriteLine("Mouse:I go to find something,and I must always listen cat's crying.");
 7         }
 8 
 9         public void Run()
10         {
11             Console.WriteLine("Mouse:A cat is coming,I must go back!");
12         }
13     }

这个地方最让人关心的就是:Cat.Cry += new CryEventHandler(Run) 这个语句,从它的IL中可以看到其实做了三件事。

① ldftn:       将Run方法的非托管指针推送到计算堆栈上。

② newobj:   将CryEventHandler委托new一下,同时将计算堆栈上的Run方法的非托管指针作为构造函数的参数。

③ call:         调用Cat类的Add_Cry方法,将CryEventHandler的实例作为参数传递下去。

 

下面继续将该IL代码反编译回来,不过针对IL指令:call       void Sample.Cat::add_Cry(class Sample.CryEventHandler)

并没有很好的翻译过来,只能new Cat()了一下才能调用Add_Cry,从而触发了Cat的构造函数。

 1   public class Mouse
 2     {
 3         public Mouse()
 4         {
 5             var cryHandler = new CryEventHandler(Run);
 6 
 7             /*
 8              *  针对IL:call       void Sample.Cat::add_Cry(class Sample.CryEventHandler)
 9              *  这个没有反编译好,因为我new Cat()将会再次调用构造函数。
10              */
11             new Cat().Add_Cry(cryHandler);
12 
13             Console.WriteLine("Mouse:I go to find something,and I must always listen cat's crying.");
14         }
15 
16         public void Run()
17         {
18             Console.WriteLine("Mouse:A cat is coming,I must go back!");
19         }
20     }

 

好了,说了这么多,应该也有总结性的东西出来了,原来事件是完完全全的建立在委托的基础上,你可以认为事件就是用委托来玩一个

观察者模式的,你甚至可以认为事件就是委托。没有本质区别。

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:一步一步学c#(四):继承

下一篇:绝对好文:.NET程序性能的基本要领