threading - tpl c#

Comandos WPF asincrónicos

Question

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

Una de las cosas que quería sin comandos era un diseño horneado para operaciones asincrónicas. 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;
    }
}

entonces la pregunta es: ¿es todo esto necesario? 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

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

Answer 2

Pude refinar la muestra original y tener algunos consejos para cualquier 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 pueden hacer muchas cosas con BackgroundWorker.

Pero al envolver BackgroundWorker, AsyncCommand proporciona comandos como la funcionalidad con comportamiento asincrónico (también tengo una 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;
    }
}