internal UploadMediaInfoWorker(FileInfo inputFile)
        {
            Logger.Info("Starting new UploadMediaInfoWorker on " + inputFile.FullName);
            this.inputFile = inputFile;

            DoWork += new DoWorkEventHandler(UploadMediaInfoWorker_DoWork);
        }

 public ProcessBackground(int Max, DoWorkEventHandler DoWork, ProgressChangedEventHandler worker_ProgressChanged)//最大值和标题
 {
     progressForm = new FrmAutoUpdate();
     progressForm.progressBarDownload.Value = 0;
     progressForm.Show();
     SetbackgroundWorker(DoWork, worker_ProgressChanged);
 }

 public BackgroundConnectionHelper(DoWorkEventHandler AsyncDelegate, RunWorkerCompletedEventHandler GUIDelegate)
 {
     backgroundWorker = new BackgroundWorker();
     backgroundWorker.DoWork += AsyncDelegate;
     backgroundWorker.RunWorkerCompleted += GUIDelegate;
     backgroundWorker.WorkerSupportsCancellation = true;
 }

        /// <summary>
        /// Shows loading form and executes given action as async background worker.
        /// </summary>
        /// <param name="action">Async action to execute</param>
        /// <param name="Text">Text to display on loading form</param>
        /// <param name="invertOrder">true - action will be runned first, loading form will be showed as second action | false - first will be showed loading form, second will be executed given action</param>
        /// <param name="sleep">delay in ms to wait between given action and loading form showing</param>
        public void runAsyncLoadingAction(DoWorkEventHandler action, String Text, bool invertOrder = false, int sleep=0)
        {
            this.Enabled = false;
            loadingText = Text;
            BackgroundWorker bw = new BackgroundWorker();
            bw.DoWork += new DoWorkEventHandler(handleLoading);

            BackgroundWorker bw2 = new BackgroundWorker();
            if (action != null)
            {
                bw2.DoWork += new DoWorkEventHandler(action);
                bw2.RunWorkerCompleted += handleLoadingEnd;
            }
            if (!invertOrder)
            {
                if (action != null)
                {
                    bw2.RunWorkerAsync();
                    if (sleep>0)
                        System.Threading.Thread.Sleep(sleep);
                }
                bw.RunWorkerAsync();
            }
            else {
                bw.RunWorkerAsync();
                if (action != null)
                {
                    if (sleep>0)
                        System.Threading.Thread.Sleep(sleep);
                    bw2.RunWorkerAsync();
                }
            }
        }

        /// <summary>
        /// ProgressDialogクラスのコンストラクタ
        /// </summary>
        /// <param name="caption">タイトルバーに表示するテキスト</param>
        /// <param name="doWorkHandler">バックグラウンドで実行するメソッド</param>
        /// <param name="argument">doWorkで取得できるパラメータ</param>
        public ProgressDialog(string caption,
            DoWorkEventHandler doWork,
            object argument)
        {
            InitializeComponent();

            //初期設定
            this.workerArgument = argument;
            this.Text = caption;
            this.FormBorderStyle = FormBorderStyle.FixedDialog;
            this.ShowInTaskbar = false;
            this.StartPosition = FormStartPosition.CenterParent;
            this.ControlBox = false;
            this.CancelButton = this.cancelAsyncButton;
            this.messageLabel.Text = "";
            this.progressBar1.Minimum = 0;
            this.progressBar1.Maximum = 100;
            this.progressBar1.Value = 0;
            this.cancelAsyncButton.Text = "キャンセル";
            this.cancelAsyncButton.Enabled = true;
            this.backgroundWorker1.WorkerReportsProgress = true;
            this.backgroundWorker1.WorkerSupportsCancellation = true;

            //イベント
            this.Shown += new EventHandler(ProgressDialog_Shown);
            this.cancelAsyncButton.Click += new EventHandler(cancelAsyncButton_Click);
            this.backgroundWorker1.DoWork += doWork;
            this.backgroundWorker1.ProgressChanged +=
                new ProgressChangedEventHandler(backgroundWorker1_ProgressChanged);
            this.backgroundWorker1.RunWorkerCompleted +=
                new RunWorkerCompletedEventHandler(backgroundWorker1_RunWorkerCompleted);
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="AsyncWorker"/> class.
 /// </summary>
 /// <param name="name">The name used in log messages.</param>
 /// <param name="worker">The worker delegate.</param>
 /// <param name="completed">The completed delegate.</param>
 public AsyncWorker(
     string name,
     DoWorkEventHandler worker,
     RunWorkerCompletedEventHandler completed)
     : this(name, worker, null, completed)
 {
 }

 public FormInfo(Form owner,
                 string Message,
                 DoWorkEventHandler DoWork,
                 RunWorkerCompletedEventHandler RunWorkerCompleted)
 {
     doInitialize(owner, Message, DoWork, RunWorkerCompleted, null);
 }

        private static void RegisterDoWork(this BackgroundWorker bw, DoWorkEventHandler doWorkEvent = null)
        {
            bw.WorkerSupportsCancellation = true;

            //默认实现
            if (doWorkEvent == null)
            {
                doWorkEvent = (sender, e) =>
                {
                    var ce = e.Argument as CustomerDoWorkEventArgs;//获取传递参数
                    BackgroundWorker cBw = ce.ExecBackgroundWorker;
                    int count = Convert.ToInt32(ce.ExecParameter.ToString(), 10);
                    for (int i = 0; i < count; i++)
                    {
                        if (!cBw.CancellationPending)//永远可以取消
                        {
                            //汇报当前处理进度
                            cBw.ReportProgress(i, "正在处理第" + i + "条数据");
                            Thread.Sleep(500);
                        }
                        else
                        {
                            e.Cancel = true;
                            return;
                        }
                    }
                    e.Result = "执行操作完成的结果：1";
                };

            }

            bw.DoWork += doWorkEvent;
        }

 public QBDepositWorker(DailyDeposit dailyDeposit)
 {
     _dailyDeposit = dailyDeposit;
     DoWork += new DoWorkEventHandler(QBDepositWorker_DoWork);
     WorkerReportsProgress = true;
     WorkerSupportsCancellation = true;
 }

 /// <summary>
 /// Constructor that accepts Event handlers for executing async thread
 /// </summary>
 /// <param name="WorkerProcess">Worker Process Handler</param>
 /// <param name="WorkProgressHandler">Progress Changed Event Handler</param>
 /// <param name="WorkCompletedHandler">Call back method handler which is invoked once the Worker Process is completed</param>
 public WorkerHelper(DoWorkEventHandler WorkerProcess, ProgressChangedEventHandler WorkProgressHandler, RunWorkerCompletedEventHandler WorkCompletedHandler)
 {
     this.DoWork += WorkerProcess;
     this.ProgressChanged += WorkProgressHandler;
     this.RunWorkerCompleted += WorkCompletedHandler;
     this.WorkerReportsProgress = true;
 }

        public ConsoleWorker(int maximumCount)
        {
            _countProtector = new Object();

            _maxCount       = maximumCount;
            _workerCallback = new AsyncCallback(this.OnRunWorkerCompleted);
            _eventHandler   = new DoWorkEventHandler(this.OnDoWork);
        }

 public static BackgroundWorker InitNewBackgroundWorker(DoWorkEventHandler doWorkEvent, ProgressChangedEventHandler progressChangedEvent, RunWorkerCompletedEventHandler runWorkerCompletedEvent)
 {
     var bw = new BackgroundWorker();
     bw.RegisterDoWork(doWorkEvent);
     bw.RegisterProgressChanged(progressChangedEvent);
     bw.RegisterRunWorkerCompleted(runWorkerCompletedEvent);
     return bw;
 }

        internal PublishWorkerHost(string outputDirectoryPath)
        {
            DoWork += new DoWorkEventHandler(SaveWorkerHost_DoWork);
            WorkerReportsProgress = true;
            WorkerSupportsCancellation = true;

            this.outputDirectoryPath = outputDirectoryPath;
        }

 private void RunBackground(DoWorkEventHandler doWork, object argument, RunWorkerCompletedEventHandler runWorkerCompleted)
 {
     using (BackgroundWorker backgroundWorker = new BackgroundWorker())
     {
         backgroundWorker.DoWork += doWork;
         backgroundWorker.RunWorkerCompleted += runWorkerCompleted;
         backgroundWorker.RunWorkerAsync(argument);
     }
 }

 public void startWork(DoWorkEventHandler work, String description)
 {
     if (bg_worker.IsBusy) return;
     isProgressBarActive = true;
     StatusText = description;
     bg_worker.DoWork += work;
     bg_worker.RunWorkerAsync();
     bg_worker.DoWork -= work;
 }

        public static double method(int i)
        {
            DoWorkEventArgs args = new DoWorkEventArgs(i);
            DoWorkEventHandler work = new DoWorkEventHandler(bw_DoWork);

            work(null, args);

            return (double)args.Result;
        }

        public DownloadWorker(String id)
            : base()
        {
            Id = id;
            WorkerReportsProgress = true;
            WorkerSupportsCancellation = true;

            DoWork += new DoWorkEventHandler(DownloadWorker_DoWork);
        }

 public BackgroundWorkerCommand(DoWorkEventHandler execute, Predicate<object> canExecute)
 {
     if (execute == null)
     {
         throw new ArgumentNullException("execute");
     }
     DoWork += execute;
     RunWorkerCompleted += RunWorkerCompletedTrack;
     this.canExecute = canExecute;
 }

 //把事件传进入
 private void SetbackgroundWorker(DoWorkEventHandler DoWork, ProgressChangedEventHandler worker_ProgressChanged)
 {           
     backgroundWorker.WorkerReportsProgress = true;//有进度条
     backgroundWorker.WorkerSupportsCancellation = true;//是否支持异步取消
     backgroundWorker.DoWork += new DoWorkEventHandler(DoWork);
     backgroundWorker.ProgressChanged += new ProgressChangedEventHandler(worker_ProgressChanged);//做的事情
     backgroundWorker.ProgressChanged += new ProgressChangedEventHandler(OnProgressChanged);//更新进度条
     backgroundWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(worker_RunWorkerCompleted);//完成事件
     backgroundWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(OnProcessCompleted);
     backgroundWorker.RunWorkerAsync();
 }

        public FrmProgressWindow(Form parentForm, string titleRoot, DoWorkEventHandler function)
        {
            _parentForm = parentForm;
            _titleRoot = titleRoot;
            InitializeComponent();

            ClientSize = new Size(511, 131);

            _titleRoot = titleRoot;

            bgWork.DoWork += function;
        }