asíncrono WPF Comandos

Question

Nota: El código de esta cuestión es parte de deSleeper si desea que el código fuente completo.

Una de las cosas que quería sin comandos era un diseño horneado para operaciones asíncronas. Quería que el botón presionado se deshabilitara mientras se ejecutaba el comando, y volver cuando se completara. Quería que el trabajo real se realizara en un elemento de trabajo ThreadPool. Y, por último, quería una forma de manejar cualquier error que ocurriera durante el procesamiento asincrónico.

Mi solución fue un 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; 
    } 
} 

así que la pregunta es: ¿Es necesario todo esto? Me he dado cuenta de una compatibilidad asíncrona integrada para el enlace de datos, entonces ¿por qué no ejecutar comandos? Quizás esté relacionado con la pregunta del parámetro, que es mi próxima pregunta.

Answer 1

He podido refinar la muestra original y tener algunos consejos para cualquier persona que se encuentre en situaciones similares.

En primer lugar, considere si BackgroundWorker satisfará las necesidades. Todavía uso AsyncCommand a menudo para obtener la función de desactivación automática, pero si se pueden hacer muchas cosas con BackgroundWorker.

Pero envolviendo BackgroundWorker, AsyncCommand proporciona comando como la funcionalidad con el comportamiento asíncrono (también tengo una 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; 
    } 
} 

Answer 2

Como respondí en su otra pregunta, probablemente aún quiera enlazar esto sincrónicamente y luego ejecutar los comandos de forma asíncrona. De esa forma evitarás los problemas que estás teniendo ahora.