我一直在谷歌搜索甚至 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/