BackgroundWorker的替代者! （转）

转自： http://blog.csdn.net/oldhunter/archive/2006/04/24/674310.aspx
用过2.0中BackgroundWorker的网友估计都有遭遇不爽的经历,网上有文章说已经被定为BUG了.无BUG版本估计要等.NET的下一个build了.
前两天写了个BackgroundWorker的替代者,我在自己的软件中已经用上了,目前没有发现问题.
用法与BackgroundWorker一样,除了一个InvokerControl属性. 此属性主要用在更新FORM时,把状态更新方法的执行由线程池转到调用线程中.估计用过多线程的都知道,这里就不多说了.
其它用法请参阅MDSN的BackgroundWorker类,里面的属性,方法及事件等与BackgroundWorker一模一样,所以可以用作过度替代,等.NET的build出来了再换过来!

using System;
using System.Threading;
using System.ComponentModel;
using System.Windows.Forms;

namespace bget
{
    class BackgroundWorker2 : Component
    {
        #region properties

        private Control invokerControl;

        public Control InvokerControl
        {
            get { return invokerControl; }
            set { invokerControl = value; }
        } 

        private bool cancellationPending;

        public bool CancellationPending
        {
            get { return cancellationPending; }
        }

        private bool isBusy;

        public bool IsBusy
        {
            get { return isBusy; }
        }

        private bool workerReportsProgress;

        public bool WorkerReportsProgress
        {
            get { return workerReportsProgress; }
            set { workerReportsProgress = value; }
        }

        private bool workerSupportsCancellation;

        public bool WorkerSupportsCancellation
        {
            get { return workerSupportsCancellation; }
            set { workerSupportsCancellation = value; }
        }

        #endregion

        public void RunWorkerAsync()
        {
            RunWorkerAsync(null);
        }

        public void RunWorkerAsync(Object argument)
        {
            if (IsBusy)
            {
                throw new InvalidOperationException("Worker is busy now.");
            }

            OnDoWork(new DoWorkEventArgs(argument));
        }

        public void ReportProgress(int percentProgress)
        {
            ReportProgress(percentProgress, null);
        }

        public void ReportProgress(int percentProgress, Object userState)
        {
            if ( !workerReportsProgress )
            {
                throw new InvalidOperationException("WorkerReportsProgress is required to be true.");
            }

            OnProgressChanged(new ProgressChangedEventArgs(percentProgress, userState));
        }

        public void CancelAsync()
        {
            if ( !workerSupportsCancellation )
            {
                throw new InvalidOperationException("WorkerSupportsCancellation is required to be true.");
            }

            cancellationPending = true;
        }

        #region events

        public event DoWorkEventHandler DoWork;

        protected virtual void OnDoWork(DoWorkEventArgs e)
        {
            if (DoWork != null)
            {
                isBusy = true;

                try
                {
                    DoWork.BeginInvoke(this, e, new AsyncCallback(DoWorkCallback), e); // 这里使用的是线程池
                }
                catch (Exception ex)
                {
                    OnRunWorkerCompleted(new RunWorkerCompletedEventArgs(null, ex, false));
                    isBusy = false;
                    cancellationPending = false;
                }
            }
        }

        private void DoWorkCallback(IAsyncResult ar)
        {
            if (ar.IsCompleted)
            {
                DoWorkEventArgs args = ar.AsyncState as DoWorkEventArgs;
                if (args != null)
                {
                    OnRunWorkerCompleted(new RunWorkerCompletedEventArgs(args.Result, null, args.Cancel));
                }

                isBusy = false;
                cancellationPending = false;
            }
        }

        public event ProgressChangedEventHandler ProgressChanged;

        protected virtual void OnProgressChanged(ProgressChangedEventArgs e)
        {
            if (ProgressChanged != null)
            {
                if (invokerControl == null)
                {
                    throw new InvalidOperationException("InvokerControl is required.");
                }
                if (invokerControl.InvokeRequired)
                {
                    invokerControl.Invoke(ProgressChanged, this, e);
                }
                else
                {
                    ProgressChanged(this, e);
                }
            }
        }

        public event RunWorkerCompletedEventHandler RunWorkerCompleted;

        protected virtual void OnRunWorkerCompleted(RunWorkerCompletedEventArgs e)
        {
            if (RunWorkerCompleted != null)
            {
                if (invokerControl == null)
                {
                    throw new InvalidOperationException("InvokerControl is required.");
                }
                if (invokerControl.InvokeRequired)
                {
                    invokerControl.Invoke(RunWorkerCompleted, this, e);
                }
                else
                {
                    RunWorkerCompleted(this, e);
                }
            }
        }

        #endregion       
    }
}

这是在"CSDN - 技术社区 - .NET技术 C# " 的贴子:
http://community.csdn.net/Expert/topic/4707/4707944.xml?temp=1.667422E-02