public pgWorker(int pos, string dsn, 
     ProgressChangedEventHandler onProgress,
     RunWorkerCompletedEventHandler onComplete)
 {
     this.thNo = pos;
     this.pg_conn = new NpgsqlConnection(dsn);
     try
     {
         pg_conn.Open();
         pg_error = "";
     }
     catch (Exception ex)
     {
         pg_conn = null;
         pg_error = ex.Message;
     }
     if (pg_conn != null)
     {
         this.bw = new BackgroundWorker();
         this.bw.WorkerReportsProgress = true;
         this.bw.WorkerSupportsCancellation = true;
         this.bw.DoWork += this.bwDoWork;
         this.bw.ProgressChanged += onProgress;
         this.bw.RunWorkerCompleted += onComplete;
     }
 }

 private void BackgroundCall( string service, RunWorkerCompletedEventHandler callback, Func<string,NameValueCollection,HappyIndex> serviceCall, NameValueCollection parameters = null )
 {
     BackgroundWorker w = new BackgroundWorker();
     w.RunWorkerCompleted += callback;
     w.DoWork += WOnDoWork;
     w.RunWorkerAsync(new BackgroundArgs{ Service = service, Parameters = parameters, ServiceCall = serviceCall });
 }

        private BackgroundWorker GetBackgroundWorker(DoWorkQueuedEventHandler doWork, RunWorkerCompletedEventHandler workerCompleted)
        {
            BackgroundWorker bw = new BackgroundWorker();
            bw.WorkerReportsProgress = false;
            bw.WorkerSupportsCancellation = false;

            bw.DoWork += (sender, args) =>
                             {
                                 if (doWork != null)
                                 {
                                     args.Result=doWork(this, new DoWorkEventArgs(args.Argument));
                                 }
                             };

            bw.RunWorkerCompleted += (sender, args) =>
                                         {
                                             if (workerCompleted != null)
                                             {
                                                 object result = args.Error == null ? args.Result : null;
                                                 workerCompleted(this,
                                                                 new RunWorkerCompletedEventArgs(result, args.Error,
                                                                                                 args.Cancelled));
                                             }
                                             Queue.Dequeue();
                                             lock (_lock)
                                             {
                                                 if (Queue.Count > 0)
                                                 {
                                                     ((BackgroundWorker)this.Queue.Peek()).RunWorkerAsync();
                                                 }
                                             }
                                         };
            return bw;
        }

        /// <summary>
        /// Creates and dispatches a PageManager to load a search page,
        /// parse, extract, validate and return results using the 
        /// parameter callback EventHandlers
        /// </summary>
        /// <param name="pageNumber">Which search page number to load</param>
        /// <param name="criteria">The user's search criteria</param>
        /// <param name="pageLoadMethod">Supply the method to retrieve html</param>
        /// <param name="updateProgressMethod">Callback for progress updates</param>
        /// <param name="workerCompleteMethod">Callback when work complete</param>
        public PageManager(int pageNumber,
            SearchCriteria criteria,
            Func<int, string, string> pageLoadMethod, // see explanation above
            ProgressChangedEventHandler updateProgressMethod,
            RunWorkerCompletedEventHandler workerCompleteMethod)
        {
            if (pageNumber < 1)
            {
                string msg = "Supplied page number ({0}) was < 0!";
                msg = string.Format(msg,pageNumber);
                throw new ArgumentOutOfRangeException(msg);
            }

            if (pageLoadMethod == null)
            {
                string msg = "Provided a null method to obtain page HTML!";
                throw new InvalidOperationException(msg);
            }

            ProgressChanged += updateProgressMethod; // Callback
            RunWorkerCompleted += workerCompleteMethod;  // Callback
            DoWork += Work;

            _pageLoadMethod = pageLoadMethod;
            _searchCriteria = criteria;
            _pageNumber = pageNumber;

            WorkerReportsProgress = true;
            WorkerSupportsCancellation = true;
        }

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

 public static void Remove(string path, RunWorkerCompletedEventHandler runworkerDone)
 {
     var bw = new BackgroundWorker { WorkerReportsProgress = false, WorkerSupportsCancellation = false };
     bw.DoWork += RemoveFileFromIndex;
     bw.RunWorkerCompleted += runworkerDone;
     bw.RunWorkerAsync(path);
 }

 /// <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 AsyncCommandBinding(ICommand command, ExecutedRoutedEventHandler executed, CanExecuteRoutedEventHandler canExecute, RunWorkerCompletedEventHandler runWokrerCompleted)
        {
            if (command == null)
            {
                throw new ArgumentNullException("command");
            }

            _task = new BackgroundWorker();
            _task.DoWork += delegate
                                {
                                    executed(null, null);
                                };
            _task.RunWorkerCompleted += (s, e) =>
                                            {
                                                runWokrerCompleted(s, e);
                                                _task.Dispose();
                                            };

            Command = command;
            if (executed != null)
            {
                Executed += delegate
                                {
                                    if (!_task.IsBusy)
                                        _task.RunWorkerAsync();
                                };
            }
            if (canExecute != null)
            {
                CanExecute += canExecute;
            }
        }

 /// <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 FormInfo(Form owner,
                 string Message,
                 DoWorkEventHandler DoWork,
                 RunWorkerCompletedEventHandler RunWorkerCompleted)
 {
     doInitialize(owner, Message, DoWork, RunWorkerCompleted, null);
 }

 //
 public void Connect()
 {
     if (!_worker.IsBusy)
     {
         this._RunWorkerCompletedEventHandler = _imageGrabber.ConnectCompletedHandler;
         _worker.RunWorkerAsync(_imageGrabber.ConnectHandler);
     }
 }

        public static void methodAsync(int i, RunWorkerCompletedEventHandler onComplete)
        {
            BackgroundWorker bw = new BackgroundWorker();
            bw.DoWork += new DoWorkEventHandler(bw_DoWork);
            bw.RunWorkerCompleted += onComplete;

            bw.RunWorkerAsync(i);
        }

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

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

 private void SetUp(string statusText, RunWorkerCompletedEventHandler workerCompletedTask)
 {
     cdDialogPanel.Enabled = false;
     cdConnectButton.Enabled = false;
     cdTestButton.Enabled = false;
     cdConnectStatusLabel.Text = statusText;
     backgroundWorker.RunWorkerCompleted += workerCompletedTask;
     backgroundWorker.RunWorkerAsync(ConnectionDetail);
 }

        public void sendEmail(string new_title, string new_body, RunWorkerCompletedEventHandler target) {
            BackgroundWorker worker = new BackgroundWorker();
            worker.DoWork += new System.ComponentModel.DoWorkEventHandler(sendEmail);
            worker.RunWorkerCompleted += new System.ComponentModel.RunWorkerCompletedEventHandler(target);
            body = new_body;
            title = new_title;
            worker.RunWorkerAsync();

        }

 public void sendEmail(string new_from, string new_to, string new_reply_to, string new_title,string new_body, RunWorkerCompletedEventHandler target)
 {
     this.DoWork += new System.ComponentModel.DoWorkEventHandler(sendEmail);
     RunWorkerCompleted += new System.ComponentModel.RunWorkerCompletedEventHandler(target);
     from = new_from;
     to = new_to;
     reply_to = new_reply_to;
     body = new_body;
     title = new_title;
     this.RunWorkerAsync();
 }

 public PackingProcess(ProgressChangedEventHandler handler, RunWorkerCompletedEventHandler completedHandler)
 {
     this.DoWork += PackingProcess_DoWork;
     this.RunWorkerCompleted += PackingProcess_RunWorkerCompleted;
     this.RunWorkerCompleted += completedHandler;
     this.WorkerReportsProgress = true;
     this.WorkerSupportsCancellation = true;
     this.ProgressChanged += handler;
     IsRunning = false;
     IsError = false;
 }

        public static void GetCardRulings(Filter filter, RunWorkerCompletedEventHandler completedDelegate)
        {
            Console.WriteLine("Call to GetCardInfo");

            if(bgWorker == null || !bgWorker.IsBusy)
            {
                bgWorker = new BackgroundWorker();
                bgWorker.DoWork += AsyncFindMatches;
                bgWorker.RunWorkerCompleted += completedDelegate;
                bgWorker.RunWorkerAsync(filter);
            }
        }

 public static void GetImageUrl(Filter filter, RunWorkerCompletedEventHandler callback)
 {
     Console.WriteLine("Call to GetImageUrl");
     if (bgWorker == null || !bgWorker.IsBusy)
     {
         bgWorker = new BackgroundWorker();
         bgWorker.DoWork += new DoWorkEventHandler(AsyncGrabImage);
         bgWorker.WorkerSupportsCancellation = true;
         bgWorker.RunWorkerCompleted += callback;
         bgWorker.RunWorkerAsync(filter);
     }
 }