我该如何在MVVM中对异步ICommand进行单元测试？

Question

我已经谷歌和必应搜索过，但都没有找到满意的答案。

我有一个 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（保存未更改的项目没有意义）。然而，上面显示的Assert总是失败，因为我没有等待SaveCommand执行完成。

现在，我无法等待它执行完成，因为我不能。 ICommand.Execute并不返回Task。如果我将AsyncCommand更改为使其Execute返回Task，那么它将无法正确实现ICommand接口。

所以，我现在唯一能做的事情就是为了测试目的，在AsynCommand中添加一个新函数：

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

因此，我的测试将运行（并等待）ExecuteAsync函数，XAML UI将运行ICommand.Execute方法，在其中它不会await。

我对我的建议解决方法感到不满意，因为我认为，希望和期望有更好的方式。

我提出的建议合理吗？有更好的方法吗？

- Peter pete

---

你的命令中是否有任何属性表明“正在运行”或“执行”？也许一种方法是向命令添加一个“执行”标志。这也可能修复测试失败的原因，你可以在CanExecute中使用“执行”标志来确保它们不会运行两次命令。 - Ron Beyer

我明白你的意思。让我试一下。*马上回来 - Peter pete

实际上，AsyncCommand已经有了执行标志。当我最初发现这个问题时，说实话，我并没有使用AsyncCommand，而是另一种东西，它没有这个标志。也许我现在实际上没有问题！ - Peter pete

@RonBeyer：现在单元测试中的Assert已经通过了，而且由于执行标志的作用，我的UI也可以工作了。然而，当单元测试结束时，我仍然会从我的SaveCommand中得到一个ThreadAbortException，它仍然将项目保存到文件中。虽然这“不是真正的问题”，但我想知道是否可以让所有东西都干净地结束。 - Peter pete

我会在断言下面加上 while(vm.SaveCommand.Executing); 来验证操作是否完成。这样会让测试运行时间变长，但很可能会执行成功。 - Ron Beyer

啊！太好了，Ron提出的建议很棒。我喜欢它，确实很喜欢。请将它们作为答案回复 :) - Peter pete

Answer 1

您提出的建议很合理，正是Stephen Cleary创建的AsyncCommand实现所做的（他是我认为在异步代码方面最重要的专家之一）。

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

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;
    }
}

- Scott Chamberlain

---

哇塞，这似乎包含了所有东西，甚至包括厨房水槽！我同意这是一个看起来非常完整的实现，包括取消等功能。现在，我的问题是，我应该选择哪个答案作为正确答案？对于我的即时需求，也许我只需要测试用例中的while循环。但我理解这个答案最完整，最终解决了我的即时问题，也可能解决我未来遇到的所有问题。 - Peter pete

Answer 2

看起来答案是使用 AsyncCommand 对象的标志。在 CanExecute 方法中使用 AsyncCommand 的 Executing 标志，可以确保当另一个实例正在运行时用户无法执行命令。

此外，对于您的单元测试，您可以使用 while 循环使其在断言后等待：

while (vm.SaveCommand.Executing) ;

确保测试能够干净地退出。

- Ron Beyer

---

我认为这更加简洁，因为没有两个令人困惑的Execute方法。 - Peter pete

@SriramSakthivel 我不是在创建一个属性，它已经存在于 AsyncCommand 对象上，请查看问题的注释。 - Ron Beyer

@RonBeyer 在OP提供的链接中并没有。它只是一个私有字段。另外，请注意您必须将SaveCommand属性公开为AsyncCommand而不仅仅是ICommand。所以，在我看来最好添加另一种方法。 - Sriram Sakthivel

@SriramSakthivel：是的，它是一个私有字段，但我只是将其提升了。而且这是真的，我正在公开AsyncCommand而不是ICommand。但是，即使周围有Execute()和ExecuteAsync方法，我仍然需要公开AsyncCommand，以便我的单元测试可以看到ExecuteAsync，并等待它。 - Peter pete

我喜欢使用Executing/IsExecuting属性解决方案和循环，因为我还需要添加一些代码来强制调度程序进行操作，并且我可以在循环中完成这个过程。[https://dev59.com/q3NA5IYBdhLWcg3wEZaT] - Peter pete

Answer 3

其他答案的评论

使用while (vm.SaveCommand.Executing) ;看起来像是忙等待，我更倾向于避免这种情况。

另一种解决方案使用了Stephen Cleary的AsyncCommand，对于如此简单的任务来说，似乎有点过度设计。

我的建议不会破坏封装性——Save方法不会暴露任何内部细节。它只是提供了另一种访问相同功能的方式。

我的解决方案似乎以简单而直接的方式涵盖了所有需要的内容。

建议

我建议重构这段代码：

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);
    });

to:

SaveCommand = new RelayCommand(async param => await Save(param));

public async Task Save(object 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);
}

请注意：我将 AsyncCommand 更改为任何 MVVM 框架中都可以找到的 RelayCommand。它只接收一个操作作为参数，并在调用 ICommand.Execute 方法时运行该操作。

单元测试

我使用了支持 async 测试的 NUnit 框架来制作示例：

[Test]
public async Task MyViewModelWithAsyncCommandsTest()
{
    // Arrange
    // do view model initialization here

    // Act
    await vm.Save(param);

    // Assert
    // verify that what what you expected actually happened
}

然后在视图中像通常一样绑定命令：

Command="{Binding SaveCommand}"

- Igor Popov

---

我认为Stephen Cleary的方法是在您的视图模型中使用IAsyncCommand，然后在测试中使用await vm.SaveCommand.ExecuteAsync()。 （并非所有的AsyncCommand实现都有这个方法（例如DevExpress没有），但是Cleary的实现有。） - metal

只是一个小的补充：我会将Save方法标记为“internal”，并在YourAssembly的AssemblyInfo.cs中添加[assembly：InternalsVisibleTo（“YourAssembly.Tests”）]（其中Save方法存在）。我不太喜欢仅仅为了单元测试而将事物公开。 - thomasgalliker