Comandos asincrónicos de WPF

Question

Nota : El código en esta pregunta es parte de deSleeper si desea la fuente completa.

Una de las cosas que quería de los comandos era un diseño horneado para operaciones asincrónicas. Quería presionar el botón para deshabilitar mientras se ejecutaba el comando, y volver cuando estuviera completo. 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;
    }
}

entonces la pregunta es: ¿Es todo esto necesario? Me he dado cuenta de la compatibilidad asincrónica 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 dar algunos consejos para cualquier otra persona que se encuentre en situaciones similares.

Primero, 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 pudieran hacer muchas cosas con BackgroundWorker.

Pero al ajustar BackgroundWorker, AsyncCommand proporciona una funcionalidad similar a un comando con un comportamiento asincrónico (también tengo un entrada de blog sobre este tema )

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 todavía quiera vincularse a esto sincrónicamente y luego iniciar los comandos de forma asincrónica. De esa forma, evitas los problemas que tienes ahora.