基于MVVM实现按钮点击调用异步方法并支持取消的方案

我明白你想实现一个绑定到按钮的异步命令，支持启动和取消操作，而且不想引入第三方库——完全可以基于你已经写的接口和基类来改造，不用从头搭建新框架。咱们一步步来解决问题：

1. 先解决CommandManager相关的问题 #

你提到AsyncCommandBase里的ICanExecuteChanged和CommandManager的问题，首先咱们补全ICanExecuteChanged接口的定义（你之前的代码里引用了但没贴出来），然后实现一个基于WPF CommandManager的版本，这样就能自动处理命令可用性的更新：

using System;
using System.Windows.Input;

namespace Data
{
    public interface ICanExecuteChanged
    {
        event EventHandler CanExecuteChanged;
        void OnCanExecuteChanged();
    }

    // 基于CommandManager的实现，自动触发命令状态更新
    public class CommandManagerCanExecuteChanged : ICanExecuteChanged
    {
        private readonly ICommand _command;

        public CommandManagerCanExecuteChanged(ICommand command)
        {
            _command = command;
        }

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

        public void OnCanExecuteChanged()
        {
            CommandManager.InvalidateRequerySuggested();
        }
    }
}

然后修改你的AsyncCommandBase，给它加一个默认构造函数，自动使用上面的实现，这样就不用手动传入工厂了：

using System;
using System.Threading.Tasks;
using System.Windows.Input;

namespace Data
{
    public abstract class AsyncCommandBase : IAsyncCommand
    {
        private readonly ICanExecuteChanged _canExecuteChanged;

        // 默认构造函数，自动使用CommandManager的实现
        protected AsyncCommandBase() : this(cmd => new CommandManagerCanExecuteChanged(cmd))
        {
        }

        protected AsyncCommandBase(Func<object, ICanExecuteChanged> canExecuteChangedFactory)
        {
            _canExecuteChanged = canExecuteChangedFactory(this);
        }

        public abstract Task ExecuteAsync(object parameter);
        protected abstract bool CanExecute(object parameter);

        protected void OnCanExecuteChanged()
        {
            _canExecuteChanged.OnCanExecuteChanged();
        }

        event EventHandler ICommand.CanExecuteChanged
        {
            add => _canExecuteChanged.CanExecuteChanged += value;
            remove => _canExecuteChanged.CanExecuteChanged -= value;
        }

        bool ICommand.CanExecute(object parameter) => CanExecute(parameter);

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

2. 实现支持取消的具体AsyncCommand类 #

接下来咱们写一个具体的命令类，加入CancellationTokenSource来管理取消逻辑，同时跟踪命令的执行状态（防止重复点击）：

using System;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Input;

namespace Data
{
    public class AsyncCommand : AsyncCommandBase
    {
        private readonly Func<object, CancellationToken, Task> _executeAsync;
        private readonly Func<object, bool> _canExecute;
        private CancellationTokenSource _cts;
        private bool _isExecuting;

        // 构造函数：传入带取消令牌的异步执行逻辑，可选传入可用性判断逻辑
        public AsyncCommand(Func<object, CancellationToken, Task> executeAsync, Func<object, bool> canExecute = null)
        {
            _executeAsync = executeAsync ?? throw new ArgumentNullException(nameof(executeAsync));
            _canExecute = canExecute ?? (_ => true);
        }

        // 跟踪命令是否正在执行，用来控制按钮可用性
        public bool IsExecuting
        {
            get => _isExecuting;
            private set
            {
                if (_isExecuting != value)
                {
                    _isExecuting = value;
                    OnCanExecuteChanged(); // 状态变化时触发命令可用性更新
                }
            }
        }

        // 取消命令的方法
        public void Cancel()
        {
            _cts?.Cancel();
        }

        protected override bool CanExecute(object parameter)
        {
            // 只有当命令未执行，且自定义的可用性判断通过时，才允许执行
            return !IsExecuting && _canExecute(parameter);
        }

        public override async Task ExecuteAsync(object parameter)
        {
            if (!CanExecute(parameter))
                return;

            IsExecuting = true;
            _cts = new CancellationTokenSource();

            try
            {
                // 传入取消令牌，让异步操作可以响应取消
                await _executeAsync(parameter, _cts.Token);
            }
            catch (OperationCanceledException)
            {
                // 这里可以处理取消后的逻辑，比如提示用户操作已取消
            }
            finally
            {
                // 清理资源，重置状态
                _cts.Dispose();
                _cts = null;
                IsExecuting = false;
            }
        }
    }
}

3. 在ViewModel中使用示例 #

现在你可以在ViewModel里创建命令，绑定到UI按钮了。比如下面的例子：

using System;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Input;

namespace YourViewModelNamespace
{
    public class MyViewModel
    {
        public AsyncCommand LongRunningCommand { get; }
        public ICommand CancelCommand { get; }

        public MyViewModel()
        {
            // 初始化异步命令，传入你的异步操作逻辑
            LongRunningCommand = new AsyncCommand(ExecuteLongRunningOperation);
            // 取消命令，绑定到另一个按钮或者同一个按钮的切换逻辑
            CancelCommand = new RelayCommand(() => LongRunningCommand.Cancel());
        }

        // 你的异步操作逻辑，注意接收CancellationToken参数来响应取消
        private async Task ExecuteLongRunningOperation(object parameter, CancellationToken token)
        {
            // 示例：模拟一个耗时操作，每1秒检查一次取消状态
            for (int i = 0; i < 10; i++)
            {
                // 如果取消请求已触发，抛出异常终止操作
                token.ThrowIfCancellationRequested();
                
                await Task.Delay(1000, token);
                // 这里可以更新UI绑定的属性，比如进度值
                // ProgressValue = i * 10;
            }
        }
    }

    // 简单的同步RelayCommand实现（如果你的项目里没有的话）
    public class RelayCommand : ICommand
    {
        private readonly Action _execute;
        private readonly Func<bool> _canExecute;

        public RelayCommand(Action execute, Func<bool> canExecute = null)
        {
            _execute = execute ?? throw new ArgumentNullException(nameof(execute));
            _canExecute = canExecute ?? (() => true);
        }

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

        public bool CanExecute(object parameter) => _canExecute();

        public void Execute(object parameter) => _execute();
    }
}

4. 关键说明 #

• 取消逻辑：每次执行命令时都会创建新的CancellationTokenSource，调用Cancel()方法会触发令牌的取消信号，你的异步操作需要在适当的位置检查这个令牌（比如用token.ThrowIfCancellationRequested()）。
• 按钮可用性：IsExecuting属性会自动控制按钮是否可点击，避免重复触发异步操作。
• 无需第三方库：所有代码都是基于WPF原生的ICommand和CommandManager实现的，不用引入任何额外库。

这样改造后，你就能实现点击按钮触发异步函数，并且支持取消功能了。

内容的提问来源于stack exchange，提问作者user12609036