深入理解.Net事件

前两天在与朋友聊天时提到了事件，故写下此文与他分享对事件的理解。因不敢独享所以拿出来请大家指正。

　　在进行WinForm编程时，事件这个概念无时无刻都围绕身边。点个按钮就是一个事件。在.Net中，事件这个概念总是让人觉得比较复杂，有着深奥的理论，而且其中的delegate关键字本身就让人觉得很深奥。

其实呢，事件并没有那么复杂而且深奥。只是MS为了让程序员写的代码少一点，鼓捣出个代理的概念。其实如果您对Java的界面编程有所了解之后，对.Net事件的理解就会顺利多了。当然，下面我们将先接触一段Java的代码。

在Java的GUI编程中，没有代理这个概念，它用的是接口。我们先来看一个带按钮的窗口：

 1import java.awt.event.ActionEvent;
 2import java.awt.event.ActionListener;
 3import java.awt.event.WindowAdapter;
 4import java.awt.event.WindowEvent;
 5import javax.swing.JButton;
 6import javax.swing.JFrame;
 7
 8public class EventStudy {
 9 public static void main(String[] args) {
      JFrame f = new JFrame();
      JButton b = new JButton();
      f.addWindowListener(new WindowAdapter(){
         @Override
         public void windowClosing(WindowEvent e) {
             System.exit(0);
         }
      });
      f.setSize(300, 200);
      b.setText("I'm a Button");
      b.addActionListener(new ActionListener(){
         @Override
         public void actionPerformed(ActionEvent e) {
             System.out.println("the Button is Clicked.");
         }
      });
      f.add(b);
      f.setVisible(true);
 }
}

 

现在，我们来看看上面的代码。这是一个包含了一个代码的窗体。其中，当单击了按钮之后，在控制台上会显示“the Button is Clicked.”那么Java是怎么做到这些事情的呢？我们先来看看下面这段代码：

b.addActionListener(new ActionListener(){
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("the Button is Clicked.");
    }
});

 

这段代码其含义就是向JButton对象注册一个事件监听器。在Java中，事件监听器就是一个接口。比如这个ActionListener接口，就包含一个actionPreformed方法。继承了这个接口的类就可以传入JButton对象的addActionListener方法中。一旦我们单击按钮之后，Swing的事件处理机制会调用actionPerformed方法，并把一个ActionEvent对象传入这个方法。

好了，让我们回到.Net。首先我们通过一个例子模拟一下按钮被单击的效果吧。当然，这个按钮并不是一个真正的按钮，不过是一个自己编写的类罢了。

 1using System;
 2using System.Collections.Generic;
 3using System.Linq;
 4using System.Text;
 5
 6namespace EventStudy
 7{
 8    interface ActionListener
 9    {
        void actionPreformed();
    }

    class MyButton
    {
        private ActionListener al = null;
        public MyButton() { }
        public string Text { get; set; }

        public void setActionListener(ActionListener al)
        {
            this.al = al;
        }

        public void ClickMe()
        {
            if(al != null)
                al.actionPreformed();
        }
    }

    class Program
    {
        class myActionListener : ActionListener
        {
            ActionListener Members#region ActionListener Members
            public void actionPreformed()
            {
                Console.WriteLine("Button Clicked!");
            }
            #endregion
        }

        static void Main(string[] args)
        {
            MyButton b = new MyButton();
            b.Text = "A Button.";
            b.setActionListener(new myActionListener());
            b.ClickMe();
        }
    }
}

 

首先呢，我们要有一个ActionListener接口，然后是MyButton类来模拟实际的按钮。MyButton类中的ClickMe方法就是模拟人工单击按钮这个过程。

最后，我们就在Main函数中设定好一切，然后“单击”这个按钮。

一般来说，当我们单击一个按钮之后，Windows会重绘按钮的图片，让它看起来像是被按下去一样，然后再去调用Click事件。在此我们省略重绘按钮图片的过程，直接让它触发事件。因此，ActionListener对象的actionPreformed方法就会被调用。

当然，上面用的是Java GUI对事件处理的设计模式。换到.Net中，我们可以把这个只包含一个方法的接口换成一个代理：

 1namespace EventStudy
 2{
 3    delegate void OnClick();
 4 
 5    class MyButton
 6    {
 7        private OnClick click = null;
 8        public MyButton() { }
 9        public string Text { get; set; }
 
        public void setOnClickEvent(OnClick oc)
        {
            this.click = oc;
        }
 
        public void ClickMe()
        {
            if (click != null)
                click();
        }
    }
 
    class Program
    {
        static void Main(string[] args)
        {
            MyButton b = new MyButton();
            b.Text = "A Button.";
            b.setOnClickEvent(delegate()
            {
                Console.WriteLine("Button Clicked!");
            });
            b.ClickMe();
        }
    }
}

 

现在，接口变成代理了，相应的一些代码也有所改动。其结果还是一样，不过代码确实可以少写点了。

对于事件处理，有一个多播的概念。那么多播是怎么回事呢？其实就是向一个事件注册多个监听者。如果不好理解就来看看下面的代码吧：

  

 1class MyButton
 2{
 3    private List<OnClick> clickEvents = new List<OnClick>();
 4    public MyButton() { }
 5    public string Text { get; set; }
 6
 7    public void addOnClickEvent(OnClick oc)
 8    {
 9        this.clickEvents.Add(oc);
    }

    public void ClickMe()
    {
        foreach (OnClick click in this.clickEvents)
            click();
    }
}

class Program
{
    static void Main(string[] args)
    {
        MyButton b = new MyButton();
        b.Text = "A Button.";
        b.addOnClickEvent(delegate()
        {
            Console.WriteLine("First Listener:Button Clicked!");
        });
        b.addOnClickEvent(delegate()
        {
            Console.WriteLine("Second Listener:Button Clicked!");
        });
        b.ClickMe();
    }
}

 

　　其实多播事件就是先用一个容器来保存所有注册的事件监听器（或者说处理函数），然后在触发事件时顺序地调用这些事件监听器。

当然，在.Net中有一个event关键字来让我们更轻松地完成这个任务：

 

 1class MyButton
 2{
 3    public event OnClick Click;
 4    public MyButton() { }
 5    public string Text { get; set; }
 6    
 7    public void ClickMe()
 8    {
 9        Click();
    }
}

class Program
{
    static void Main(string[] args)
    {
        MyButton b = new MyButton();
        b.Text = "A Button.";
        b.Click += delegate()
        {
            Console.WriteLine("First Listener:Button Clicked!");
         };
         b.Click += delegate()
         {
             Console.WriteLine("Second Listener:Button Clicked!");
          };
          b.ClickMe();
    }
}

现在，我们的MyButton已经非常接近实际.Net类库中的事件处理的设计方式了。目前的差距就是关于事件处理函数的参数。一般来说，WinForm的控件的事件处理函数都会包含两个参数：sender和e，一个是触发事件的对象sender和这个事件相关的参数。要让我们的MyButton更贴近真实，我们来看看如何加入这两个内容：

 1class MyClickEventArgs : EventArgs
 2{
 3    public string MyMessage { set; get; }
 4}
 5
 6delegate void OnClick(object sender, MyClickEventArgs e);
 7
 8class MyButton
 9{
    public event OnClick Click;
    public MyButton() { }
    public string Text { get; set; }

    public void ClickMe()
    {
        MyClickEventArgs e = new MyClickEventArgs();
        e.MyMessage = "This is a Message";
        Click(this, e);
    }
}

class Program
{
    static void Main(string[] args)
    {
        MyButton b = new MyButton();
        b.Text = "A Button.";
        b.Click += delegate(object sender, MyClickEventArgs e)
        {
            Console.WriteLine("Button Clicked!");
            Console.WriteLine("Message:{0}", e.MyMessage);
            Console.WriteLine("Button Text:{0}", ((MyButton)sender).Text);
        };
        b.ClickMe();
    }
}

 

首先，事件参数应该从EventArgs基类继承。当然，编写自己的事件参数类也不是不可以。至于sender，就是MyButton对象自己。至于EventArgs中到底有什么参数应该视情况而定。

最后，让我们来看看事件的先后顺序。比如按钮中的MouseDown，MouseUp，MouseClick这三个事件是顺序触发的。那么这个过程是如何来实现的呢。下面我们继续修改上面的代码，加入两个新的事件：BeforeClick和AfterClick。

 

 1delegate void ClickEventHanler(object sender, MyClickEventArgs e);
 2  
 3class MyButton
 4{
 5    public event ClickEventHanler BeforeClick;
 6    public event ClickEventHanler OnClick;
 7    public event ClickEventHanler AfterClick;
 8
 9    public MyButton() { }
 
    public string Text { get; set; }
 
    public void ClickMe()
    {
        MyClickEventArgs e;

        e = new MyClickEventArgs();
        e.MyMessage = "Before Click";
        BeforeClick(this, e);
 
        e = new MyClickEventArgs();
        e.MyMessage = "On Click";
        OnClick(this, e);
 
        e = new MyClickEventArgs();
        e.MyMessage = "After Click";
        AfterClick(this, e);
    }
}
 
class Program
{
    static void Main(string[] args)
    {
        MyButton b = new MyButton();
        b.Text = "A Button.";
        b.BeforeClick += new ClickEventHanler(Program.HandleEvent);
        b.OnClick += new ClickEventHanler(Program.HandleEvent);
        b.AfterClick += new ClickEventHanler(Program.HandleEvent);
        b.ClickMe();
    }
 
    public static void HandleEvent(object sender, MyClickEventArgs e)
    {
        Console.WriteLine("Button Text:{0}", ((MyButton)sender).Text);
        Console.WriteLine("Message:{0}", e.MyMessage);
    }
}

 

这次为了方便，我们把所有的事件处理代理都声明为ClickEventHandler。然后在MyButton类中声明3个事件：BeforeClick，OnClick，AfterClick。在Program类中，声明一个HandleEvent方法作为事件处理的一个公共方法。

在这个例子中，变动最大的是ClickMe方法，这个方法会按照顺序触发3个事件，这样我们就可以看到注册的3个事件按照先后顺序来触发了。

至于为什么每次触发事件都要重新new一个EventArgs，这考虑到多线程的问题。当然，在没有什么苛刻环境的情况下，改变EventArgs的属性然后再传入事件也是可以的。至于每次都会new一个新的对象，在语意上也是合理的。毕竟每个事件的参数都应该是独立的。

看完上面的这些例子之后，你会发现事件并没有想像中那么复杂，无非是一个函数的调用而已。而.Net之所以整出这么多新的概念其目的就是让我们编程的时候更加简洁。想想看，是Java的事件监听器写起来方便还是.Net的代理写起来方便呢？