C#委托,事件理解入门 (译稿)

天海一线

目录

l        导论

l        什么是委托

l        事件的理解

l        事件 关键字

l        最后

 

导论

    在学习C#中的委托和事件过程中，我读了许多文章来理解他们二者究竟是怎么一回事，以及如何使用他们，现在我将整个的理解过程陈述以下，我学到的每一方面，恐怕也是你们需要掌握的 ：-）。

什么是委托？

    委托和事件这两个概念是完全配合的。委托仅仅是函数指针，那就是说，它能够引用函数，通过传递地址的机制完成。委托是一个类，当你对它实例化时，要提供一个引用函数，将其作为它构造函数的参数。

  每一个委托都有自己的签名，例如：Delegate int SomeDelegate(string s, bool b);是一个委托申明，在这里，提及的签名，就是说SomeDelegate 这个委托 有 string 和 bool 类型的形参，返回一个int 类型。

上面提及的：当你对委托实例化时，要提供一个引用函数，将其作为它构造函数的参数。这里要注意了：被引用的这个函数必须和委托有相同的签名。

看下面的函数：

private int SomeFunction(string str, bool bln){...}

你可以把这个函数传给SomeDelegate的构造函数，因为他们有相似的签名（in other words，他们都有相同的形参类型和个数，并且返回相同的数据类型）。

    SomeDelegate sd = new SomeDelegate(SomeFunction);

  sd 引用了 SomeFunction，也就是说，SomeFunction已被sd所登记注册，如果你调用 sd，SomeFunction 这个函数也会被调用，记住：我所说 SomeFunction的含义，后面，我们会用到它。

  现在，你应该知道如何使用委托了，让我们继续理解事件之旅……

事件的理解

 我们知道，在C#中：

l        按钮（Button）就是一个类，当我们单击它时，就触发一次click事件。

l        时钟（Timer）也是一个类，每过一毫秒，就触发一次tick事件。

让我们通过一个例子来学习，假定有这样的情节：

  现在有一个Counter的类，它有一个方法 CountTo(int countTo, int reachableNum)，该方法表示：在指定的时间段内（0~~countTo），当到达指定的时间点reachableNum时，就触发一次NumberReached事件。

它还有一个事件：NumberReached，事件是委托类型的变量。意思是：如果给事件命名，用event关键字和要使用的委托类型申明它即可，如下所示：

public event NumberReachedEventHandler NumberReached;

 

在上面的申明中，NumberReachedEventHandle 仅是一个委托，更确切的表示应该是：NumberReachedDelegate。但是微软从不这样认为MouseDelegate或者PaintDelegate，，而是称谓：MouseEventHandler 或者 PaintEventHandler。所以

NumberReachedEventHandler 比NumberReachedDelegate听起来更方便一些，OK?好了，让我们继续，现在你知道了，在我们声明事件之前，需要象下面这样的形式来定义委托：

public delegate void NumberReachedEventHandler(object sender, NumberReachedEventArgs e);

现在声明的委托 NumberReachedEventHandle，它有一个void 返回值，和object，NumberReachedEventArgs两个形参。就像我们在第一节中强调的那样，当实例化委托时，作为实参传入的函数也必须拥有和委托同样的签名。

 在你的代码中， 你是否用过PaintEventArgs 或者 MouseEventArgs来确定鼠标的移动位置？是否在触发Paint事件的对象中用过Graphics 属性？实际上，为用户提供数据的类都是继承于System.EventArgs类，就是我们常说的事件参数类，如果事件不提供参数，就不定义该类。在我们的例子中，我们通过下面的类提供预期的时间点。

public class NumberReachedEventArgs : EventArgs

{

    private int _reached;

    public NumberReachedEventArgs(int num)

    {

        this._reached = num;

    }

    public int ReachedNumber

    {

        get

        {

            return _reached;

        }

    }

}

好，有了前面的介绍，让我们到Counter类里面看看：

namespace Events

{

    public delegate void NumberReachedEventHandler(object sender,

        NumberReachedEventArgs e);

 

    /// <summary>

    /// Summary description for Counter.

    /// </summary>

    public class Counter

    {

        public event NumberReachedEventHandler NumberReached;

       

        public Counter()

        {

            //

            // TODO: Add constructor logic here

            //

        }

        public void CountTo(int countTo, int reachableNum)

        {

            if(countTo < reachableNum)

                throw new ArgumentException(

                    "reachableNum should be less than countTo");

            for(int ctr=0;ctr<=countTo;ctr++)

            {

                if(ctr == reachableNum)

                {

                    NumberReachedEventArgs e = new NumberReachedEventArgs(

                        reachableNum);

                    OnNumberReached(e);

                    return;//don't count any more

                }

            }

        }

 

        protected virtual void OnNumberReached(NumberReachedEventArgs e)

        {

            if(NumberReached != null)

            {

                NumberReached(this, e);//Raise the event

            }

        }

}

在Counter中，如果到达指定的时间点，就触发一次事件，有以下几个方面需要注意：

l        通过调用NumberReached（它是NumberReachedEventHandler委托的实例）来完成一次触发事件。

NumberReached(this, e);  通过这种方式，可以调用所有的注册函数。

l        通过 NumberReachedEventArgs e = new NumberReachedEventArgs(reachableNum); 为所有的注册函数提供事件数据。

l        看了上面的代码，你可能要问了：为什么我们直接用 OnNumberReached(NumberReachedEventArgs e)方法来调用NumberReached（this，e），而不用下面的代码呢？

    if(ctr == reachableNum)

{

    NumberReachedEventArgs e = new NumberReachedEventArgs(reachableNum);

    //OnNumberReached(e);

    if(NumberReached != null)

    {

        NumberReached(this, e);//Raise the event

    }

    return;//don't count any more

}

这个问题问得很好，那就让我们再看一下OnNumberReached 签名：

protected virtual void OnNumberReached(NumberReachedEventArgs e)

①你也明白 关键字protected限定了 只有从该类继承的类才能调用该类中的所有方法。

②关键字 virtual 表明了 在继承类中可以重写该方法。

这两点非常有用，假设你在写一个从Counter继承而来的类，通过重写OnNumberReached 方法，你可以在事件触发之前，进行一次其他的工作。

 

protected override void OnNumberReached(NumberReachedEventArgs e)

{

    //Do additional work

    base.OnNumberReached(e);

}

注意：如果你没有调用base.OnNumberReached(e), 那么从不会触发这个事件！在你继承该类而想剔出它的一些其他事件时，使用该方式是非常有用的。

l        还要注意到：委托 NumberReachedEventHandler 是在类定义的外部，命名空间内定义的，对所有类来说是可见的。

好，该我们来实际操作使用Counter类了。

 

在我们简单的应用程序中，我们有两个文本框，分别是：txtCountTo和txtReachable：

 下面是btnRun的click事件：

private void btnRun_Click(object sender, System.EventArgs e)

       {

           if(txtCountTo.Text == "" || txtReachable.Text=="")

              return;

           oCounter.CountTo(Convert.ToInt32(txtCountTo.Text), Convert.ToInt32(txtReachable.Text));

       }

 

private void oCounter_NumberReached(object sender, NumberReachedEventArgs e)

       {

           MessageBox.Show("Reached: " + e.ReachedNumber.ToString());

   }

 

初始化事件处理的语法如下：

oCounter = new Counter();

          oCounter.NumberReached += new NumberReachedEventHandler(oCounter_NumberReached);

         

现在你明白了你刚才所做的一切，仅仅初始化 NumberReachedEventHandler 委托类型的对象（就像你实例化其他对象一样），注意到 oCounter_NumberReached 方法的签名与我前面提到的相似。

还要注意我们用的是+= 而不是=；这是因为委托是特殊的对象，它可以引用多个对象（在这里是指它可以引用多个函数）。For example 如果有另外一个

和oCounter_NumberReached一样具有相同签名的函数oCounter_NumberReached2，这两个函数都可以被引用：

 

oCounter = new Counter();

           oCounter.NumberReached += new NumberReachedEventHandler(oCounter_NumberReached);

           oCounter.NumberReached += new NumberReachedEventHandler(oCounter_NumberReached2);

现在，触发一个事件后，上面两个函数被依次调用。

 

视情况而定，如果你想让oCounter_NumberReached2在NumberReached事件发生后不再被调用，可以简单地这样写：oCounter.NumberReached -= new NumberReachedEventHandler(oCounter_NumberReached2);

 

最后

  让我们看一下完整的源代码,以供参考：

Form1.cs

 

1. using System;
   
2. using System.Drawing;
   
3. using System.Collections;
   
4. using System.ComponentModel;
   
5. using System.Windows.Forms;
   
6. using System.Data;
   
7. 
   
8. namespace Events
   
9. {
   
10.     /**//// <summary>
    
11. 
    
12.     /// Summary description for Form1.
    
13. 
    
14.     /// </summary>
    
15. 
    
16.     public class Form1 : System.Windows.Forms.Form
    
17.     {
    
18.         Counter oCounter = null;
    
19. 
    
20.         private System.Windows.Forms.Button cmdRun;
    
21.         private System.Windows.Forms.TextBox txtReachable;
    
22.         private System.Windows.Forms.TextBox txtCountTo;
    
23.         private System.Windows.Forms.Label label1;
    
24.         private System.Windows.Forms.Label label2;
    
25.         private System.Windows.Forms.Button btnRemoveDelegate;
    
26.         /**//// <summary>
    
27. 
    
28.         /// Required designer variable.
    
29. 
    
30.         /// </summary>
    
31. 
    
32.         private System.ComponentModel.Container components = null;
    
33. 
    
34.         public Form1()
    
35.         {
    
36.             //
    
37. 
    
38.             // Required for Windows Form Designer support
    
39. 
    
40.             //
    
41. 
    
42.             InitializeComponent();
    
43. 
    
44.             //
    
45. 
    
46.             // TODO: Add any constructor code after InitializeComponent call
    
47. 
    
48.             //
    
49. 
    
50.             oCounter = new Counter();
    
51.             oCounter.NumberReached += new NumberReachedEventHandler(oCounter_NumberReached);
    
52.             oCounter.NumberReached += new NumberReachedEventHandler(oCounter_NumberReached2);
    
53.         }
    
54. 
    
55.         /**//// <summary>
    
56. 
    
57.         /// Clean up any resources being used.
    
58. 
    
59.         /// </summary>
    
60. 
    
61.         protected override void Dispose( bool disposing )
    
62.         {
    
63.             if( disposing )
    
64.             {
    
65.                 if (components != null)
    
66.                 {
    
67.                     components.Dispose();
    
68.                 }
    
69.             }
    
70.             base.Dispose( disposing );
    
71.         }
    
72. 
    
73.         Windows Form Designer generated code#region Windows Form Designer generated code
    
74.         /**//// <summary>
    
75. 
    
76.         /// Required method for Designer support - do not modify
    
77. 
    
78.         /// the contents of this method with the code editor.
    
79. 
    
80.         /// </summary>
    
81. 
    
82.         private void InitializeComponent()
    
83.         {
    
84.             this.cmdRun = new System.Windows.Forms.Button();
    
85.             this.txtReachable = new System.Windows.Forms.TextBox();
    
86.             this.txtCountTo = new System.Windows.Forms.TextBox();
    
87.             this.label1 = new System.Windows.Forms.Label();
    
88.             this.label2 = new System.Windows.Forms.Label();
    
89.             this.btnRemoveDelegate = new System.Windows.Forms.Button();
    
90.             this.SuspendLayout();
    
91.             //
    
92. 
    
93.             // cmdRun
    
94. 
    
95.             //
    
96. 
    
97.             this.cmdRun.Location = new System.Drawing.Point(16, 72);
    
98.             this.cmdRun.Name = "cmdRun";
    
99.             this.cmdRun.Size = new System.Drawing.Size(48, 23);
    
100.             this.cmdRun.TabIndex = 2;
     
101.             this.cmdRun.Text = "Run";
     
102.             this.cmdRun.Click += new System.EventHandler(this.cmdRun_Click);
     
103.             //
     
104. 
     
105.             // txtReachable
     
106. 
     
107.             //
     
108. 
     
109.             this.txtReachable.Location = new System.Drawing.Point(144, 40);
     
110.             this.txtReachable.Name = "txtReachable";
     
111.             this.txtReachable.Size = new System.Drawing.Size(56, 20);
     
112.             this.txtReachable.TabIndex = 1;
     
113.             this.txtReachable.Text = "";
     
114.             //
     
115. 
     
116.             // txtCountTo
     
117. 
     
118.             //
     
119. 
     
120.             this.txtCountTo.Location = new System.Drawing.Point(144, 16);
     
121.             this.txtCountTo.Name = "txtCountTo";
     
122.             this.txtCountTo.Size = new System.Drawing.Size(56, 20);
     
123.             this.txtCountTo.TabIndex = 0;
     
124.             this.txtCountTo.Text = "";
     
125.             //
     
126. 
     
127.             // label1
     
128. 
     
129.             //
     
130. 
     
131.             this.label1.AutoSize = true;
     
132.             this.label1.Location = new System.Drawing.Point(16, 16);
     
133.             this.label1.Name = "label1";
     
134.             this.label1.Size = new System.Drawing.Size(51, 13);
     
135.             this.label1.TabIndex = 3;
     
136.             this.label1.Text = "Count To";
     
137.             //
     
138. 
     
139.             // label2
     
140. 
     
141.             //
     
142. 
     
143.             this.label2.AutoSize = true;
     
144.             this.label2.Location = new System.Drawing.Point(16, 40);
     
145.             this.label2.Name = "label2";
     
146.             this.label2.Size = new System.Drawing.Size(99, 13);
     
147.             this.label2.TabIndex = 4;
     
148.             this.label2.Text = "Reach this number";
     
149.             //
     
150. 
     
151.             // btnRemoveDelegate
     
152. 
     
153.             //
     
154. 
     
155.             this.btnRemoveDelegate.Location = new System.Drawing.Point(16, 104);
     
156.             this.btnRemoveDelegate.Name = "btnRemoveDelegate";
     
157.             this.btnRemoveDelegate.Size = new System.Drawing.Size(168, 23);
     
158.             this.btnRemoveDelegate.TabIndex = 5;
     
159.             this.btnRemoveDelegate.Text = "Remove second handler";
     
160.             this.btnRemoveDelegate.Click += new System.EventHandler(this.btnRemoveDelegate_Click);
     
161.             //
     
162. 
     
163.             // Form1
     
164. 
     
165.             //
     
166. 
     
167.             this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
     
168.             this.ClientSize = new System.Drawing.Size(224, 134);
     
169.             this.Controls.AddRange(new System.Windows.Forms.Control[] {
     
170.                                                                           this.btnRemoveDelegate,
     
171.                                                                           this.label2,
     
172.                                                                           this.label1,
     
173.                                                                           this.txtCountTo,
     
174.                                                                           this.txtReachable,
     
175.                                                                           this.cmdRun});
     
176.             this.Name = "Form1";
     
177.             this.Text = "Events";
     
178.             this.ResumeLayout(false);
     
179. 
     
180.         }
     
181.         #endregion
     
182. 
     
183.         /**//// <summary>
     
184. 
     
185.         /// The main entry point for the application.
     
186. 
     
187.         /// </summary>
     
188. 
     
189.         [STAThread]
     
190.         static void Main()
     
191.         {
     
192.             Application.Run(new Form1());
     
193.         }
     
194. 
     
195.         private void btnRun_Click(object sender, System.EventArgs e)
     
196.         {
     
197.             if(txtCountTo.Text == "" || txtReachable.Text=="")
     
198.                 return;
     
199.             oCounter.CountTo(Convert.ToInt32(txtCountTo.Text), Convert.ToInt32(txtReachable.Text));
     
200.         }
     
201. 
     
202.         private void oCounter_NumberReached(object sender, NumberReachedEventArgs e)
     
203.         {
     
204.             MessageBox.Show("Reached: " + e.ReachedNumber.ToString());
     
205.         }
     
206.         private void oCounter_NumberReached2(object sender, NumberReachedEventArgs e)
     
207.         {
     
208.             MessageBox.Show("Reached2: " + e.ReachedNumber.ToString());
     
209.         }
     
210. 
     
211.         private void btnRemoveDelegate_Click(object sender, System.EventArgs e)
     
212.         {
     
213.             oCounter.NumberReached -= new NumberReachedEventHandler(oCounter_NumberReached2);
     
214.             oCounter.CountTo(Convert.ToInt32(txtCountTo.Text), Convert.ToInt32(txtReachable.Text));
     
215.         }
     
216.     }
     
217. }

 

Counter.cs

1. using System;
   
2. 
   
3. namespace Events
   
4. {
   
5.     public delegate void NumberReachedEventHandler(object sender, NumberReachedEventArgs e);
   
6. 
   
7.     /**//// <summary>
   
8. 
   
9.     /// Summary description for Counter.
   
10. 
    
11.     /// </summary>
    
12. 
    
13.     public class Counter
    
14.     {
    
15.         public event NumberReachedEventHandler NumberReached;
    
16.          
    
17.         public Counter()
    
18.         {
    
19.             //
    
20. 
    
21.             // TODO: Add constructor logic here
    
22. 
    
23.             //
    
24. 
    
25.         }
    
26.         public void CountTo(int countTo, int reachableNum)
    
27.         {
    
28.             if(countTo < reachableNum)
    
29.                 throw new ArgumentException("reachableNum should be less than countTo");
    
30.             for(int ctr=0;ctr<=countTo;ctr++)
    
31.             {
    
32.                 if(ctr == reachableNum)
    
33.                 {
    
34.                     NumberReachedEventArgs e = new NumberReachedEventArgs(reachableNum);
    
35.                     OnNumberReached(e);
    
36.                     return;//don't count any more
    
37. 
    
38.                 }
    
39.             }
    
40.         }
    
41. 
    
42.         protected virtual void OnNumberReached(NumberReachedEventArgs e)
    
43.         {
    
44.             if(NumberReached!=null)
    
45.             {
    
46.                 NumberReached(this, e);
    
47.             }
    
48.         }
    
49.     }
    
50. 
    
51.     public class NumberReachedEventArgs : EventArgs
    
52.     {
    
53.         private int _reached;
    
54.         public NumberReachedEventArgs(int num)
    
55.         {
    
56.             this._reached = num;
    
57.         }
    
58.         public int ReachedNumber
    
59.         {
    
60.             get
    
61.             {
    
62.                 return _reached;
    
63.             }
    
64.         }
    
65.     }
    
66. }