窗体和消息处理

「爱情、让人受尽委屈。」 2022-07-14 23:45 153阅读 0赞

[点击打开链接][Link 1]

**0 概述**

Windows的界面顾名思义，由“窗体”来组成，窗体的概念：屏幕上特定的一块区域，具有绘图区域和剪裁边界，并具备响应用户输入设备操作能力。

*  **绘图区域**：每一个窗体都定义了一块区域，在这块区域里，可以进行绘图，绘制的图形将显示在窗体中。随着窗体位置的移动，绘图区域也在不断移动；
 *  **剪裁边界**：绘图区域的四周，由剪裁边界包围，剪裁边界保证了绘图区域确定的大小，超出部分会被剪裁掉，不被显示；
 *  **事件响应**：主要响应鼠标和键盘事件，当鼠标在窗体上发生点击，则一组鼠标事件会从操作系统反映给该窗体；当按下键盘时，一组键盘事件会从操作系统反映给“**输入焦点**”所在的窗体。

Windows的图形系统由如下几个部分组成：

*  **顶级窗体**：Desktop或称为桌面，是Windows操作系统的最主要的窗体，其它窗体都是在其基础上建立的；
 *  **窗体**：是由应用程序建立的窗体；
 *  **子窗体：**是依附于主窗体或弹出窗体之上的窗体，俗称的“**控件**”就是子窗体的一种。

所以所谓的图形编程，就是为各种各样的窗体编程。

**1 窗体和消息循环**

**　　**先来看一段主窗体的代码，由于Visual Studio会自动为Windows应用程序项目建立主窗体，所以这里我们采用将控制台应用程序项目改造为Windows应用程序项目的方法来体现建立窗体的过程。

第一步：建立一个普通的“控制台应用程序”项目：

第二步：为项目添加支持窗体编程的程序集引用：

1、选择“项目 –> 添加引用”打开“添加引用对话框”，选中“.NET选项卡”（如下图）：

图1 添加引用

2、按住Ctrl键，同时选中其中的“**System.Drawing**”和“**System.Windows.Forms**”两项，点击确定，完成这两个程序集引用的添加，其中：

*  **System.Drawing **命名空间包括了.net Framework图形绘制相关类；
 *  **System.Windows.Forms **命名空间包括了.net Framework窗体相关类。

第三步：将项目输出类型改为“**Windows**应用程序”

选择“项目 –> 属性”，打开项目属窗口，选择“应用程序”选项卡，将其中输出类型改为“Windows应用程序”

图2 更改项目输出类型

至此，我们的项目就可以支持图形用户界面的开发了。现在在Program.cs中输入如下代码：

**\[csharp\]**  [view plain][]   [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **using** System;  
2.  **using** System.Windows.Forms;  
3.    
4.  **namespace** Edu.Study.Graphic.Win \{  
5.    
6.      **class** Program \{  
7.          **static** **void** Main(**string**\[\] args) \{  
8.          // 实例化一个Form类的对象  
9.              Form form = **new** Form();  
10.   
11.             // 设置Text属性, 字符串  
12.             form.Text = "第一个窗体";  
13.   
14.             // 设置Width, Height属性, 宽度高度  
15.             form.Width = 800;  
16.             form.Height = 600;  
17.   
18.             // 启动消息循环  
19.             Application.Run(form);  
20.         \}  
21.     \}  
22. \}

运行代码的结果是显示一个如下的窗体：

![0_1271349998ElMm.gif][]   
图3 窗体显示效果图

好了，目前我们就拥有了一个空白的窗体，这个窗体就是我们整个应用程序的“主窗体”，它具有“标题栏”，“最大化、最小化和关闭按钮”以及“系统图标和系统菜单”，是一个标准的Windows窗体。

从代码可以看到，创建一个窗体非常简单，生成一个Form类的对象即可。Form类对象的引用传入一个Application类的静态Run方法作为参数，窗口就可以显示出来了。

Form类具有一些属性，可以设置窗口的标题、大小和位置等。

这里面我们注意一点：我们在Main方法中创建了主窗体的对象，随机将这个对象的引用作为参数传递给了Application类的静态方法Run方法中。这个Run方法实际上启动了一段称为**消息循环**的代码，即一个while循环，这个循环首先保证了Main方法不会直接运行完毕退出（所以那个Form类的对象也不会被销毁，那么消息循环还干什么事儿呢？

在一个窗体应用程序中，具备一个队列结构称为“**消息队列**”，队列里面存放者发送给这个窗体的消息，例如当我们操作窗体时（操作鼠标或者按下键盘），这些操作就会形成“消息”，存入到消息队列中。

在Main方法中，Application.Run内部启动了一个循环，循环从消息队列里面一条一条的读取消息。如果没有消息，则这个循环就会被阻塞，直到有消息到来。读取到的消息，根据消息类型不同，交给窗体类中对应的方法去处理。直到消息队列中一条“关闭窗体”的消息被获取到后结束循环。

所以一旦运行了Application.Run方法，除非该方法参数指定的窗口被关闭，否则Main方法一直都不会运行结束，而是在一个循环中不断重复读取消息的工作。

![0_12713499999zmC.gif][]

图4 消息队列、消息循环示意图

**2 继承窗体，完成消息处理**

继续扩充上述代码

**\[csharp\]**  [view plain][]   [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **using** System;  
2.  **using** System.Drawing;  
3.  **using** System.Windows.Forms;  
4.    
5.  **namespace** Edu.Study.Graphics.ExtendsForm \{  
6.    
7.      /// <summary>  
8.      /// 继承Form类  
9.      /// </summary>  
10.     **class** MyForm : Form \{  
11.   
12.         /// <summary>  
13.         /// 保存键盘按键消息的按键值  
14.         /// </summary>  
15.         **private** Keys key = Keys.NoName;  
16.   
17.         /// <summary>  
18.         /// 保存鼠标单击消息的坐标值  
19.         /// </summary>  
20.         **private** Point point = Point.Empty;  
21.              
22.         /// <summary>  
23.         /// 构造器  
24.         /// </summary>  
25.         **public** MyForm() \{  
26.             **this**.Width = 800;  
27.             **this**.Height = 600;  
28.             **this**.Text = "继承窗体类";  
29.   
30.             // 开启双缓冲绘图模式  
31.             **this**.DoubleBuffered = **true**;  
32.         \}  
33.       
34.         /// <summary>  
35.         /// 鼠标单击消息处理方法  
36.         /// </summary>  
37.         **protected** **override** **void** OnMouseDown(MouseEventArgs e) \{  
38.             **base**.OnMouseDown(e);  
39.   
40.             // 将单击时的坐标保存  
41.             **this**.point = **new** Point(e.X, e.Y);  
42.             // 刷新窗口, 发出窗口重绘消息  
43.             Refresh();  
44.         \}  
45.       
46.         /// <summary>  
47.         /// 键盘按下消息处理方法  
48.         /// </summary>  
49.         **protected** **override** **void** OnKeyDown(KeyEventArgs e) \{  
50.             **base**.OnKeyDown(e);  
51.       
52.             // 将键盘按键值保存  
53.             **this**.key = e.KeyCode;  
54.             **this**.Refresh();  
55.         \}  
56.       
57.         /// <summary>  
58.         /// 重绘窗口消息处理方法  
59.         /// </summary>  
60.         **protected** **override** **void** OnPaint(PaintEventArgs e) \{  
61.             **base**.OnPaint(e);  
62.       
63.             // 实例化字体对象  
64.             // 使用窗体默认字体, 字号30  
65.             Font font = **new** Font(**this**.Font.FontFamily, 30F);  
66.       
67.             // 将鼠标坐标绘制在界面上  
68.             e.Graphics.DrawString(  
69.                 String.Format("\{0\} : \{1\}", **this**.point.X, **this**.point.Y),     // 要绘制的字符串  
70.                 font,   // 绘制使用的字体  
71.                 **new** SolidBrush(Color.Red),  // 绘制使用的画刷  
72.                 10, 5   // 绘制到屏幕的坐标  
73.             );  
74.       
75.             // 将键盘按键值转换为字符串  
76.             **string** showText = **this**.key.ToString();  
77.       
78.             // 实例化字体对象  
79.             font = **new** Font(**this**.Font.FontFamily, 50F);  
80.       
81.             // 测量字符串大小(高度、宽度)  
82.             SizeF size = e.Graphics.MeasureString(showText, font);  
83.       
84.             // 获取屏幕中央点  
85.             PointF point = **new** PointF((**float**)**this**.Width / 2F, (**float**)**this**.Height / 2F);  
86.       
87.             // 计算字符串绘制起始位置  
88.             point.X -= size.Width / 2;  
89.             point.Y -= size.Height / 2;  
90.       
91.             // 绘制字符串  
92.             e.Graphics.DrawString(showText, font, **new** SolidBrush(Color.Green), point);  
93.         \}  
94.     \}  
95.          
96.     **static** **class** Program \{  
97.         **static** **void** Main(**string**\[\] args) \{  
98.             Application.Run(**new** MyForm());  
99.         \}  
100.     \}  
101. \}

执行结果如下图：

![0_1271350000ziy9.gif][]   
图5 项目运行结果

可以看到，Form类本身具备了处理各种消息的方法，并且每个方法和不同的消息一一对应。我们只需要覆盖其中的不同方法，就可以改变对某个消息的处理方式。

在Form类中，所有以On开头的方法都是处理各种消息的，这些方法都定义为virtual，都可以被子类的同样方法所覆盖。

消息都会附加一些参数，例如鼠标消息会附加鼠标指针的坐标，鼠标按键的类型；键盘消息会附加键盘按键的值，键盘组合键值等。这些消息参数被包装为EventArgs类的不同子类的对象，传递给消息处理方法。

![0_12713500011t47.gif][]    
图6 EventArgs类继承图

其中，EventArgs类不具有特殊的属性，仅具有一个静态的Empty属性，引用到了一个EventArgs对象上，表示消息没有额外的参数。也就是说，当我们看到一个消息处理方法的参数为EventArgs类的对象引用，那说明**这个方法处理的消息没有特别的消息参数**。

如果消息方法的参数是一个EventArgs类的子类对象引用，则说明这个消息附带一些特殊的参数，例如图中的MouseVentArgs类，表示鼠标消息参数，具有坐标属性，鼠标按键属性等。

上述响应窗体事件的方法：继承Form类，覆盖On打头的消息处理方法，根据参数获取消息附加参数。

**　　注意：一般而言，我们再覆盖On系列方法时，都要在第一句使用base.OnXXX调用超类的被覆盖方法一次，因为超类定义的On系列方法是虚拟方法，本身具有方法体，对消息有一些基本的处理，我们需要调用一次。**

**3 利用EventHandler委托**

一个窗体除了On系列方法处理消息外，还有一系列**XXXEventHandler**类型的**事件**属性，名称恰好是On系列方法的方法名去掉On。消息处理方法和事件属性之间的关系为：**每一个事件处理方法在内部都访问了对应的事件属性，通过这些属性调用了代理的方法（如果有的话）**。

EventHandle委托的类型为：

**\[csharp\]**  [view plain][]   [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **public** **delegate** **void** EventHandler(**object** sender, EventArgs e);

其中，sender参数为引发事件的对象，例如本例中的窗体Form对象。e参数为消息参数，即引发该事件的消息的附加参数。EventArgs类型表示没有附加参数。

其它XXXEventHandler委托大体上和EventHandler委托类似，只是参数不为EventArgs，例如处理鼠标消息的MouseEventHandler类型为：

**\[csharp\]**  [view plain][]   [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **public** **delegate** **void** MouseEventHandler(**object** sender, MouseEventArgs e);

重新改动上一节的代码

**\[csharp\]**  [view plain][]   [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **using** System;  
2.  **using** System.Drawing;  
3.  **using** System.Windows.Forms;  
4.    
5.  **namespace** Edu.Study.Graphics.EventHandler \{  
6.    
7.      **static** **class** Program \{  
8.    
9.          /// <summary>  
10.         /// 保存键盘按键消息的按键值  
11.         /// </summary>  
12.         **private** **static** Keys key = Keys.NoName;  
13.   
14.         /// <summary>  
15.         /// 保存鼠标单击消息的坐标值  
16.         /// </summary>  
17.         **private** **static** Point point = Point.Empty;  
18.   
19.         /// <summary>  
20.         /// 窗体对象  
21.         /// </summary>  
22.         **private** **static** Form form = **new** Form();  
23.   
24.         /// <summary>  
25.         /// 主方法  
26.         /// </summary>  
27.         **static** **void** Main(**string**\[\] args) \{  
28.             form.Height = 600;  
29.             form.Width = 800;  
30.             form.Text = "窗体事件";  
31.   
32.             // 将委托方法关联窗体到事件属性上  
33.   
34.             // 关联鼠标事件  
35.             form.MouseDown += **new** MouseEventHandler(FormMouseDown);  
36.             // 关联按键事件  
37.             form.KeyDown += **new** KeyEventHandler(FormKeyDown);  
38.             // 关联刷新事件  
39.             form.Paint += **new** PaintEventHandler(FormPaint);  
40.   
41.             Application.Run(form);  
42.         \}  
43.   
44.         **static** **void** FormMouseDown(**object** sender, MouseEventArgs e) \{  
45.             // 将单击时的坐标保存  
46.             point = **new** Point(e.X, e.Y);  
47.               
48.             // 刷新窗口, 发出窗口重绘消息  
49.             form.Refresh();  
50.         \}  
51.   
52.         **static** **void** FormKeyDown(**object** sender, KeyEventArgs e) \{  
53.             // 将键盘按键值保存  
54.             key = e.KeyCode;  
55.             form.Refresh();  
56.         \}  
57.   
58.         **static** **void** FormPaint(**object** sender, PaintEventArgs e) \{  
59.             // 实例化字体对象  
60.             // 使用窗体默认字体, 字号30  
61.             Font font = **new** Font(form.Font.FontFamily, 30F);  
62.   
63.             // 将鼠标坐标绘制在界面上  
64.             e.Graphics.DrawString(  
65.                 **string**.Format("\{0\} : \{1\}", point.X, point.Y), // 要绘制的字符串  
66.                 font, // 绘制使用的字体  
67.                 **new** SolidBrush(Color.Red), // 绘制使用的画刷  
68.                 10, 5 // 绘制到屏幕的坐标  
69.             );  
70.   
71.             // 将键盘按键值转换为字符串  
72.             **string** showText = key.ToString();  
73.   
74.             // 实例化字体对象  
75.             font = **new** Font(form.Font.FontFamily, 50F);  
76.   
77.             // 测量字符串大小(高度、宽度)  
78.             SizeF size = e.Graphics.MeasureString(showText, font);  
79.   
80.             // 获取屏幕中央点  
81.             PointF pointf = **new** PointF((**float**)form.Width / 2F, (**float**)form.Height / 2F);  
82.   
83.             // 计算字符串绘制起始位置  
84.             pointf.X -= size.Width / 2;  
85.             pointf.Y -= size.Height / 2;  
86.   
87.             // 绘制字符串  
88.             e.Graphics.DrawString(showText, font, **new** SolidBrush(Color.Green), pointf);  
89.         \}  
90.     \}  
91. \}

这一次我们使用了Form对象和它的各类事件属性，执行结果和上一节代码完全相同。

对于一般性的编程，我们可以灵活的使用上述的两种方式，继承或使用事件属性，来为窗体添加我们感兴趣的事件处理方法，让窗体具有更好的功能。

[Link 1]: http://blog.csdn.net/mousebaby808/article/details/5385188
[view plain]: http://blog.csdn.net/mousebaby808/article/details/5385188#
[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/149057
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/149057/fork
[0_1271349998ElMm.gif]: /images/20220715/5274cb84a940423792271d77dabd8b1e.png
[0_12713499999zmC.gif]: /images/20220715/e04bb4d29ccc4d8aaeca3bbfcc64a7ba.png
[0_1271350000ziy9.gif]: /images/20220715/ea9f5f7e75d341ec8d52741a55d6c332.png
[0_12713500011t47.gif]: /images/20220715/8e6483f0b916416085648d07b2caf83b.png