轻松做异步 - BackgroundWorker源代码（c#)

最新推荐文章于 2022-05-27 09:15:46 发布

原创最新推荐文章于 2022-05-27 09:15:46 发布 · 3.2k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#c# #exception #object #delegates #callback #class

本文详细解析了C#中BackgroundWorker类的工作原理，包括如何启动异步任务、支持进度报告和取消操作。通过事件驱动模型，BackgroundWorker在后台线程执行任务，并在完成或遇到异常时通知主线程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

using System;

using System.ComponentModel;

namespace Unique.Shavit.UI

{
#region BackgroundWorker
public class BackgroundWorker
{
  bool m_CancelPending = false;
  bool m_ReportsProgress = false;
  bool m_SupportsCancellation = false;

  public event DoWorkEventHandler DoWork;
  public event ProgressChangedEventHandler ProgressChanged;
  public event RunWorkerCompletedEventHandler RunWorkerCompleted;

  public bool WorkerSupportsCancellation
  {
   get
   {
    lock(this)
    {
     return m_SupportsCancellation;
    }
   }

   set
   {
    lock(this)
    {
     m_SupportsCancellation = value;
    }
   }
  }

  public bool WorkerReportsProgress
  {
   get
   {
    lock(this)
    {
     return m_ReportsProgress;
    }
   }
   set
   {
    lock(this)
    {
     m_ReportsProgress = value;
    }
   }
  }

  public bool CancellationPending
  {
   get
   {
    lock(this)
    {
     return m_CancelPending;
    }
   }
  }

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

  public void RunWorkerAsync(object argument)
  {
   m_CancelPending = false;
   if(DoWork != null)
   {
    DoWorkEventArgs args = new DoWorkEventArgs(argument);
    AsyncCallback callback;
    callback = new AsyncCallback(ReportCompletion);
    DoWork.BeginInvoke(this,args,callback,args);
   }
  }

  public void ReportProgress(int percent)
  {
   if(WorkerReportsProgress)
   {
    ProgressChangedEventArgs progressArgs;
    progressArgs = new ProgressChangedEventArgs(percent);
    OnProgressChanged(progressArgs);
   }
  }

  public void CancelAsync()
  {
   lock(this)
   {
    m_CancelPending = true;
   }
  }

  protected virtual void OnProgressChanged(ProgressChangedEventArgs progressArgs)
  {
   ProcessDelegate(ProgressChanged,this,progressArgs);
  }

  protected virtual void OnRunWorkerCompleted(RunWorkerCompletedEventArgs completedArgs)
  {
   ProcessDelegate(RunWorkerCompleted,this,completedArgs);
  }

  public delegate void DoWorkEventHandler(object sender, DoWorkEventArgs e);
  public delegate void ProgressChangedEventHandler(object sender, ProgressChangedEventArgs e);
  public delegate void RunWorkerCompletedEventHandler(object sender, RunWorkerCompletedEventArgs e);

  void ProcessDelegate(Delegate del,params object[] args)
  {
   Delegate temp = del;
   if(temp == null)
   {
    return;
   }
   Delegate[] delegates = temp.GetInvocationList();
   foreach(Delegate handler in delegates)
   {
    InvokeDelegate(handler,args);
   }
  }

  void InvokeDelegate(Delegate del,object[] args)
  {
   System.ComponentModel.ISynchronizeInvoke synchronizer;
   synchronizer = del.Target as System.ComponentModel.ISynchronizeInvoke;
   if(synchronizer != null) //A Windows Forms object
   {
    if(synchronizer.InvokeRequired == false)
    {
     del.DynamicInvoke(args);
     return;
    }
    try
    {
     synchronizer.Invoke(del,args);
    }
    catch
    {}
   }
   else //Not a Windows Forms object
   {
    del.DynamicInvoke(args);
   }
  }

  void ReportCompletion(IAsyncResult asyncResult)
  {
   System.Runtime.Remoting.Messaging.AsyncResult ar = (System.Runtime.Remoting.Messaging.AsyncResult)asyncResult;
   DoWorkEventHandler del;
   del = (DoWorkEventHandler)ar.AsyncDelegate;
   DoWorkEventArgs doWorkArgs = (DoWorkEventArgs)ar.AsyncState;
   object result = null;
   Exception error = null;
   try
   {
    del.EndInvoke(asyncResult);
    result = doWorkArgs.Result;
   }
   catch(Exception exception)
   {
    error = exception;
   }
   RunWorkerCompletedEventArgs completedArgs = new RunWorkerCompletedEventArgs(result, error, doWorkArgs.Cancel);
   OnRunWorkerCompleted(completedArgs);
  }
}
#endregion

#region AsyncCompletedEventArgs
public class AsyncCompletedEventArgs : EventArgs
{
  public AsyncCompletedEventArgs (bool cancelled,Exception ex)
  {
   Cancelled= cancelled;
   Error = ex;
  }

  public AsyncCompletedEventArgs(){}
  public readonly Exception Error;
  public readonly bool Cancelled;

}

#endregion

#region CancelEventArgs

public class CancleEventArgs : EventArgs
{
private bool m_cancel = false;

  public bool Cancel
  {
   get
   {
    return m_cancel;
   }
   set
   {
    m_cancel=value;
   }
  }
}

#endregion

#region DoWorkEventArgs

public class DoWorkEventArgs : CancleEventArgs
{
  public bool Result
  {
   get
   {
    return false;
   }

set
{

}
}

public readonly object Argument;