C#三步实现标准事件处理程序

 

事件，MSDN解释： 类或对象可以通过事件向其他类或对象通知发生的相关事情。发送（或引发）事件的类称为“发行者”，接收（或处理）事件的类称为“订户”。

有关事件的理论与好处，在这里就不再废话了，感兴趣的可以参考MSDN的讲解。这里就通过有一个demo演示一下如何一步步实现标准的事件处理过程。可以做为以后代码中的事件编写参考。要运用事件，需要了解委托与事件，可以去学习相关教程。

模拟有一个恐怖的军火提供商要我们实现一个火箭炮的订单管理程序。效果图：

第一步：基本实践

从MSDN上看了事件的讲解，我们可能想实践一下，来编写一个简单的事件处理，无参数，也不怎么规范，但已经达到的实现事件的功能。

代码

1 public class BookBomb
2 {
3 /// <summary>
4 /// 定义委托
5 /// </summary>
6   public delegate void BookBombs();
7 /// <summary>
8 /// 定义事件
9 /// </summary>
10   public event BookBombs Book;
11 public event BookBombs Booking;
12 public event BookBombs Booked;
13
14 /// <summary>
15 /// 预定
16 /// </summary>
17   public void OnBook()
18 {
19 if (Book != null )
20 {
21 Book();
22 }
23 }
24 /// <summary>
25 /// 正在处理
26 /// </summary>
27   public void OnBooking()
28 {
29 if (Booking != null )
30 {
31 Booking();
32 }
33 }
34 /// <summary>
35 /// 装配完毕
36 /// </summary>
37   public void OnBooked()
38 {
39 if (Booked != null )
40 {
41 Booked();
42 }
43 }
44 }
45 }

这是一个很基本也不规范的事件示例，实现了火箭炮的订单预定，装配处理，装配完毕三个环节。

注册事件很简单 事件名后输入+=后会提示按Tab键自动导入每个事件相关的处理程序。

下面看看客户程序的注册与调用。

代码

1 // 声明
2   BookBomb _bookBomb = null ;
3 _bookBomb = new BookBomb();
4 // 分别注册三个事件
5   _bookBomb.Book += new BookBomb.BookBombs(_bookBomb_Book);
6 _bookBomb.Booking += new BookBomb.BookBombs(_bookBomb_Booking);
7 _bookBomb.Booked += new BookBomb.BookBombs(_bookBomb_Booked);
8   void _bookBomb_Booked()
9 {
10 txtMsg.AppendText( " 装配完毕 型号：NB-250 数量：10 \r\n\r\n " );
11 }
12
13 void _bookBomb_Booking()
14 {
15 txtMsg.AppendText( " 正在装配 型号：NB-250 数量：10 \r\n " );
16 }
17
18 void _bookBomb_Book()
19 {
20 txtMsg.AppendText( " 预定炸弹 型号：NB-250 数量：10 \r\n " );
21 }
22   // 模拟订单处理流程的有三次调用
23   _bookBomb.OnBook();
24 _bookBomb.OnBooking();
25 _bookBomb.OnBooked();

简单的实现就完成了。事件处理的结果是在消息框内输出相关订单的简要信息。

第二步：带参数事件处理

在第一步实践中，事件处理的时候并没有传入参数，而我们实际程序中会提供参数做相应处理，并且会根据业务的不同执行不同事件处理。并且上一实践中的命名也不太规范，似乎跟我们在 IDE中看到的按钮等其他处理程序不太一样。这一实践，我们进行改革完善。

给事件提供参数，要求我们的参数要符合 .net 规范里的参数定义。我们继承 .net 的参数类 EventArgs 来自定义我们自己的参数类型:

 

代码

1 /// <summary>
2 /// 事件参数
3 /// </summary>
4   public class SimpleBookEventArgs : EventArgs
5 {
6 private int _count = 0 ;
7 public int Count
8 {
9 get { return _count; }
10 set { _count = value; }
11 }
12
13 private string _model;
14 public string Name
15 {
16 get { return _model; }
17 set { _model = value; }
18 }
19 }
20
21 public class SimpleBookBomb
22 {
23 public delegate void SimpleBookEventHandler(SimpleBookEventArgs e);
24 public event SimpleBookEventHandler SimpleBookEvent;
25 public event SimpleBookEventHandler SimpleBookingEvent;
26 public event SimpleBookEventHandler SimpleBookedEvent;
27 /// <summary>
28 /// 预定
29 /// </summary>
30 /// <param name="e"></param>
31 public void OnSimpleBook(SimpleBookEventArgs e)
32 {
33 if (SimpleBookEvent != null )
34 {
35 this .SimpleBookEvent(e);
36 }
37 }
38 /// <summary>
39 /// 正在处理
40 /// </summary>
41 public void OnSimpleBooking(SimpleBookEventArgs e)
42 {
43 if (SimpleBookingEvent != null )
44 {
45 this .SimpleBookingEvent(e);
46 }
47 }
48 /// <summary>
49 /// 装配完毕
50 /// </summary>
51 public void OnSimpleBooked(SimpleBookEventArgs e)
52 {
53 if (SimpleBookedEvent != null )
54 {
55 this .SimpleBookedEvent(e);
56 }
57 }
58 }

 

第三步：标准的事件实现

通过以上两个实践，细心的你会发现怎么看上去跟系统的那些事件“样式”还不太一样呢，如果按钮事件的参数是两个，还有类似sender，例如：

private void btnStandard_Click(object sender, EventArgs e)

加上去就行了，对于系统的类事件，Sender参数只是简单地传递了指向引发事件的那个类的实例的一个引用，e依然是事件处理的参数。

看一个相对标准的示例：

参数定义：

代码

1 /// <summary>
2 /// 事件参数
3 /// </summary>
4 public class StandardBookEventArgs : EventArgs
5 {
6 private int _count = 0 ;
7 public int Count
8 {
9 get { return _count; }
10 set { _count = value; }
11 }
12
13 private string _name;
14 public string Name
15 {
16 get { return _name; }
17 set { _name = value; }
18 }
19 }
20
21 public class StandardBookBomb
22 {
23 public delegate void StandardBookEventHandler( object sender, StandardBookEventArgs e);
24 public event StandardBookEventHandler StandardBookEvent;
25 public event StandardBookEventHandler StandardBookingEvent;
26 public event StandardBookEventHandler StandardBookedEvent;
27 /// <summary>
28 /// 预定
29 /// </summary>
30 public void OnStandardBook( object sender, StandardBookEventArgs e)
31 {
32 if (StandardBookEvent != null )
33 {
34 this .StandardBookEvent(sender, e);
35 }
36 }
37 /// <summary>
38 /// 正在处理
39 /// </summary>
40 public void OnStandardBooking( object sender, StandardBookEventArgs e)
41 {
42 if (StandardBookingEvent != null )
43 {
44 this .StandardBookingEvent(sender, e);
45 }
46 }
47 /// <summary>
48 /// 装配完毕
49 /// </summary>
50 public void OnStandardBooked( object sender, StandardBookEventArgs e)
51 {
52 if (StandardBookedEvent != null )
53 {
54 this .StandardBookedEvent(sender, e);
55 }
56 }
57 }

 

总结：通过一步步进化，在第三个实践中已经是一个相对“标准”的事件处理过程了。

命名规范：

参数后缀EventArgs，例如 ：StandardBookEventArgs

委托后缀EventHandler，例如：StandardBookEventHandler

事件后缀Event，例如：StandardBookEvent

处理方法前缀On，例如：OnStandardBook()

大致步骤：

1，      定义参数

2，      定义委托

3，      定义事件

4，      注册事件

5，      实现事件处理程序

6，      触发事件

这个可以作为以后写类似代码的参考。

点击下载源码

转载于:https://www.cnblogs.com/wwwzzg168/p/3569997.html