AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Winform应用程序实现通用消息窗口

2017-11-15 1075
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

记得我之前发表过一篇文章《Winform应用程序实现通用遮罩层》，是实现了透明遮罩的消息窗口，功能侧重点在动图显示+消息提醒，效果看上去比较的炫，而本篇我又来重新设计通用消息窗口，功能重点在于消息提醒、进度报告，当然如果大家时间，可以将两种相结合，那样就会更完美了，我这里仍是以实现功能为主，由于代码相对简单，我就直接贴上所有代码，大家可以直接复制到本地测试，若发现问题可自行改正或反馈给我，我来完善，谢谢！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
using  System;
using  System.Collections.Generic;
using  System.ComponentModel;
using  System.Data;
using  System.Drawing;
using  System.Text;
using  System.Threading;
using  System.Windows.Forms;
 
namespace  WindowsFormsApplication1
{
     /// <summary>
     /// 等待窗口：用于处理耗时工作时，友好显示消息窗口
     /// 作者：Zuowenjun
     /// 日期：2016-1-29
     /// 网址：http://www.zuowenjun.cn
     /// </summary>
     public  partial  class  FRM_Waitting : Form
     {
         private  SynchronizationContext formContext;
 
         public  string  Message
         {
             get  {  return  labMessage.Text; }
             set  { labMessage.Text = value; }
         }
 
         public  Action<WaittingForWorkObject> WorkAction {  get ;  set ; }
 
         public  object  WorkActionParam {  get ;  set ; }
 
         public  Exception WorkException {  get ;  private  set ; }
 
         public  class  WaittingForWorkObject
         {
             private  SendOrPostCallback UpdateMessageAction =  null ;
             public  SynchronizationContext Context {  get ;  private  set ; }
 
             public  object  UserData {  get ;  private  set ; }
 
             public  void  UpdateMessage( string  msg)
             {
                 this .Context.Post(UpdateMessageAction, msg);
             }
 
             public  WaittingForWorkObject(FRM_Waitting parentForm)
             {
                 this .Context = parentForm.formContext;
                 this .UserData = parentForm.WorkActionParam;
                 this .UpdateMessageAction =  delegate ( object  o)
                 {
                     parentForm.Message = o.ToString();
                 };
             }
         }
 
 
         public  static  void  WaittingForWork(Action<WaittingForWorkObject> workAction,  object  workParam =  null ,  string  text =  "请稍候" ,  string  message =  "系统处理中，请稍候..." )
         {
             var  waittingForm =  new  FRM_Waitting(text, message, workAction, workParam);
             waittingForm.ShowDialog();
             if  (waittingForm.WorkException !=  null )
             {
                 throw  waittingForm.WorkException;
             }
 
         }
 
         public  FRM_Waitting()
         {
             InitializeComponent();
         }
 
         public  FRM_Waitting( string  text,  string  message, Action<WaittingForWorkObject> workAction,  object  workParam =  null )
             :  this ()
         {
             this .Text = text;
             this .Message = message;
             this .WorkAction = workAction;
             this .WorkActionParam = workParam;
         }
 
         private  void  FRM_Waitting_Load( object  sender, EventArgs e)
         {
 
         }
 
         private  void  FRM_Waitting_Shown( object  sender, EventArgs e)
         {
             formContext = SynchronizationContext.Current;
             if  (WorkAction !=  null )
             {
                 Thread workThread =  new  Thread(DoWork);
                 workThread.IsBackground =  true ;
                 workThread.Start();
             }
         }
 
         private  void  DoWork()
         {
             try
             {
                 var  wfObject =  new  WaittingForWorkObject( this );
                 WorkAction(wfObject);
             }
             catch  (Exception ex)
             {
                 WorkException = ex;
             }
             formContext.Send( delegate ( object  o) {  this .Close(); },  null );
         }
 
 
 
     }
}

以下是系统自动生成的代码：

上述代码比较简单，我这里对消息窗口的实现原理作一个简要的说明：

1.将耗时处理逻辑代码封装到一个委托中（Aciton<FRM_Waitting.WaittingForWorkObject>）；

2.获取当前同步上下文并保存，以便可以跨线程操作UI；

3.创建并运行一个后台线程，同时将该线程指定到DoWork（工作方法）；

4.在DoWork方法中实例化WaittingForWorkObject对象，并传给1中委托，然后执行委托，这样耗时的操作都在后台线程中处理了；

5.在DoWork方法使用try catch捕获可能存在的异常，若发生异常则保存到WorkException属性中；

6.执行完成后（无论是否报错），通过同上下文发送关闭消息窗口指令，使消息窗口关闭；

7.在静态方法WaittingForWork中判断WorkException属性是否不为空，若不为空则重新抛出错误，这样主线程就知道发生了什么异常；

 说明：为了能够兼容.NET 2.0及以上版本，代码中采用了匿名方法，而非Lambada表达式，实际使用时则可以任意选择，下面的测试示例中均提供了新旧两种代码写法，以供大家比较。

以下是各种测试示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/// <summary>
/// 测试：普通显示一个消息窗口
/// </summary>
private  void  Test1()
{
     //旧方式（兼容.NET2.0及以上）
     FRM_Waitting.WaittingForWork( delegate (FRM_Waitting.WaittingForWorkObject o)
     {
         //在这里面写耗时处理逻辑代码，以下是模拟耗时
         Thread.Sleep(10 * 1000);
     });
 
     //新方式（.NET4.0及以上）
     //FRM_Waitting.WaittingForWork((o) =>
     //{
         //在这里面写耗时处理逻辑代码，以下是模拟耗时
     //    Thread.Sleep(10 * 1000);
     //});
 
}

效果如下：

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/// <summary>
/// 测试：普通显示一个消息窗口,并自定义提示消息并窗口标题
/// </summary>
private  void  Test1_1()
{
     //旧方式（兼容.NET2.0及以上）
     FRM_Waitting.WaittingForWork( delegate (FRM_Waitting.WaittingForWorkObject o)
     {
         //在这里面写耗时处理逻辑代码，以下是模拟耗时
         Thread.Sleep(10 * 1000);
     }, null , "客官请稍候" , "客官，店小二正在为您拼命处理中，请稍等片刻..." );
 
     //新方式（.NET4.0及以上）
     //FRM_Waitting.WaittingForWork((o) =>
     //{
         //在这里面写耗时处理逻辑代码，以下是模拟耗时
     //    Thread.Sleep(10 * 1000);
     //},null,"客官请稍候","客官，店小二正在为您拼命处理中，请稍等片刻...");
 
}

效果如下：

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/// <summary>
/// 测试：普通显示一个消息窗口,并在后台线程中抛出错误，前台显示错误信息
/// </summary>
  private  void  Test1_2()
{
      try
      {
          //旧方式（兼容.NET2.0及以上）
          //FRM_Waitting.WaittingForWork(delegate(FRM_Waitting.WaittingForWorkObject o)
          //{
          //    //在这里面写耗时处理逻辑代码，以下是模拟耗时
          //    Thread.Sleep(10 * 1000);
          //    throw new Exception("这里后台线程里抛出的错误！");
          //});
 
          //新方式（.NET4.0及以上）
          FRM_Waitting.WaittingForWork((o) =>
          {
             //在这里面写耗时处理逻辑代码，以下是模拟耗时
              Thread.Sleep(10 * 1000);
              throw  new  Exception( "这里后台线程里抛出的错误！" );
          });
 
      }
      catch (Exception ex)
      {
          MessageBox.Show( "发生异常："  + ex.Message);
      }
}

效果如下：

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
/// <summary>
/// 测试：在消息窗口上显示加载进度
/// </summary>
private  void  Test2()
{
 
     //旧方式（兼容.NET2.0及以上）
     //FRM_Waitting.WaittingForWork(delegate(FRM_Waitting.WaittingForWorkObject o)
     //{
             //在这里面写耗时处理逻辑代码，以下是模拟耗时
     //    for (int i = 1; i <= 10; i++)
     //    {
     //        Thread.Sleep(1000);
     //        o.UpdateMessage(string.Format("共{0}项，当前已加载{1}项", 10, i));
     //    }
 
     //});
 
     //新方式（.NET4.0及以上）
     FRM_Waitting.WaittingForWork((o) =>
     {
         //在这里面写耗时处理逻辑代码，以下是模拟耗时
         for  ( int  i = 1; i <= 10; i++)
         {
             Thread.Sleep(1000);
             o.UpdateMessage( string .Format( "共{0}项，当前已加载{1}项" , 10, i));
         }
 
     });
 
}

效果如下：

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
/// <summary>
/// 测试：在消息窗口上显示加载进度，并同时在主窗口（非消息窗口都可以）上更新控件内容
/// </summary>
private  void  Test3()
{
 
     //旧方式（兼容.NET2.0及以上）
     FRM_Waitting.WaittingForWork( delegate (FRM_Waitting.WaittingForWorkObject o)
     {
         //在这里面写耗时处理逻辑代码，以下是模拟耗时
         for  ( int  i = 1; i <= 10; i++)
         {
             Thread.Sleep(1000);
             o.UpdateMessage( string .Format( "共{0}项，当前已加载{1}项" , 10, i));
             o.Context.Send( delegate ( object  d) {  this .listBox1.Items.Add(d); },  string .Format( "共{0}项，当前已加载{1}项" , 10, i));
         }
 
     });
 
     //新方式（.NET4.0及以上）
     //FRM_Waitting.WaittingForWork((o) =>
     //{
         //在这里面写耗时处理逻辑代码，以下是模拟耗时
     //    for (int i = 1; i <= 10; i++)
     //    {
     //        Thread.Sleep(1000);
     //        o.UpdateMessage(string.Format("共{0}项，当前已加载{1}项", 10, i));
     //        o.Context.Send(d => this.listBox1.Items.Add(d), string.Format("共{0}项，当前已加载{1}项", 10, i));
     //    }
 
     //});
 
}

效果如下：

 

看完上面的测试效果，大家觉得如何，能否满足你的日常要求呢，我认为基本都可以满足的，当然如果发现更多的情况，欢迎在下方评论留言。

本文转自 梦在旅途 博客园博客，原文链接：http://www.cnblogs.com/zuowj/p/5169241.html  ，如需转载请自行联系原作者

文章标签：
测试技术
技术小牛人
目录
相关文章
阿甘兄
10 MFC - 对话框应用程序框架介绍
10 MFC - 对话框应用程序框架介绍
阿甘兄
97 0
代码掌控者
|
19天前
|
设计模式 程序员 C#
C# 使用 WinForm MDI 模式管理多个子窗体程序的详细步骤
WinForm MDI 模式就像是有超能力一般，让多个子窗体井然有序地排列在一个主窗体之下，既美观又实用。不过，也要小心管理好子窗体们的生命周期哦，否则一不小心就会出现一些意想不到的小bug
代码掌控者
55 0
何雨晨
|
1月前
|
API C# Windows
【C#】在winform中如何实现嵌入第三方软件窗体
【C#】在winform中如何实现嵌入第三方软件窗体
何雨晨
62 0
sumith
|
6月前
MFC应用程序对话框架构
MFC应用程序对话框架构
sumith
37 0
杰克.陈
|
安全 C#
WPF的消息机制（三）- WPF内部的5个窗口之处理激活和关闭的消息窗口以及系统资源通知窗口
原文:WPF的消息机制（三）- WPF内部的5个窗口之处理激活和关闭的消息窗口以及系统资源通知窗口 版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.
杰克.陈
1040 0
杰克.陈
|
消息中间件 C#
WPF的消息机制（二）- WPF内部的5个窗口之隐藏消息窗口
原文:WPF的消息机制（二）- WPF内部的5个窗口之隐藏消息窗口 版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/powertoolsteam/article/details/6109036 ...
杰克.陈
1064 0
杰克.陈
|
消息中间件 C# Windows
WPF的消息机制（一）- 让应用程序动起来
原文:WPF的消息机制（一）- 让应用程序动起来 版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/powertoolsteam/article/details/6106485 ...
杰克.陈
1090 0
杰克.陈
|
C#
WPF关闭应用程序方法
原文:WPF关闭应用程序方法  很多人认为关闭应用程序应该很简单，例如WindowsForm里一个Application.Exit();方法就可以解决问题，但在WPF里面可别滥用，因为WPF里Application类没有该方法，倒是有一个Exit的事件驱动，在WPF应用程序里面关闭程序讲究很多： ...
杰克.陈
1304 0
maojunxu
|
JavaScript 前端开发 C++
COM组件开发实践（七）---多线程ActiveX控件和自动调整ActiveX控件大小(上)
声明：本文代码基于CodeProject的文章《A Complete ActiveX Web Control Tutorial》修改而来，因此同样遵循Code Project Open License (CPOL)。
maojunxu
867 0
嗯哼9925
|
JavaScript 前端开发 容器
COM组件开发实践（八）---多线程ActiveX控件和自动调整ActiveX控件大小(下)
嗯哼9925
1539 0