BackgroundWorker.cs

Go to the documentation of this file.

//-----------------------------------------------------------------------
// <copyright file="BackgroundWorker.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>Wraps a System.ComponentModel.BackgroundWorker and transfers ApplicationContext.User, ClientContest, GlobalContext, CurrentCulture and CurrentUICulture to background thread.</summary>
//-----------------------------------------------------------------------
using System;
using System.ComponentModel;
using System.Globalization;
using System.Threading;
 
namespace Csla.Threading
{
  public class BackgroundWorker : System.ComponentModel.Component
  {
    private readonly System.ComponentModel.BackgroundWorker _myWorker = new System.ComponentModel.BackgroundWorker();
    public BackgroundWorker()
    {
      _myWorker.DoWork += InternalDoWork;
      _myWorker.RunWorkerCompleted += InternalRunWorkerCompleted;
      _myWorker.ProgressChanged += InternalProgressChanged;
    }
 
    // overridden event handler to be invoked by this class
    private DoWorkEventHandler _myDoWork;
    private RunWorkerCompletedEventHandler _myWorkerCompleted;
    private ProgressChangedEventHandler _myWorkerProgressChanged;
    
    [Description("Event handler to be run on a different thread when the operation begins."), Category("Asynchronous")]
    public event DoWorkEventHandler DoWork
    {
      add
      {
        _myDoWork += value;
      }
      remove
      {
        _myDoWork -= value;
      }
    }
 
    [Description("Raised when the worker has completed (either through success, failure or cancellation)."), Category("Asynchronous")]
    public event RunWorkerCompletedEventHandler RunWorkerCompleted
    {
      add
      {
        _myWorkerCompleted += value;
      }
      remove
      {
        _myWorkerCompleted -= value;
      }
    }
 
 
    [Description("Occurs when ReportProgress is called.).")]
    public event ProgressChangedEventHandler ProgressChanged
    {
      add
      {
        _myWorkerProgressChanged += value;
      }
      remove
      {
        _myWorkerProgressChanged -= value;
      }
    }
 
    public bool IsBusy
    {
      get
      {
        return _myWorker.IsBusy;
      }
    }
 
    public bool WorkerReportsProgress
    {
      get
      {
        return _myWorker.WorkerReportsProgress;
      }
      set
      {
        _myWorker.WorkerReportsProgress = value;
      }
    }
 
    public bool WorkerSupportsCancellation
    {
      get
      {
        return _myWorker.WorkerSupportsCancellation;
      }
      set
      {
        _myWorker.WorkerSupportsCancellation = value;
      }
    }
 
    public void CancelAsync()
    {
      _myWorker.CancelAsync();
    }
 
    public bool CancellationPending
    {
      get
      {
        return _myWorker.CancellationPending;
      }
    }
 
#region Worker Async Request
 
    private class WorkerAsyncRequest : ContextParams
    {
      public object Argument { get; private set; }
 
      public WorkerAsyncRequest(object argument)
      {
        this.Argument = argument;
      }
    }
 
    private class WorkerAsyncResult
    {
      public object Result { get; private set; }
      public Csla.Core.ContextDictionary GlobalContext { get; private set; }
      public Exception Error { get; private set; }
      public bool Cancelled { get; private set; }
 
      public WorkerAsyncResult(object result, Csla.Core.ContextDictionary globalContext, Exception error)
      {
        this.Result = result;
        this.GlobalContext = globalContext;
        this.Error = error;
      }
    }
 
#endregion
 
#region GlobalContext
 
 
    public Csla.Core.ContextDictionary GlobalContext { get; private set; }
 
#endregion
 
#region RunWorkerAsync
 
    public void RunWorkerAsync()
    {
      RunWorkerAsync(null);
    }
 
    public void RunWorkerAsync(object argument)
    {
      _myWorker.RunWorkerAsync(new WorkerAsyncRequest(argument));
    }
 
 
#endregion
 
#region Private methods
 
    void InternalDoWork(object sender, DoWorkEventArgs e)
    {
      var request = (WorkerAsyncRequest)e.Argument;
 
      // set the background worker thread context
      request.SetThreadContext();
 
      try
      {
        var doWorkEventArgs = new DoWorkEventArgs(request.Argument);
        if (_myDoWork != null)
        {
          _myDoWork.Invoke(this, doWorkEventArgs);
        }
#pragma warning disable CS0618 // Type or member is obsolete
        e.Result = new WorkerAsyncResult(doWorkEventArgs.Result, Csla.ApplicationContext.GlobalContext, null);
#pragma warning restore CS0618 // Type or member is obsolete
        e.Cancel = doWorkEventArgs.Cancel;
      }
      // must implement exception handling and return exception in WorkerAsyncResult
      catch (Exception ex)
      {
#pragma warning disable CS0618 // Type or member is obsolete
        e.Result = new WorkerAsyncResult(null, Csla.ApplicationContext.GlobalContext, ex);
#pragma warning restore CS0618 // Type or member is obsolete
      }
    }
 
    private void InternalRunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
    {
 
 
      Exception error = null;
      object result = null;
 
      if (!e.Cancelled)
      {
        var workerResult = (WorkerAsyncResult)e.Result;
        // always set GlobalContext returned in the BW
        // so it can be addressed in RunWorkerCompleted.
        GlobalContext = workerResult.GlobalContext;
 
        // must check for error as accessing e.Result will throw exception
        // if e.Error is not null.
        error = workerResult.Error;
        if (workerResult.Error == null)
        {
          result = workerResult.Result;
        }
      }
 
 
      if (_myWorkerCompleted != null)
      {
        _myWorkerCompleted.Invoke(this, new RunWorkerCompletedEventArgs(result, error, e.Cancelled));
      }
    }
 
    private void InternalProgressChanged(object sender, ProgressChangedEventArgs e)
    {
      if (_myWorkerProgressChanged != null)
      {
        _myWorkerProgressChanged.Invoke(this, new ProgressChangedEventArgs(e.ProgressPercentage, e.UserState));
      }
    }
 
    public void ReportProgress(int percentProgress)
    {
      _myWorker.ReportProgress(percentProgress);
    }
 
    public void ReportProgress(int percentProgress, object userState)
    {
      _myWorker.ReportProgress(percentProgress, userState);
    }
 
#endregion
  }
}