lyfz_repos/其他源码/LYFZ.ComponentLibrary/FrmLoadHandling.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Windows.Forms;

namespace LYFZ.ComponentLibrary
{
    /// <summary>
    /// 进度状态显示类型
    /// </summary>
   public enum LoadHandlingType {
        /// <summary>
        /// 加载固定状态显示，只显示进度动画，不显示具体进度值
        /// </summary>
        LoadProgress,
        /// <summary>
        /// 执行进度条显示，显示具体进度值
        /// </summary>
        ExecutionProgress,

    }
   public delegate void ExecutionBackgroundDoWork(object argument, BackgroundWorker backgroundWorker);
   public delegate void LoadBackgroundDoWork(object argument, BackgroundWorker backgroundWorker);

   /// <summary>
   /// 程序在执行时显示的进度状态窗体
   /// </summary>
    public partial class FrmLoadHandling : Form
    {
        /// <summary>
        /// 
        /// </summary>
        private BackgroundWorker backgroundWorker = new BackgroundWorker();
        /// <summary>
        /// 独立执行线程
        /// </summary>
        public BackgroundWorker BackgroundWorker
        {
            get { return backgroundWorker; }
            set { backgroundWorker = value; }
        }

        /// <summary>
        /// 
        /// </summary>
        private ExecutionBackgroundDoWork executionBackgroundDoWorkMethod = null;
        /// <summary>
        /// ExecutionProgress要执行的方法委托，设置要执行的法
        /// </summary>
        public ExecutionBackgroundDoWork ExecutionBackgroundDoWorkMethod 
        {
            get { return executionBackgroundDoWorkMethod; }
            set { executionBackgroundDoWorkMethod = value; }
        }
        /// <summary>
        /// 
        /// </summary>
        private LoadBackgroundDoWork loadBackgroundDoWorkMethod = null;
        /// <summary>
        /// LoadProgress要执行的方法委托，设置要执行的法
        /// </summary>
        public LoadBackgroundDoWork LoadBackgroundDoWorkMethod 
        {
            get { return loadBackgroundDoWorkMethod; }
            set { loadBackgroundDoWorkMethod = value; }
        }
        LoadProgress loadProgress = new LoadProgress();
        /// <summary>
        /// LoadProgress固定滚动进度条
        /// </summary>
        public LoadProgress LoadProgressControl
        {
            get { return loadProgress; }
            set { loadProgress = value; }
        }
        ExecutionProgress executionProgress = new ExecutionProgress();
        /// <summary>
        /// ExecutionProgress进度值滚动进度条
        /// </summary>
        public ExecutionProgress ExecutionProgressControl
        {
            get { return executionProgress; }
            set { executionProgress = value; }
        }
        ManualResetEvent eventDone = new ManualResetEvent(false);
        /// <summary>
        /// 
        /// </summary>
        public ManualResetEvent EventDone
        {
            get { return eventDone; }
            set { eventDone = value; }
        }
           
        public FrmLoadHandling(bool isInitializeBackgroundWorker)
        {
            this.isInitializeBackgroundWorker = isInitializeBackgroundWorker;
            InitializeBackgroundWorker(LoadHandlingType.LoadProgress);
        }
        public FrmLoadHandling()
        {
            InitializeBackgroundWorker(LoadHandlingType.LoadProgress);
        }
        LoadHandlingType _type = LoadHandlingType.LoadProgress;
        public FrmLoadHandling(LoadHandlingType type)
        {
            InitializeBackgroundWorker(type);
        }

        bool isInitializeBackgroundWorker = true;

        /// <summary>
        /// 初始化独立线程
        /// </summary>
        public void InitializeBackgroundWorker(LoadHandlingType type)
        {
            InitializeComponent();
            this._type = type;
            switch (this._type)
            { 
                case LoadHandlingType.LoadProgress:
                    loadProgress.Location = new Point(0,0);
                    loadProgress.Dock = DockStyle.Fill;
                    loadProgress.Name = "load" + DateTime.Now.ToString("yyyyMMddhhmmssff");
                    this.Controls.Add(loadProgress);
                    break;
                case LoadHandlingType.ExecutionProgress:
                    this.Width = 280;
                    executionProgress.Location = new Point(0, 0);
                    executionProgress.Dock = DockStyle.Fill;
                    executionProgress.Name = "exe" + DateTime.Now.ToString("yyyyMMddhhmmssff");
                    this.Controls.Add(executionProgress);
                    break;
            }
            if (isInitializeBackgroundWorker)
            {
                this.Load += new System.EventHandler(this.FrmLoadHandling_Load);
                backgroundWorker.WorkerReportsProgress = true;
                backgroundWorker.WorkerSupportsCancellation = true;
                backgroundWorker.DoWork += new DoWorkEventHandler(backgroundWorker_DoWork);
                backgroundWorker.ProgressChanged += new ProgressChangedEventHandler(backgroundWorker_ProgressChanged);
                backgroundWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(backgroundWorker_RunWorkerCompleted);
            }
           
        }
        void backgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            try
            {

                if (e.Cancelled)
                {
                    this.EventDone.Set();
                    this.DialogResult = DialogResult.Cancel;
                  
                    //  MessageBox.Show("操作取消");
                }
                else
                {
                    this.EventDone.Set();
                    this.DialogResult = DialogResult.OK;
                    //   MessageBox.Show("操作完成");
                }
            }
            catch {
                this.EventDone.Set();
                this.DialogResult = DialogResult.Cancel;
            }
        }

        void backgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            try
            {
                if (e.ProgressPercentage == -1)
                {
                    this.Opacity = 0;
                    return;
                }
                else
                {
                    this.Opacity = 100;
                }
                if (this._type == LoadHandlingType.ExecutionProgress)
                {
                    if (e.ProgressPercentage >= executionProgress.MySkinProgressBar.Maximum)
                    {
                        executionProgress.MySkinProgressBarValue = executionProgress.MySkinProgressBar.Maximum;
                    }
                    else
                    {
                        executionProgress.MySkinProgressBarValue = e.ProgressPercentage;
                    }
                    if (e.UserState != null)
                    {
                        ExecutionProgressControl.LbLoadProgress.Text = e.UserState.ToString();
                    }
                }
                if (this._type == LoadHandlingType.LoadProgress)
                {
                    if (e.UserState != null)
                    {
                        LoadProgressControl.LbLoadProgress.Text = e.UserState.ToString();
                    }
                }
            }
            catch { }
        }

        void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            try
            {
                Form frmP = this.ParentForm;
                switch (this._type)
                {
                    case LoadHandlingType.ExecutionProgress:
                        if (ExecutionBackgroundDoWorkMethod != null)
                        {
                            ExecutionBackgroundDoWorkMethod(e.Argument, this.BackgroundWorker);
                            e.Result = true;
                        }
                        else
                        {
                            e.Result = false;
                        }
                        break;
                    case LoadHandlingType.LoadProgress:
                        if (LoadBackgroundDoWorkMethod != null)
                        {
                            LoadBackgroundDoWorkMethod(e.Argument, this.BackgroundWorker);
                            e.Result = true;
                        }
                        else
                        {

                            e.Result = false;
                        }
                        break;

                }
            }
            catch (Exception ex){
                MessageBoxCustom.Show(ex.Message);
            }
            
        }


        /// <summary>
        /// 执行指定方法并显示固定状态进度条
        /// </summary>
        /// <param name="doWorkMethod">要执行指定的方法</param>
        /// <param name="argument">参数</param>
        /// <returns></returns>
        public static DialogResult LoadDoWorkMethod(LoadBackgroundDoWork doWorkMethod, object argument = null, int width = 190,bool isTopMost=false)
        {
            FrmLoadHandling frm = new FrmLoadHandling();
            
             frm.TopMost = isTopMost;
            if (width > 190 && width < 800)
            {
                frm.Width = width;
            }
            frm.LoadBackgroundDoWorkMethod = doWorkMethod;
            frm.BackgroundWorker.RunWorkerAsync(argument);
            return frm.ShowDialog();
        }

        /// <summary>
        /// 执行指定方法并显示具体进度值状态进度条
        /// </summary>
        /// <param name="doWorkMethod">要执行指定的方法</param>
        /// <param name="argument">参数</param>
        /// <param name="width">显示进度条窗体的宽度，值为：190～800 之间的整数</param>
        /// <returns></returns>
        public static DialogResult ExecutionDoWorkMethod(ExecutionBackgroundDoWork doWorkMethod, object argument = null, int width = 190)
        {
            FrmLoadHandling frm = new FrmLoadHandling(LoadHandlingType.ExecutionProgress);
           // frm.TopMost = true;
            if (width > 190 && width < 800)
            {
                frm.Width = width;
            }
            frm.ExecutionBackgroundDoWorkMethod= doWorkMethod;
            frm.BackgroundWorker.RunWorkerAsync(argument);
            return frm.ShowDialog();
        }

        private void FrmLoadHandling_Load(object sender, EventArgs e)
        {
           // backgroundWorker.RunWorkerAsync();
        }
    }
}