MVP-VM (Model View Presenter - ViewModel) with Data Binding and BackgroundWorker in Windows Forms applications

protected virtual void Dispose(bool disposing)
{
    if (!this.disposed)
    {
        if (disposing)
        {
            if (this.backgroundWorker != null)
            {
                this.backgroundWorker.Dispose();
            }
        }
    }

    this.disposed = true;
}

using System;
using System.Diagnostics;
using System.Runtime.Serialization;
 
namespace DataBinding
{
    [DataContract(Name = "Solver")]
    public class MoreComplexSolver : AsynchronousSolver
    {
        private Stopwatch stopwatch;
        private bool askedUser;
 
        public event EventHandler<UserResponseRequiredEventArgs> UserResponseRequired;
 
        [DataMember]
        public string Comments { get; set; }
 
        public static MoreComplexSolver CreateDefaultSolver()
        {
            var solver = new MoreComplexSolver { Max = 1000 };
            solver.Seeds.Add(3);
            solver.Seeds.Add(5);
            return solver;
        }
 
        protected override void DoWork()
        {
            this.askedUser = false;
            this.stopwatch = new Stopwatch();
            this.stopwatch.Start();
            base.DoWork();
        }
 
        protected override bool FirstArgIsMultipleOfSecondArg(int firstArg, int secondArg)
        {
            if (this.NeedsToAskUserIfHeWantsToContinue())
            {
                var e = new UserResponseRequiredEventArgs
                    {
                        Message = "Calculation may take longer. Do you want to continue?"
                    };
                this.OnUserResponseRequired(e);
                if (!e.UserWantsToContinue)
                {
                    throw new OperationCanceledException();
                }
            }
 
            return base.FirstArgIsMultipleOfSecondArg(firstArg, secondArg);
        }
 
        protected virtual void OnUserResponseRequired(UserResponseRequiredEventArgs e)
        {
            var handler = this.UserResponseRequired;
            if (handler != null)
            {
                handler(this, e);
            }
        }
 
        private bool NeedsToAskUserIfHeWantsToContinue()
        {
            var result = this.stopwatch.ElapsedMilliseconds > 5000 && !this.askedUser;
            if (result)
            {
                this.askedUser = true;
            }
 
            return result;
        }
    }
}

protected virtual void DoWork()
{
    this.progress = new Progress(Seeds.Count, Max);
    FindSumOfMultiplesOfSeedsBelowMax();
}

private void BackgroundWorker_DoWork(object sender, DoWorkEventArgs e)
{            try
    {
        this.DoWork();
    }
    catch (OperationCanceledException)
    {
        // e.Cancel will be transferred to RunWorkerCompletedEventArgs.Canceled.
        e.Cancel = true;
    }
}

using System;
 
namespace DataBinding
{
    public class UserResponseRequiredEventArgs : EventArgs
    {
        public string Message { get; set; }
 
        public bool UserWantsToContinue { get; set; }
    }
}

public Control Control { get; set; }

public SolverPresenter(MoreComplexSolver solver)
{
    this.solver = solver;
    this.solver.AsyncCompleted += this.Solver_AsyncCompleted;
    this.solver.UserResponseRequired += this.Solver_UserResponseRequired;
    this.SolverViewModel = new SolverViewModel(solver);
    this.SolverViewModel.InitializeBoundProperties();
}

private void Solver_UserResponseRequired(object sender, UserResponseRequiredEventArgs e)
{
    if (this.Control.InvokeRequired)
    {
        this.Control.Invoke(new EventHandler<UserResponseRequiredEventArgs>(this.Solver_UserResponseRequired), new object[] { this, e });
    }
    else
    {
        var result = MessageBox.Show(
            e.Message,
            Application.ProductName,
            MessageBoxButtons.YesNo,
            MessageBoxIcon.None,
            MessageBoxDefaultButton.Button1,
            MessageBoxOptions.DefaultDesktopOnly);
        e.UserWantsToContinue = result == DialogResult.Yes;
    }
}

this.presenter.Control = this;

using System;
using System.Windows.Forms;
 
namespace DataBinding
{
    public partial class EditCommentsForm : Form
    {
        private readonly CommentsPresenter presenter;
 
        public EditCommentsForm()
        {
            InitializeComponent();
        }
 
        public EditCommentsForm(CommentsPresenter presenter)
            : this()
        {
            this.presenter = presenter;
            commentsViewModelBindingSource.DataSource = this.presenter.CommentsViewModel;
        }
 
        private void UpdateCommentsButton_Click(object sender, EventArgs e)
        {
            try
            {
                this.presenter.UpdateCommentsClicked();
            }
            catch (OperationFailedException ex)
            {
                MessageBox.Show(
                    ex.Message,
                    Application.ProductName,
                    MessageBoxButtons.OK,
                    MessageBoxIcon.None,
                    MessageBoxDefaultButton.Button1,
                    MessageBoxOptions.DefaultDesktopOnly);
            }
        }
 
        private void CancelButton_Click(object sender, EventArgs e)
        {
            try
            {
                this.presenter.CancelClicked();
            }
            catch (OperationFailedException ex)
            {
                MessageBox.Show(
                    ex.Message,
                    Application.ProductName,
                    MessageBoxButtons.OK,
                    MessageBoxIcon.None,
                    MessageBoxDefaultButton.Button1,
                    MessageBoxOptions.DefaultDesktopOnly);
            }
        }
    }
}

using System;
 
namespace DataBinding
{
    public class CommentsPresenter : IDisposable
    {
        private EditCommentsForm editCommentsForm;
        private bool disposed;
 
        public CommentsPresenter(string comments)
        {
            this.Comments = comments;
            this.CommentsViewModel = new CommentsViewModel { Comments = comments };
        }
 
        public CommentsViewModel CommentsViewModel { get; private set; }
 
        public string Comments { get; private set; }
 
        public void ShowForm()
        {
            this.editCommentsForm = new EditCommentsForm(this);
            this.editCommentsForm.ShowDialog();
        }
 
        public void UpdateCommentsClicked()
        {
            this.Comments = this.GetUpdatedComments();
            this.editCommentsForm.Close();
        }
 
        public void CancelClicked()
        {
            this.editCommentsForm.Close();
        }
 
        public void Dispose()
        {
            this.Dispose(true);
            GC.SuppressFinalize(this);
        }
 
        protected virtual void Dispose(bool disposing)
        {
            if (!this.disposed)
            {
                if (disposing)
                {
                    if (this.editCommentsForm != null)
                    {
                        this.editCommentsForm.Dispose();
                    }
                }
            }
 
            this.disposed = true;
        }
 
        private string GetUpdatedComments()
        {
            return this.CommentsViewModel.Comments;
        }
    }
}

namespace DataBinding
{
    public class CommentsViewModel
    {
        public string Comments { get; set; }
    }
}

public void EditCommentsClicked()
{
    var presenter = new CommentsPresenter(this.solver.Comments);
    presenter.ShowForm();
    this.SolverViewModel.UpdateComments(presenter.Comments);
}

public const string CommentsPropertyName           = "Comments";
private string comments;
public string Comments
{
    get
    {
        return this.comments;
    }

    set
    {
        if (this.comments != value)
        {
            this.comments = value;
            this.OnPropertyChanged(new PropertyChangedEventArgs(CommentsPropertyName));
        }
    }
}

public void InitializeBoundProperties()
{
    this.Max = this.solver.Max.ToString(CultureInfo.CurrentCulture);
    this.Seeds = this.GetSeeds();
    this.Answer = this.GetAnswerFromSolver();
    this.Comments = this.solver.Comments;
}

public void UpdateComments(string newComments)
{
    this.Comments = newComments;
    this.solver.Comments = newComments;
}

internal class ExampleSolverViewModel : ThreadedViewModelBase
   {
       public const string MaxPropertyName                = "Max";                 // These string constants must match the property name. Otherwise, data binding wouldn't work.
       public const string SeedsPropertyName              = "Seeds";
       private string max;
       private string seeds;
       private string answer;
       public ExampleSolverViewModel()
           : base(new ExampleSolverValidator())
       {
       }
       /// <summary>
       /// Input by UI
       /// </summary>
       public string Max
       {
           get
           {
               return this.max;
           }
           set
           {
               if (this.max != value)
               {
                   this.max = value;
                   this.ValidateMax();
               }
           }
       }
       /// <summary>
       /// Input by UI
       /// </summary>
       public string Seeds
       {
           get
           {
               return this.seeds;
           }
           set
           {
               if (this.seeds != value)
               {
                   this.seeds = value;
                   this.ValidateSeeds();
               }
           }
       }
       /// <summary>
       /// OutPut to UI
       /// </summary>
       public string Answer
       {
           get
           {
               return this.answer;
           }
           set
           {
               if (this.answer != value)
               {
                   this.answer = value;
                   this.OnPropertyChanged(new PropertyChangedEventArgs("Answer"));
               }
           }
       }
       public void Validate()
       {
           this.ValidateMax();
           this.ValidateSeeds();
       }
       internal int ValidateMax()
       {
           return Validation.ValidatePositiveInteger(MaxPropertyName, this.max);
       }
       internal Collection<int> ValidateSeeds()
       {
           return ((ExampleSolverValidator)Validation).ValidateCsvForPositiveIntegers(SeedsPropertyName, this.seeds, 10);
       }
   }

internal class ThreadedViewModelBase : ViewModelBase
    {
        private bool _canCancel;
        private bool _cancellled;
        private bool _hasRun;
        private bool _isReady = true;
        private bool _isRunning;
        private bool _neverRun = true;
        private bool _progressBarVisible;
        private int _progressPercentage;

        protected ThreadedViewModelBase(Validator validation) : base(validation)
        {
        }

        public int ProgressPercentage
        {
            get { return _progressPercentage; }

            set
            {
                if (_progressPercentage != value)
                {
                    _progressPercentage = value;
                    OnPropertyChanged(new PropertyChangedEventArgs("ProgressPercentage"));
                }
            }
        }

        public bool ProgressBarVisible
        {
            get { return _progressBarVisible; }

            set
            {
                if (_progressBarVisible != value)
                {
                    _progressBarVisible = value;
                    OnPropertyChanged(new PropertyChangedEventArgs("ProgressBarVisible"));
                }
            }
        }

        public bool IsReady
        {
            get { return _isReady; }

            set
            {
                if (_isReady != value)
                {
                    _isReady = value;
                    OnPropertyChanged(new PropertyChangedEventArgs("IsReady"));
                    IsRunning = !value;
                    CanCancel = !value;
              
                }
            }
        }

        public bool IsRunning
        {
            get { return _isRunning; }

            private set
            {
                if (_isRunning != value)
                {
                    _isRunning = value;
                    OnPropertyChanged(new PropertyChangedEventArgs("IsRunning"));
                    if (!_hasRun)
                    {
                        HasRun = true;
                    }
                }
            }
        }


        public bool HasRun
        {
            get { return _hasRun; }

            private set
            {
                if (_hasRun != value)
                {
                    _hasRun = value;
                    OnPropertyChanged(new PropertyChangedEventArgs("HasRun"));
                    NeverRun = !_hasRun;
                    HasAnswer = _hasRun && !_cancellled;
                }
            }
        }

        public bool NeverRun
        {
            get { return _neverRun; }

            private set
            {
                if (_neverRun != value)
                {
                    _neverRun = value;
                    OnPropertyChanged(new PropertyChangedEventArgs("NeverRun"));
                }
            }
        }

        public bool CanCancel
        {
            get { return _isRunning && _canCancel; }

            set
            {
                if (_isRunning && _canCancel != value)
                {
                    _canCancel = value;
                    OnPropertyChanged(new PropertyChangedEventArgs("CanCancel"));
                }
            }
        }

        public bool Cancelled
        {
            get { return _cancellled; }

            set
            {
                if (_cancellled != value)
                {
                    _cancellled = value;
                    OnPropertyChanged(new PropertyChangedEventArgs("Cancelled"));
                    HasAnswer = _hasRun && !_cancellled;
                }
            }
        }

        private bool _hasAnswer;

        public bool HasAnswer
        {
            get { return _hasAnswer; }
            set
            {
                if (this._hasAnswer != value)
                {
                    this._hasAnswer = value;
                    this.OnPropertyChanged(new PropertyChangedEventArgs("HasAnswer"));
                }
            }
        }

internal class ViewModelBase : IDataErrorInfo, INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;
        protected ViewModelBase(Validator validation)
        {
            Validation = validation;
        }
        [Browsable(false)]
        public bool IsValid
        {
            get { return this.Validation.ErrorCount == 0; }
        }

        [Browsable(false)]
        public string Error
        {
            get { return this.Validation.ToString(); }
        }

        protected Validator Validation { get; private set; }

        public Exception RuntimeError { get; set; }

        public string RuntimeErrorMessage { 
            get
        {
            return RuntimeError == null ? string.Empty : RuntimeError.Message;
        }
        }
        /// <summary>
        /// Gets the error message for the property with the given name.
        /// </summary>
        /// <returns>
        /// The error message for the property. The default is a null.
        /// </returns>
        /// <param name="columnName">The name of the property whose error message to get. 
        ///                 </param>
        public string this[string columnName]
        {
            get
            {
                return this.Validation[columnName];
            }
        }

        protected virtual void OnPropertyChanged(PropertyChangedEventArgs e)
        {
            var handler = this.PropertyChanged;
            if (handler != null)
            {
                handler(this, e);
            }            
        }
    }

public class ExampleSolverValidator : Validator
    {

        public Collection<int> ValidateCsvForPositiveIntegers(string propertyName, string value, int maxCount)
        {
            if (string.IsNullOrEmpty(propertyName))
            {
                throw new ArgumentNullOrEmptyException(propertyName);
            }
            Collection<int> result = new Collection<int>();
     
                Clear(propertyName);
                foreach (string v in value.Split(new[] { ',' }, maxCount))
                {
                    int output;
                    if (!int.TryParse(v, out output))
                    {
                        string s = "Cannot convert to one or more valid whole numbers \"" + value + "\".";
                        AddValidationError(propertyName, s);
                        return null;
                    }

                    if (output <= 0)
                    {
                        AddValidationError(propertyName, "Must all be positive whole numbers.");
                        return null;
                    }

                    result.Add(output);
                }
         

            return result;
        }
    }

public class Validator
    {
        private readonly Dictionary<string, string> _errorList = new Dictionary<string, string>();


        public int ValidatePositiveInteger(string propertyName, string value)
        {
            //Contract.Requires(!string.IsNullOrEmpty(propertyName));
            //Contract.Requires(value != null);

            Clear(propertyName);
            int result;
            if (!int.TryParse(value, out result))
            {
                AddValidationError(propertyName, propertyName + " Must be a valid whole number.");
                return 0;
            }

            if (result <= 0)
            {
                AddValidationError(propertyName, propertyName+ " Must be a positive whole number.");
                return 0;
            }

            return result;
        }
        public int ValidatePositiveInteger(string propertyName, int value)
        {

            Clear(propertyName);
  

            if (value <= 0)
            {
                AddValidationError(propertyName, propertyName+ " Must be a positive whole number.");
            }

            return value;
        }

        public int ErrorCount
        {
            get { return this._errorList.Count; }
        }

        public string this[string propertyName]
        {
            get
            {
                if (this._errorList.ContainsKey(propertyName))
                {
                    return this._errorList[propertyName];
                }

                return null;
            }
        }

        public override string ToString()
        {
            var sb = new StringBuilder();
            foreach (var s in this._errorList.Values)
            {
                sb.AppendLine(s);
            }

            return sb.ToString();
        }

        public void Clear(string propertyName)
        {
            if (this._errorList.ContainsKey(propertyName))
            {
                this._errorList.Remove(propertyName);
            }
        }

        protected void AddValidationError(string propertyName, string message)
        {
            if (this._errorList.ContainsKey(propertyName))
            {
                var existingMessage = this._errorList[propertyName];
                if (!existingMessage.Contains(message))
                {
                    this._errorList[propertyName] += "; " + message;
                }
            }
            else
            {
                this._errorList.Add(propertyName, message);
            }
        }
    }

internal class ExampleSolver : ISolver<ProgressChangedEventArgs, int>
    {
        //[DataMember(Name = "Seeds")]
        private readonly PositiveIntegerSetCollection seeds = new PositiveIntegerSetCollection();
        private int _iteration;
        private IReportProgress<ProgressChangedEventArgs> _reporter;
        private int _result;
        private int max;
        private HashSet<int> multiples;
        private int _maxIteration;
        private DoWorkEventArgs _doWorkEventArgs;


        public static AsynchronousSolver<ExampleSolver,string, ProgressChangedEventArgs, int> CreateDefaultSolver()
        {
            ExampleSolver solver = new ExampleSolver {Max = 1000};
            AsynchronousSolver<ExampleSolver, string, ProgressChangedEventArgs, int> asyncsolver = new AsynchronousSolver<ExampleSolver,string, ProgressChangedEventArgs, int>(solver);
            solver.Seeds.Add(3);
            solver.Seeds.Add(5);
            return asyncsolver;
        }

        //[DataMember]
        public int Max
        {
            get { return max; }

            set
            {
                //Contract.Requires(value > 0, "Max must be a positive integer.");
                max = value;
            }
        }

        public int MaxIteration
        {
            get { return seeds == null ? 0 : max*seeds.Count; }
        }

        public PositiveIntegerSetCollection Seeds
        {
            get { return seeds; }
        }

        #region ISolver<ProgressChangedEventArgs,int> Members

        public void Run(IReportProgress<ProgressChangedEventArgs> reporter,DoWorkEventArgs e)
        {
            _doWorkEventArgs = e;
            _iteration = 0;
            _maxIteration = this.Max * this.Seeds.Count;

            //Contract.Requires(this.Max > 0, "Max must be assigned a positive integer before calling this function.");
            //Contract.Requires(this.Seeds.Count > 0, "At least one seed needs to be added before calling this function.");
            _reporter = reporter;
            _result = 0;
            multiples = new HashSet<int>();
            GetMultiples();
            GetSum();
            e.Result = Result;
        }

        public int Result
        {
            get { return _result; }
        }

        #endregion

        private void AccumulateResults(int value)
        {
            try
            {
                multiples.Add(value);
            }
            catch (OutOfMemoryException ex)
            {
                multiples.Clear();
                string msg = string.Format
                    (CultureInfo.CurrentCulture, "Out of memory. Too many multiples ({0}) found...\nPlease try different set of values.", multiples.Count);
                throw new OperationFailedException(msg, ex);
            }
        }


        private bool FirstArgIsMultipleOfSecondArg(int firstArg, int secondArg)
        {

            if (_reporter != null && _maxIteration>0)
                _reporter.ReportProgress(_iteration*100/_maxIteration);
            Thread.Sleep(25); 
                _iteration++;
            return firstArg%secondArg == 0;
        }

        private void GetMultiples()
        {
            foreach (int v in seeds)
            {
 
                GetMultiplesOf(v);
            }
        }

        private void GetMultiplesOf(int seed)
        {
            for (int i = 1; i < Max; i++)
            {
                if (_reporter.CancellationPending)
                {
                    _doWorkEventArgs.Cancel = true;
                    _doWorkEventArgs.Result = 0;
                    return;
                }
                 
                if (FirstArgIsMultipleOfSecondArg(i, seed))
                {
                    AccumulateResults(i);
                }
            }
        }

        private void GetSum()
        {
            try
            {
                _result = multiples.Sum();
            }
            catch (OverflowException ex)
            {
                string msg = string.Format
                    (
                        CultureInfo.CurrentCulture,
                        "The sum was greater than {0}.\nThis program can not handle numbers larger than that. Please try different set of values.", int.MaxValue);
                throw new OperationFailedException(msg, ex);
            }
            finally
            {
                multiples.Clear();
            }
        }
    }

internal interface ISolver<TProgress,  TResult>
  {
      void Run(IReportProgress<TProgress> arg,DoWorkEventArgs e);
      TResult Result { get; }
  }

internal class AsynchronousSolver<TSolver , TArgument, TProgress, TResult>
        where TSolver : ISolver<TProgress, TResult>
    {

        private readonly TSolver _solver;

        private BackgroundWorkerAdvanced<TArgument, TProgress, TResult> _backgroundWorker;


        public event EventHandler<BackgroundWorkerAdvanced<TArgument, TProgress, TResult>.ProgressChangedAdvancedEventArgs> ProgressChanged;

        public event PropertyChangedEventHandler PropertyChanged;

        public event EventHandler<BackgroundWorkerAdvanced<TArgument, TProgress, TResult>.RunWorkerCompletedAdvancedEventArgs> AsyncCompleted;

        internal AsynchronousSolver(TSolver solver)
        {
            _solver = solver;
  
        }


   

        #region ISolver<TArgument,TResult> Members


        public TResult Result
        {
            get { return Solver.Result; }
        }

        public TSolver Solver
        {
            get { return _solver; }
        }

        #endregion



        public void Run(TArgument arg)
        {


            this._backgroundWorker = new BackgroundWorkerAdvanced<TArgument, TProgress, TResult> { WorkerReportsProgress = true, WorkerSupportsCancellation = true };
            this._backgroundWorker.ProgressChanged += BackgroundWorkerProgressChanged;
            this._backgroundWorker.RunWorkerCompleted += BackgroundWorkerRunWorkerCompleted;
            this._backgroundWorker.DoWork += BackgroundWorkerDoWork;
            this._backgroundWorker.RunWorkerAsync(arg);
        }

        void BackgroundWorkerDoWork(object sender, BackgroundWorkerAdvanced<TArgument, TProgress, TResult>.DoWorkEventArgs e)
        {
            // Any exceptions thrown while running the code below and we don't catch
            // here, will be automatically transferred to RunWorkerCompletedEventArgs.Error property.
            // Because we catch the OperationCanceledException that we are using to
            // indicate that the user canceled the operation, RunWorkerCompletedEventArgs.Error
            // will be null.

            // When an exception is thrown and you are running it from within Visual Studio,
            // VS will pop up an "xxxException was unhandled by user code" message box.
            // Do not be warned, since this is by design. Simply clicking the Run button
            // again will let VS continue running the code. Read the following excerpt.
            // Excerpt from MSDN BackgroundWorker.DoWork Event:
            //   "If the operation raises an exception that your code does not handle,
            //   the BackgroundWorker catches the exception and passes it into the
            //   RunWorkerCompleted event handler, where it is exposed as the Error
            //   property of System.ComponentModel.RunWorkerCompletedEventArgs.
            //   If you are running under the Visual Studio debugger, the debugger
            //   will break at the point in the DoWork event handler where the unhandled
            //   exception was raised."
            try
            {
                Solver.Run(_backgroundWorker, e);
            }
            catch (OperationCanceledException)
            {
                // e.Cancel will be transferred to RunWorkerCompletedEventArgs.Canceled.
                e.Cancel = true;
            }
        }

        void BackgroundWorkerRunWorkerCompleted(object sender, BackgroundWorkerAdvanced<TArgument, TProgress, TResult>.RunWorkerCompletedAdvancedEventArgs e)
        {
          this.OnAsyncCompleted(e);
        }

        void BackgroundWorkerProgressChanged(object sender, BackgroundWorkerAdvanced<TArgument, TProgress, TResult>.ProgressChangedAdvancedEventArgs e)
        {
            this.OnProgressChanged(e);
        }

        public void CancelAsync()
        {
            this._backgroundWorker.CancelAsync();
        }



  

        private void OnProgressChanged(BackgroundWorkerAdvanced<TArgument, TProgress, TResult>.ProgressChangedAdvancedEventArgs e)
        {
            var handler = this.ProgressChanged;
            if (handler != null)
            {
                handler(this, e);
            }
        }

        private void OnPropertyChanged(PropertyChangedEventArgs e)
        {
            PropertyChangedEventHandler handler = this.PropertyChanged;
            if (handler != null)
            {
                handler(this, e);
            }
        }

        private void OnAsyncCompleted(BackgroundWorkerAdvanced<TArgument, TProgress, TResult>.RunWorkerCompletedAdvancedEventArgs e)
        {
            var handler = this.AsyncCompleted;
            if (handler != null)
            {
            
                handler(this, e);
            }
        }




    }

/// <summary>
    /// Executes an operation on a separate thread.
    /// </summary>
    /// <typeparam name="TArgument">The type of argument passed to the worker.</typeparam>
    /// <typeparam name="TProgress">The type of ProgressChangedEventArgs.UserState.</typeparam>
    /// <typeparam name="TResult">The type of result retrieved from the worker.</typeparam>

    public class BackgroundWorkerAdvanced<TArgument, TProgress, TResult> : IReportProgress<TProgress>
    {
        #region Constants
        public sealed class RunWorkerCompletedAdvancedEventArgs : RunWorkerCompletedEventArgs
        {
            #region Constructors

            /// <summary>
            /// Initializes a new instance of the CurrentPatient.RunWorkerCompletedEventArgs class.
            /// </summary>
            /// <param name="result">The result of an asynchronous operation.</param>
            /// <param name="error">Any error that occurred during the asynchronous operation.</param>
            /// <param name="cancelled">A value indicating whether the asynchronous operation was cancelled.</param>
            public RunWorkerCompletedAdvancedEventArgs(TResult result, Exception error, bool cancelled):base(result,error,cancelled )
            {


            }

            #endregion

     

            #region Properties

            /// <summary>
            /// Gets a value that represents the result of an asynchronous operation.
            /// </summary>
            public TResult MyResult
            {
                get
                {
                    return base.Result!=null?(TResult) base.Result:default(TResult);
                }
        
            }

            #endregion
        }
        /// <summary>
        /// Provides data for the CurrentPatient.BackgroundWorker.DoWork event.
        /// </summary>
        /// <typeparam name="TArgument">The type of argument passed to the worker.</typeparam>
        /// <typeparam name="TResult">The type of result retrieved from the worker.</typeparam>
        public sealed class DoWorkEventArgs : System.ComponentModel.DoWorkEventArgs
        {
            #region Constructors

            /// <summary>
            /// Initializes a new instance of the CurrentPatient.DoWorkEventArgs class.
            /// </summary>
            /// <param name="argument">Specifies an argument for an asynchronous operation.</param>
            public DoWorkEventArgs(TArgument argument)
                : base(argument)
            {

            }

            #endregion

            #region Properties

            /// <summary>
            /// Gets a value that represents the argument of an asynchronous operation.
            /// </summary>
            public TArgument MyArgument
            {
                get { return (TArgument)base.Argument; }

            }
            /// <summary>
            /// Gets a value that represents the result of an asynchronous operation.
            /// </summary>
            public TResult MyResult
            {
                get
                {
                    return base.Result != null ? (TResult)base.Result : default(TResult);
                }

            }

            #endregion
        }

        /// <summary>
        /// Provides data for the CurrentPatient.BackgroundWorker.ProgressChanged event.
        /// </summary>
        /// <typeparam name="T">The type of UserState.</typeparam>
        public sealed class ProgressChangedAdvancedEventArgs : EventArgs
        {
            #region Constructors

            /// <summary>
            /// Initializes a new instance of the CurrentPatient.ProgressChangedEventArgs class.
            /// </summary>
            /// <param name="progressPercentage">The percentage of an asynchronous task that has been completed.</param>
            /// <param name="userState">A unique user state.</param>
            public ProgressChangedAdvancedEventArgs(int progressPercentage, TProgress userState)
            {
                ProgressPercentage = progressPercentage;
                UserState = userState;
            }

            #endregion

            #region Properties

            /// <summary>
            /// Gets the asynchronous task progress percentage.
            /// </summary>
            public int ProgressPercentage { get; private set; }

            /// <summary>
            /// Gets a unique user state.
            /// </summary>
            public TProgress UserState { get; private set; }

            #endregion
        }

        public const int MinProgress = 0;
        public const int MaxProgress = 100;

        #endregion

        #region Events

        /// <summary>
        /// Occurs when CurrentPatient.BackgroundWorker.RunWorkerAsync() is called.
        /// </summary>
        public event EventHandler<DoWorkEventArgs> DoWork;
        /// <summary>
        /// Occurs when CurrentPatient.BackgroundWorker.ReportProgress(System.Int32) is called.
        /// </summary>
        public event EventHandler<ProgressChangedAdvancedEventArgs> ProgressChanged;
        /// <summary>
        /// Occurs when the background operation has completed, has been canceled, or has raised an exception.
        /// </summary>
        public event EventHandler<RunWorkerCompletedAdvancedEventArgs> RunWorkerCompleted;

        #endregion

        #region Fields

        private AsyncOperation asyncOperation = null;
        private readonly ThreadStart threadStart;
        private readonly SendOrPostCallback operationCompleted;
        private readonly SendOrPostCallback progressReporter;

        #endregion

        #region Constructor

        /// <summary>
        /// Initializes a new instance of the CurrentPatient.BackgroundWorker class.
        /// </summary>
        public BackgroundWorkerAdvanced()
        {
            threadStart = new ThreadStart(WorkerThreadStart);
            operationCompleted = new SendOrPostCallback(AsyncOperationCompleted);
            progressReporter = new SendOrPostCallback(ProgressReporter);
            WorkerReportsProgress = true;
            WorkerSupportsCancellation = true;
        }

        #endregion

        #region Properties

        /// <summary>
        /// Gets a value indicating whether the application has requested cancellation of a background operation.
        /// </summary>
        public bool CancellationPending
        {
            get;
            private set;
        }
        /// <summary>
        /// Gets a value indicating whether the CurrentPatient.BackgroundWorker
        /// is running an asynchronous operation.
        /// </summary>
        public bool IsBusy
        {
            get;
            private set;
        }
        /// <summary>
        /// Gets or sets a value indicating whether the CurrentPatient.BackgroundWorker
        /// can report progress updates. The default is true.
        /// </summary>
        public bool WorkerReportsProgress
        {
            get;
            set;
        }
        /// <summary>
        /// Gets or sets a value indicating whether the CurrentPatient.BackgroundWorker
        /// supports asynchronous cancellation. The default is true.
        /// </summary>
        public bool WorkerSupportsCancellation
        {
            get;
            set;
        }

        #endregion

        #region Methods

        private void AsyncOperationCompleted(object state)
        {
            IsBusy = false;
            CancellationPending = false;
            RunWorkerCompletedAdvancedEventArgs args = (RunWorkerCompletedAdvancedEventArgs) state;


            OnRunWorkerCompleted(args);
        }
        /// <summary>
        /// Requests cancellation of a pending background operation.
        /// </summary>
        /// <returns>true, if the CurrentPatient.BackgroundWorker supports cancellation;
        /// otherwise, false.</returns>
        public bool CancelAsync()
        {
            if (!WorkerSupportsCancellation)
                return false;
            CancellationPending = true;
            return true;
        }
        /// <summary>
        /// Raises the CurrentPatient.BackgroundWorker.DoWork event.
        /// </summary>
        /// <param name="e">A CurrentPatient.DoWorkEventArgs
        /// that contains the event data.</param>
        protected virtual void OnDoWork(DoWorkEventArgs e)
        {
            EventHandler<DoWorkEventArgs> eh = DoWork;
            if (eh != null)
                eh(this, e);
        }
        /// <summary>
        /// Raises the CurrentPatient.BackgroundWorker.ProgressChanged event.
        /// </summary>
        /// <param name="e">A CurrentPatient.ProgressChangedEventArgs
        /// that contains the event data.</param>
        protected virtual void OnProgressChanged(ProgressChangedAdvancedEventArgs e)
        {
            EventHandler<ProgressChangedAdvancedEventArgs> eh = ProgressChanged;
            if (eh != null)
                eh(this, e);
        }
        /// <summary>
        /// Raises the CurrentPatient.BackgroundWorker.RunWorkerCompleted event.
        /// </summary>
        /// <param name="e">A CurrentPatient.RunWorkerCompletedEventArgs
        /// that contains the event data.</param>
        protected virtual void OnRunWorkerCompleted(RunWorkerCompletedAdvancedEventArgs e)
        {
            EventHandler<RunWorkerCompletedAdvancedEventArgs> eh = RunWorkerCompleted;
            if (eh != null)
                eh(this, e);
        }
        private void ProgressReporter(object state)
        {
            OnProgressChanged((ProgressChangedAdvancedEventArgs)state);
        }
        /// <summary>
        /// Raises the CurrentPatient.BackgroundWorker.ProgressChanged event.
        /// </summary>
        /// <param name="percentProgress">The percentage, from 0 to 100, of the background operation that is complete.</param>
        /// <returns>true, if the CurrentPatient.BackgroundWorker reports progress;
        /// otherwise, false.</returns>
        public bool ReportProgress(int percentProgress)
        {
            return ReportProgress(percentProgress, default(TProgress));
        }
        /// <summary>
        /// Raises the CurrentPatient.BackgroundWorker.ProgressChanged event.
        /// </summary>
        /// <param name="percentProgress">The percentage, from MinProgress to MaxProgress,
        /// of the background operation that is complete.</param>
        /// <param name="userState">An object to be passed to the
        /// CurrentPatient.BackgroundWorker.ProgressChanged event.</param>
        /// <returns>true, if the CurrentPatient.BackgroundWorker reports progress;
        /// otherwise, false.</returns>
        public bool ReportProgress(int percentProgress, TProgress userState)
        {
            if (!WorkerReportsProgress)
                return false;
            if (percentProgress < MinProgress)
                percentProgress = MinProgress;
            else if (percentProgress > MaxProgress)
                percentProgress = MaxProgress;
            ProgressChangedAdvancedEventArgs args = new ProgressChangedAdvancedEventArgs(percentProgress, userState);
            if (asyncOperation != null)
                asyncOperation.Post(progressReporter, args);
            else
                progressReporter(args);
            return true;
        }
        /// <summary>
        /// Starts execution of a background operation.
        /// </summary>
        /// <returns>true, if the CurrentPatient.BackgroundWorker isn't busy;
        /// otherwise, false.</returns>
        public bool RunWorkerAsync()
        {
            return RunWorkerAsync(default(TArgument));
        }
        /// <summary>
        /// Starts execution of a background operation.
        /// </summary>
        /// <param name="argument">A parameter for use by the background operation to be executed in the
        /// CurrentPatient.BackgroundWorker.DoWork event handler.</param>
        /// <returns>true, if the CurrentPatient.BackgroundWorker isn't busy;
        /// otherwise, false.</returns>
        public bool RunWorkerAsync(TArgument argument)
        {
            if (IsBusy)
                return false;
            IsBusy = true;
            CancellationPending = false;
            asyncOperation = AsyncOperationManager.CreateOperation(argument);
            threadStart.BeginInvoke(null, null);
            return true;
        }
        private void WorkerThreadStart()
        {
            TResult workerResult = default(TResult);
            Exception error = null;
            bool cancelled = false;
            try
            {
                DoWorkEventArgs doWorkArgs =
                    new DoWorkEventArgs((TArgument)asyncOperation.UserSuppliedState);
                OnDoWork(doWorkArgs);
                if (doWorkArgs.Cancel)
                    cancelled = true;
                else
                    workerResult = doWorkArgs.MyResult;
            }
            catch (Exception exception)
            {
                error = exception;
            }
            RunWorkerCompletedAdvancedEventArgs e = new RunWorkerCompletedAdvancedEventArgs(workerResult, error, cancelled);
            asyncOperation.PostOperationCompleted(operationCompleted, e);
        }

        #endregion
    }

public interface IReportProgress<TProgress>
   {
       /// <summary>
       /// Raises the CurrentPatient.BackgroundWorker.ProgressChanged event.
       /// </summary>
       /// <param name="percentProgress">The percentage, from 0 to 100, of the background operation that is complete.</param>
       /// <returns>true, if the CurrentPatient.BackgroundWorker reports progress;
       /// otherwise, false.</returns>
       bool ReportProgress(int percentProgress);

       /// <summary>
       /// Raises the CurrentPatient.BackgroundWorker.ProgressChanged event.
       /// </summary>
       /// <param name="percentProgress">The percentage, from MinProgress to MaxProgress,
       /// of the background operation that is complete.</param>
       /// <param name="userState">An object to be passed to the
       /// CurrentPatient.BackgroundWorker.ProgressChanged event.</param>
       /// <returns>true, if the CurrentPatient.BackgroundWorker reports progress;
       /// otherwise, false.</returns>
       bool ReportProgress(int percentProgress, TProgress userState);

       /// <summary>
       /// Gets a value indicating whether the application has requested cancellation of a background operation.
       /// </summary>
       bool CancellationPending
       {
           get;

       }
   }