Question

Note: The code in this question is part of deSleeper if you want the full source.

One of the things I wanted out of commands was a baked design for asynchronous operations. I wanted the button pressed to disable while the command was executing, and come back when complete. I wanted the actual work to be performed in a ThreadPool work item. And lastly, I wanted a way to handle any errors that occurred during the asynchronous processing.

My solution was an AsyncCommand:

public abstract class AsyncCommand : ICommand {     public event EventHandler CanExecuteChanged;     public event EventHandler ExecutionStarting;     public event EventHandler<AsyncCommandCompleteEventArgs> ExecutionComplete;      public abstract string Text { get; }     private bool _isExecuting;     public bool IsExecuting     {         get { return _isExecuting; }         private set         {             _isExecuting = value;             if (CanExecuteChanged != null)                 CanExecuteChanged(this, EventArgs.Empty);         }     }      protected abstract void OnExecute(object parameter);      public void Execute(object parameter)     {            try         {             IsExecuting = true;             if (ExecutionStarting != null)                 ExecutionStarting(this, EventArgs.Empty);              var dispatcher = Dispatcher.CurrentDispatcher;             ThreadPool.QueueUserWorkItem(                 obj =>                 {                     try                     {                         OnExecute(parameter);                         if (ExecutionComplete != null)                             dispatcher.Invoke(DispatcherPriority.Normal,                                  ExecutionComplete, this,                                  new AsyncCommandCompleteEventArgs(null));                     }                     catch (Exception ex)                     {                         if (ExecutionComplete != null)                             dispatcher.Invoke(DispatcherPriority.Normal,                                  ExecutionComplete, this,                                  new AsyncCommandCompleteEventArgs(ex));                     }                     finally                     {                         dispatcher.Invoke(DispatcherPriority.Normal,                              new Action(() => IsExecuting = false));                     }                 });         }         catch (Exception ex)         {             IsExecuting = false;             if (ExecutionComplete != null)                 ExecutionComplete(this, new AsyncCommandCompleteEventArgs(ex));         }     }      public virtual bool CanExecute(object parameter)     {         return !IsExecuting;     } } 

so the question is: Is all this necessary? I’ve noticed built in asynchronous support for data-binding, so why not command execution? Perhaps it’s related to the parameter question, which is my next question.

Answer 1

I’ve been able to refine the original sample down and have some advice for anyone else running into similar situations.

First, consider if BackgroundWorker will meet the needs. I still use AsyncCommand often to get the automatic disable function, but if many things could be done with BackgroundWorker.

But by wrapping BackgroundWorker, AsyncCommand provides command like functionality with asynchronous behavior (I also have a blog entry on this topic)

public abstract class AsyncCommand : ICommand {     public event EventHandler CanExecuteChanged;     public event EventHandler RunWorkerStarting;     public event RunWorkerCompletedEventHandler RunWorkerCompleted;      public abstract string Text { get; }     private bool _isExecuting;     public bool IsExecuting     {         get { return _isExecuting; }         private set         {             _isExecuting = value;             if (CanExecuteChanged != null)                 CanExecuteChanged(this, EventArgs.Empty);         }     }      protected abstract void OnExecute(object parameter);      public void Execute(object parameter)     {            try         {                onRunWorkerStarting();              var worker = new BackgroundWorker();             worker.DoWork += ((sender, e) => OnExecute(e.Argument));             worker.RunWorkerCompleted += ((sender, e) => onRunWorkerCompleted(e));             worker.RunWorkerAsync(parameter);         }         catch (Exception ex)         {             onRunWorkerCompleted(new RunWorkerCompletedEventArgs(null, ex, true));         }     }      private void onRunWorkerStarting()     {         IsExecuting = true;         if (RunWorkerStarting != null)             RunWorkerStarting(this, EventArgs.Empty);     }      private void onRunWorkerCompleted(RunWorkerCompletedEventArgs e)     {         IsExecuting = false;         if (RunWorkerCompleted != null)             RunWorkerCompleted(this, e);     }      public virtual bool CanExecute(object parameter)     {         return !IsExecuting;     } }