Winform應用程序實現通用消息窗口

時間 2019-12-09

標籤 winform 應用程序實現通用消息窗口简体版

原文原文鏈接

記得我以前發表過一篇文章《Winform應用程序實現通用遮罩層》，是實現了透明遮罩的消息窗口，功能側重點在動圖顯示+消息提醒，效果看上去比較的炫，而本篇我又來從新設計通用消息窗口，功能重點在於消息提醒、進度報告，固然若是你們時間，能夠將兩種相結合，那樣就會更完美了，我這裏還是以實現功能爲主，因爲代碼相對簡單，我就直接貼上全部代碼，你們能夠直接複製到本地測試，若發現問題可自行改正或反饋給我，我來完善，謝謝！html

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);
        }



    }
}

如下是系統自動生成的代碼：ide

namespace WindowsFormsApplication1
{
    partial class FRM_Waitting
    {
        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.IContainer components = null;

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            this.labMessage = new System.Windows.Forms.Label();
            this.SuspendLayout();
            // 
            // labMessage
            // 
            this.labMessage.Dock = System.Windows.Forms.DockStyle.Fill;
            this.labMessage.Font = new System.Drawing.Font("宋體", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(134)));
            this.labMessage.Location = new System.Drawing.Point(0, 0);
            this.labMessage.Name = "labMessage";
            this.labMessage.Padding = new System.Windows.Forms.Padding(5);
            this.labMessage.Size = new System.Drawing.Size(453, 125);
            this.labMessage.TabIndex = 0;
            this.labMessage.Text = "Message";
            this.labMessage.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
            this.labMessage.UseWaitCursor = true;
            // 
            // FRM_Waitting
            // 
            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 12F);
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
            this.ClientSize = new System.Drawing.Size(453, 125);
            this.ControlBox = false;
            this.Controls.Add(this.labMessage);
            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle;
            this.Name = "FRM_Waitting";
            this.ShowIcon = false;
            this.ShowInTaskbar = false;
            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent;
            this.Text = "FRM_Waitting";
            this.UseWaitCursor = true;
            this.Load += new System.EventHandler(this.FRM_Waitting_Load);
            this.Shown += new System.EventHandler(this.FRM_Waitting_Shown);
            this.ResumeLayout(false);

        }

        #endregion

        private System.Windows.Forms.Label labMessage;
    }
}

上述代碼比較簡單，我這裏對消息窗口的實現原理做一個簡要的說明：測試

1.將耗時處理邏輯代碼封裝到一個委託中（Aciton<FRM_Waitting.WaittingForWorkObject>）；ui

2.獲取當前同步上下文並保存，以即可以跨線程操做UI；this

3.建立並運行一個後臺線程，同時將該線程指定到DoWork（工做方法）；spa

4.在DoWork方法中實例化WaittingForWorkObject對象，並傳給1中委託，而後執行委託，這樣耗時的操做都在後臺線程中處理了；線程

5.在DoWork方法使用try catch捕獲可能存在的異常，若發生異常則保存到WorkException屬性中；設計

6.執行完成後（不管是否報錯），經過同上下文發送關閉消息窗口指令，使消息窗口關閉；code

7.在靜態方法WaittingForWork中判斷WorkException屬性是否不爲空，若不爲空則從新拋出錯誤，這樣主線程就知道發生了什麼異常；component

說明：爲了可以兼容.NET 2.0及以上版本，代碼中採用了匿名方法，而非Lambada表達式，實際使用時則能夠任意選擇，下面的測試示例中均提供了新舊兩種代碼寫法，以供你們比較。

如下是各類測試示例：

        /// <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);
            //});

        }

效果以下：

        /// <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,"客官請稍候","客官，店小二正在爲您拼命處理中，請稍等片刻...");

        }

效果以下：

        /// <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);
             }
        }

效果以下：

        /// <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));
                }

            });

        }

效果以下：

        /// <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));
            //    }

            //});

        }

效果以下：

看完上面的測試效果，你們以爲如何，可否知足你的平常要求呢，我認爲基本均可以知足的，固然若是發現更多的狀況，歡迎在下方評論留言。