我一直在谷歌搜索甚至 Bing-ing，但我没有想出任何令人满意的东西。

我有一个包含一些命令的 ViewModel，例如:SaveCommand、NewCommand 和 DeleteCommand。我的 SaveCommand 执行保存到文件操作，我希望它是一个 async 操作，这样 UI 就不会等待它。

我的 SaveCommand 是 AsyncCommand 的一个实例，它实现了 ICommand。

 SaveCommand = new AsyncCommand(
  async param =>
        {
            Connection con = await Connection.GetInstanceAsync(m_configurationPath);
            con.Shoppe.Configurations = new List<CouchDbConfig>(m_configurations);
            await con.SaveConfigurationAsync(m_configurationPath);
            //now that its saved, we reload the Data.
            await LoadDataAsync(m_configurationPath);
        }, 
 ...etc

现在我正在为我的 ViewModel 构建一个测试。在其中，我使用 NewCommand 创建了一个新东西，我修改了它，然后使用 SaveCommand。

vm.SaveCommand.Execute(null);
Assert.IsFalse(vm.SaveCommand.CanExecute(null));

我的 SaveCommand 的 CanExecute 方法(未显示)应该在项目被保存后立即返回 False(没有意义保存一个不变的项目)。但是，上面显示的断言一直失败，因为我没有等待 SaveCommand 完成执行。

现在，我等不及它完成执行，因为我不能。 ICommand.Execute 不返回 Task。如果我更改 AsyncCommand 使其 Execute 返回一个 Task 那么它就不会实现 ICommand 接口(interface)

因此，出于测试目的，我认为我现在唯一能做的就是让 AsynCommand 拥有一个新功能:

public async Task ExecuteAsync(object param) { ... }

因此，我的测试将运行(和 await)ExecuteAsync 函数，XAML UI 将运行 ICommand.Execute 方法它不会等待。

我对按照我的想法、希望并希望有更好的方法来执行我提出的解决方法感到不高兴。

我的建议合理吗？有没有更好的办法？

最佳答案

您的建议是合理的，并且正是AsyncCommand implementation created by Stephen Cleary确实(他是最重要的 experts on the subject of async 代码恕我直言之一)

这是文章中代码的完整实现(加上我为我使用的用例所做的一些调整。)

AsyncCommand.cs

/*
 * Based on the article: Patterns for Asynchronous MVVM Applications: Commands
 * http://msdn.microsoft.com/en-us/magazine/dn630647.aspx
 * 
 * Modified by Scott Chamberlain 11-19-2014
 * - Added parameter support 
 * - Added the ability to shut off the single invocation restriction.
 * - Made a non-generic version of the class that called the generic version with a <object> return type.
 */
using System;
using System.ComponentModel;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Input;

namespace Infrastructure
{
    public class AsyncCommand : AsyncCommand<object>
    {
        public AsyncCommand(Func<object, Task> command) 
            : base(async (parmater, token) => { await command(parmater); return null; }, null)
        {
        }

        public AsyncCommand(Func<object, Task> command, Func<object, bool> canExecute)
            : base(async (parmater, token) => { await command(parmater); return null; }, canExecute)
        {
        }

        public AsyncCommand(Func<object, CancellationToken, Task> command)
            : base(async (parmater, token) => { await command(parmater, token); return null; }, null)
        {
        }

        public AsyncCommand(Func<object, CancellationToken, Task> command, Func<object, bool> canExecute)
            : base(async (parmater, token) => { await command(parmater, token); return null; }, canExecute)
        {
        }
    }

    public class AsyncCommand<TResult> : AsyncCommandBase, INotifyPropertyChanged
    {
        private readonly Func<object, CancellationToken, Task<TResult>> _command;
        private readonly CancelAsyncCommand _cancelCommand;
        private readonly Func<object, bool> _canExecute;
        private NotifyTaskCompletion<TResult> _execution;
        private bool _allowMultipleInvocations;

        public AsyncCommand(Func<object, Task<TResult>> command)
            : this((parmater, token) => command(parmater), null)
        {
        }

        public AsyncCommand(Func<object, Task<TResult>> command, Func<object, bool> canExecute)
            : this((parmater, token) => command(parmater), canExecute)
        {
        }

        public AsyncCommand(Func<object, CancellationToken, Task<TResult>> command)
            : this(command, null)
        {
        }

        public AsyncCommand(Func<object, CancellationToken, Task<TResult>> command, Func<object, bool> canExecute)
        {
            _command = command;
            _canExecute = canExecute;
            _cancelCommand = new CancelAsyncCommand();
        }


        public override bool CanExecute(object parameter)
        {
            var canExecute = _canExecute == null || _canExecute(parameter);
            var executionComplete = (Execution == null || Execution.IsCompleted);

            return canExecute && (AllowMultipleInvocations || executionComplete);
        }

        public override async Task ExecuteAsync(object parameter)
        {
            _cancelCommand.NotifyCommandStarting();
            Execution = new NotifyTaskCompletion<TResult>(_command(parameter, _cancelCommand.Token));
            RaiseCanExecuteChanged();
            await Execution.TaskCompletion;
            _cancelCommand.NotifyCommandFinished();
            RaiseCanExecuteChanged();
        }

        public bool AllowMultipleInvocations
        {
            get { return _allowMultipleInvocations; }
            set
            {
                if (_allowMultipleInvocations == value)
                    return;

                _allowMultipleInvocations = value;
                OnPropertyChanged();
            }
        }

        public ICommand CancelCommand
        {
            get { return _cancelCommand; }
        }

        public NotifyTaskCompletion<TResult> Execution
        {
            get { return _execution; }
            private set
            {
                _execution = value;
                OnPropertyChanged();
            }
        }

        public event PropertyChangedEventHandler PropertyChanged;
        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
        {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null)
                handler(this, new PropertyChangedEventArgs(propertyName));
        }

        private sealed class CancelAsyncCommand : ICommand
        {
            private CancellationTokenSource _cts = new CancellationTokenSource();
            private bool _commandExecuting;

            public CancellationToken Token { get { return _cts.Token; } }

            public void NotifyCommandStarting()
            {
                _commandExecuting = true;
                if (!_cts.IsCancellationRequested)
                    return;
                _cts = new CancellationTokenSource();
                RaiseCanExecuteChanged();
            }

            public void NotifyCommandFinished()
            {
                _commandExecuting = false;
                RaiseCanExecuteChanged();
            }

            bool ICommand.CanExecute(object parameter)
            {
                return _commandExecuting && !_cts.IsCancellationRequested;
            }

            void ICommand.Execute(object parameter)
            {
                _cts.Cancel();
                RaiseCanExecuteChanged();
            }

            public event EventHandler CanExecuteChanged
            {
                add { CommandManager.RequerySuggested += value; }
                remove { CommandManager.RequerySuggested -= value; }
            }

            private void RaiseCanExecuteChanged()
            {
                CommandManager.InvalidateRequerySuggested();
            }
        }
    }
}

AsyncCommandBase.cs

/*
 * Based on the article: Patterns for Asynchronous MVVM Applications: Commands
 * http://msdn.microsoft.com/en-us/magazine/dn630647.aspx
 */
using System;
using System.Threading.Tasks;
using System.Windows.Input;

namespace Infrastructure
{
    public abstract class AsyncCommandBase : IAsyncCommand
    {
        public abstract bool CanExecute(object parameter);

        public abstract Task ExecuteAsync(object parameter);

        public async void Execute(object parameter)
        {
            await ExecuteAsync(parameter);
        }

        public event EventHandler CanExecuteChanged
        {
            add { CommandManager.RequerySuggested += value; }
            remove { CommandManager.RequerySuggested -= value; }
        }

        protected void RaiseCanExecuteChanged()
        {
            CommandManager.InvalidateRequerySuggested();
        }
    }
}

NotifyTaskCompletion.cs

/*
 * Based on the article: Patterns for Asynchronous MVVM Applications: Commands
 * http://msdn.microsoft.com/en-us/magazine/dn630647.aspx
 * 
 * Modifed by Scott Chamberlain on 12/03/2014
 * Split in to two classes, one that does not return a result and a 
 * derived class that does.
 */

using System;
using System.ComponentModel;
using System.Threading.Tasks;

namespace Infrastructure
{
    public sealed class NotifyTaskCompletion<TResult> : NotifyTaskCompletion
    {
        public NotifyTaskCompletion(Task<TResult> task)
            : base(task)
        {
        }

        public TResult Result
        {
            get
            {
                return (Task.Status == TaskStatus.RanToCompletion) ?
                    ((Task<TResult>)Task).Result : default(TResult);
            }
        }
    }

    public class NotifyTaskCompletion : INotifyPropertyChanged
    {
        public NotifyTaskCompletion(Task task)
        {
            Task = task;
            if (!task.IsCompleted)
                TaskCompletion = WatchTaskAsync(task);
            else
                TaskCompletion = Task;
        }

        private async Task WatchTaskAsync(Task task)
        {
            try
            {
                await task;
            }
            catch
            {
                //This catch is intentionally empty, the errors will be handled lower on the "task.IsFaulted" branch.
            }
            var propertyChanged = PropertyChanged;
            if (propertyChanged == null)
                return;
            propertyChanged(this, new PropertyChangedEventArgs("Status"));
            propertyChanged(this, new PropertyChangedEventArgs("IsCompleted"));
            propertyChanged(this, new PropertyChangedEventArgs("IsNotCompleted"));
            if (task.IsCanceled)
            {
                propertyChanged(this, new PropertyChangedEventArgs("IsCanceled"));
            }
            else if (task.IsFaulted)
            {
                propertyChanged(this, new PropertyChangedEventArgs("IsFaulted"));
                propertyChanged(this, new PropertyChangedEventArgs("Exception"));
                propertyChanged(this, new PropertyChangedEventArgs("InnerException"));
                propertyChanged(this, new PropertyChangedEventArgs("ErrorMessage"));
            }
            else
            {
                propertyChanged(this, new PropertyChangedEventArgs("IsSuccessfullyCompleted"));
                propertyChanged(this, new PropertyChangedEventArgs("Result"));
            }
        }

        public Task Task { get; private set; }
        public Task TaskCompletion { get; private set; }
        public TaskStatus Status { get { return Task.Status; } }
        public bool IsCompleted { get { return Task.IsCompleted; } }
        public bool IsNotCompleted { get { return !Task.IsCompleted; } }
        public bool IsSuccessfullyCompleted
        {
            get
            {
                return Task.Status ==
                    TaskStatus.RanToCompletion;
            }
        }
        public bool IsCanceled { get { return Task.IsCanceled; } }
        public bool IsFaulted { get { return Task.IsFaulted; } }
        public AggregateException Exception { get { return Task.Exception; } }
        public Exception InnerException
        {
            get
            {
                return (Exception == null) ?
                    null : Exception.InnerException;
            }
        }
        public string ErrorMessage
        {
            get
            {
                return (InnerException == null) ?
                    null : InnerException.Message;
            }
        }
        public event PropertyChangedEventHandler PropertyChanged;
    }
}

关于c# - 如何在 MVVM 中对异步 ICommand 进行单元测试？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/29919705/