wpf 异步命令

最新推荐文章于 2024-09-19 20:48:22 发布
最新推荐文章于 2024-09-19 20:48:22 发布
阅读量5.6k 收藏 6
点赞数


异步编程

针对异步 MVVM 应用程序的模式：命令

Stephen Cleary

下载代码示例

本文是关于将 async 和 await 与主流 Model-View-ViewModel (MVVM) 模式相结合的一系列文章中的第二篇。上次，我展示了如何数据绑定到异步操作，并开发了一个名为 NotifyTaskCompletion<TResult> 的键类型，其作用类似一个数据绑定友好型的 Task<TResult>（请参阅 msdn.microsoft.com/magazine/dn605875）。现在我将介绍 ICommand，这是一个 MVVM 应用程序用于定义用户操作（通常被数据绑定到按钮）的 .NET 接口，并探讨创建异步 ICommand 的意义。

此处的这些模式可能不会与所有情景完美契合，因此请根据需要进行调整。实际上，整篇文章以对异步命令类型的一系列改进为主线展开。在这些迭代过程的最后，您将最终获得如图 1 中所示的应用程序。这类似于我在上一篇文章中开发的应用程序，但这次，我为用户提供了要执行的实际命令。当用户单击“开始”按钮时，将从文本框读取 URL，并且该应用程序将对此 URL 上的字节数进行计数（人为设置的延迟之后）。在此操作正在进行时，用户无法启动另一个操作，但他能够取消此操作。






图 1：能够执行一个命令的应用程序

然后我将展示如何使用非常类似的方法创建任何数目的操作。图 2 显示了修改后的应用程序，“开始”按钮表示将操作添加到操作集中。


图 2：执行多个命令的应用程序

在开发此应用程序过程中，我将进行一些简化，以便将重点始终放在异步命令上，而不是实现细节上。首先，我不会使用命令执行参数。在真实应用程序中我几乎从不需要使用参数；但如果需要，本文中的模式可轻松进行扩展，将其包含在内。其次，我不亲自实现 ICommand.CanExecuteChanged。类似字段的标准事件将在某些 MVVM 平台上泄漏内存（请参阅 bit.ly/1bROnVj）。为使此代码保持简单，我使用 Windows Presentation Foundation (WPF) 内置的 CommandManager 来实现 CanExecuteChanged。

我还使用了简化的“服务层”，目前这只是一个静态方法，如图 3 所示。实际上该服务与我在上一篇文章中的服务相同，但进行了扩展，可支持取消操作。下一篇文章将采用适当的异步服务设计，但目前使用这个简化的服务即可。

图 3：服务层 


  
  
  1. public static class MyService
  2. {
  3.   // bit.ly/1fCnbJ2
  4.   public static async Task<int> DownloadAndCountBytesAsync(string url,
  5.     CancellationToken token = new CancellationToken())
  6.   {
  7.     await Task.Delay(TimeSpan.FromSeconds(3), token).ConfigureAwait(false);
  8.     var client = new HttpClient();
  9.     using (var response = await client.GetAsync(url, token).ConfigureAwait(false))
  10.     {
  11.       var data = await
  12.         response.Content.ReadAsByteArrayAsync().ConfigureAwait(false);
  13.       return data.Length;
  14.     }
  15.   }
  16. }

异步命令

开始前，迅速了解一下 ICommand 接口：


  
  
  1. public interface ICommand
  2. {
  3.   event EventHandler CanExecuteChanged;
  4.   bool CanExecute(object parameter);
  5.   void Execute(object parameter);
  6. }

忽略 CanExecuteChanged 和参数，稍微思考一下异步命令将如何使用此接口。CanExecute 方法必是同步的；唯一可为异步的成员是 Execute。Execute 方法是为同步实现设计的，因此其返回 void。正如我在上一篇文章“异步编程的最佳做法”（msdn.microsoft.com/magazine/jj991977）中所提到的，应避免 async void 方法，除非它们是事件处理程序（或者事件处理程序的逻辑对等物）。ICommand.Execute 的实现在逻辑上是事件处理程序，因此可以是 async void。

但最好尽量减少 async void 方法中的代码，而将一个包含实际逻辑的 async Task 方法公开。这种做法可使代码更容易测试。本着这一宗旨，我建议将以下作为异步命令接口，图 4 中的代码作为基类：


  
  
  1. public interface IAsyncCommand : ICommand
  2. {
  3.   Task ExecuteAsync(object parameter);
  4. }

图 4：异步命令的基类型 


  
  
  1. public abstract class AsyncCommandBase : IAsyncCommand
  2. {
  3.   public abstract bool CanExecute(object parameter);
  4.   public abstract Task ExecuteAsync(object parameter);
  5.   public async void Execute(object parameter)
  6.   {
  7.     await ExecuteAsync(parameter);
  8.   }
  9.   public event EventHandler CanExecuteChanged
  10.   {
  11.     add { CommandManager.RequerySuggested += value; }
  12.     remove { CommandManager.RequerySuggested -= value; }
  13.   }
  14.   protected void RaiseCanExecuteChanged()
  15.   {
  16.     CommandManager.InvalidateRequerySuggested();
  17.   }
  18. }

该基类负责两件事：它将 CanExecuteChanged 实现交给 CommandManager 类完成；通过调用 IAsyncCommand.ExecuteAsync 方法实现 async void ICommand.Execute 方法。它等待结果，以确保异步命令逻辑中的任何异常都将被正确提交到 UI 线程的主循环。

这颇为复杂，但其中每个类型都有一个用途。IAsyncCommand 可用于任何异步 ICommand 实现，其设计初衷是从 ViewModel 公开，供 View 和单元测试使用。AsyncCommandBase 提供所有异步 ICommand 公共的样板代码。

奠定了这一基础，我可以着手开始开发一个有效的异步命令。对于无返回值的同步操作，标准委托类型为 Action。异步对等物为 Func<Task>。图 5 显示了基于委托的 AsyncCommand 的第一次迭代。

图 5：对异步命令的第一次尝试 


  
  
  1. public class AsyncCommand : AsyncCommandBase
  2. {
  3.   private readonly Func<Task> _command;
  4.   public AsyncCommand(Func<Task> command)
  5.   {
  6.     _command = command;
  7.   }
  8.   public override bool CanExecute(object parameter)
  9.   {
  10.     return true;
  11.   }
  12.   public override Task ExecuteAsync(object parameter)
  13.   {
  14.     return _command();
  15.   }
  16. }

此时，UI 只有显示 URL 的文本框、启动 HTTP 请求的按钮，以及用于显示结果的标签。XAML 和 ViewModel 的基本部分很简单。以下为 Main­Window.xaml（跳过定位属性，例如 Margin）：

<Grid>
  <TextBox Text="{Binding Url}" />
  <Button Command="{Binding CountUrlBytesCommand}" 
      Content="Go" />
  <TextBlock Text="{Binding ByteCount}" />
</Grid>

图 6 显示了 MainWindowViewModel.cs。

图 6：第一个 MainWindowViewModel 


  
  
  1. public sealed class MainWindowViewModel : INotifyPropertyChanged
  2. {
  3.   public MainWindowViewModel()
  4.   {
  5.     Url = "http://www.example.com/";
  6.     CountUrlBytesCommand = new AsyncCommand(async () =>
  7.     {
  8.       ByteCount = await MyService.DownloadAndCountBytesAsync(Url);
  9.     });
  10.   }
  11.   public string Url { get; set; } // Raises PropertyChanged
  12.   public IAsyncCommand CountUrlBytesCommand { get; private set; }
  13.   public int ByteCount { get; private set; } // Raises PropertyChanged
  14. }

如果您执行该应用程序（示例代码下载中的 AsyncCommands1），您将注意到四种不良行为情况。第一，标签始终显示结果，甚至在单击按钮之前。第二，单击按钮后没有忙碌状态指示器来指示操作正在进行。第三，如果 HTTP 请求失败，则会将异常传递到 UI 主循环，从而导致应用程序崩溃。第四，如果用户做出了多个请求，则该用户无法辨别结果；由于服务器响应时间的不确定性，较早请求的结果可能覆盖较晚请求的结果。

这是一连串的问题！但在我迭代此设计之前，暂时考虑一下引发的问题的类型。当 UI 变成异步时，您不得不考虑 UI 中的额外状态。我建议您至少问自己三个问题：

  1. 此 UI 将如何显示错误？（我希望您的同步 UI 已经对此有了答案！）
  2. 当操作正在进行时，此 UI 的外观应如何？（例如，它是否将通过忙碌状态指示器及时提供反馈？）
  3. 当操作正在进行时，用户受到哪些限制？（例如，按钮是否禁用？）
  4. 当操作正在进行时，用户是否可发出额外命令？（例如，他能否取消操作？）
  5. 如果用户能够启动多个操作，UI 如何为每个操作提供完成或错误详细信息？（例如，UI 将使用“命令队列”样式还是弹出通知？）

通过数据绑定完成异步命令

第一个 Async­Command 迭代中的大部分问题与如何处理结果有关。真正需要的是找到某种类型，该类型包装 Task<T> 并提供一些数据绑定功能，使应用程序能够顺畅响应。幸好，在我的上一篇文章中开发的 NotifyTaskCompletion<T> 类型几乎完美地符合这些需求。我将在该类型中添加一个成员，以简化一些 Async­Command 逻辑：TaskCompletion 属性，表示操作完成，但不传播异常（或返回结果）。以下是对 NotifyTaskCompletion<T> 的修改：


  
  
  1. public NotifyTaskCompletion(Task<TResult> task)
  2. {
  3.   Task = task;
  4.   if (!task.IsCompleted)
  5.     TaskCompletion = WatchTaskAsync(task);
  6. }
  7. public Task TaskCompletion { get; private set; }

AsyncCommand 的下一迭代使用 NotifyTaskCompletion 来表示实际操作。这样一来，XAML 能够直接数据绑定到操作的结果和错误消息，并且在操作正在进行的过程中，还可使用数据绑定来显示相应的消息。新 AsyncCommand 现在具有表示实际操作的属性，如图 7 所示。

图 7：异步命令的第二次尝试 


  
  
  1. public class AsyncCommand<TResult> : AsyncCommandBase, INotifyPropertyChanged
  2. {
  3.   private readonly Func<Task<TResult>> _command;
  4.   private NotifyTaskCompletion<TResult> _execution;
  5.   public AsyncCommand(Func<Task<TResult>> command)
  6.   {
  7.     _command = command;
  8.   }
  9.   public override bool CanExecute(object parameter)
  10.   {
  11.     return true;
  12.   }
  13.   public override Task ExecuteAsync(object parameter)
  14.   {
  15.     Execution = new NotifyTaskCompletion<TResult>(_command());
  16.     return Execution.TaskCompletion;
  17.   }
  18.   // Raises PropertyChanged
  19.   public NotifyTaskCompletion<TResult> Execution { get; private set; }
  20. }

注意，AsyncCommand.ExecuteAsync 使用 TaskCompletion，而不是 Task。我不想将异常传播回 UI 主循环（如果其等待 Task 属性，则会发生这种情况）；而是通过数据绑定返回 TaskCompletion 并处理异常。我还在项目中添加了一个简单的 NullToVisibilityConverter，这样，忙碌状态指示器、结果和错误消息在单击按钮前都是隐藏的。图 8 显示了更新的 ViewModel 代码。

图 8：第二个 MainWindowViewModel 


  
  
  1. public sealed class MainWindowViewModel : INotifyPropertyChanged
  2. {
  3.   public MainWindowViewModel()
  4.   {
  5.     Url = "http://www.example.com/";
  6.     CountUrlBytesCommand = new AsyncCommand<int>(() => 
  7.       MyService.DownloadAndCountBytesAsync(Url));
  8.   }
  9.   // Raises PropertyChanged
  10.   public string Url { get; set; }
  11.   public IAsyncCommand CountUrlBytesCommand { get; private set; }
  12. }

图 9 显示了新 XAML 代码。

图 9：第二个 MainWindow XAML 

<Grid>
  <TextBox Text="{Binding Url}" />
  <Button Command="{Binding CountUrlBytesCommand}" Content="Go" />
  <Grid Visibility="{Binding CountUrlBytesCommand.Execution,
    Converter={StaticResource NullToVisibilityConverter}}">
    <!--Busy indicator-->
    <Label Visibility="{Binding CountUrlBytesCommand.Execution.IsNotCompleted,
      Converter={StaticResource BooleanToVisibilityConverter}}"
      Content="Loading..." />
    <!--Results-->
    <Label Content="{Binding CountUrlBytesCommand.Execution.Result}"
      Visibility="{Binding CountUrlBytesCommand.Execution.IsSuccessfullyCompleted,
      Converter={StaticResource BooleanToVisibilityConverter}}" />
    <!--Error details-->
    <Label Content="{Binding CountUrlBytesCommand.Execution.ErrorMessage}"
      Visibility="{Binding CountUrlBytesCommand.Execution.IsFaulted,
      Converter={StaticResource BooleanToVisibilityConverter}}" Foreground="Red" />
  </Grid>
</Grid>

现在，此代码匹配示例代码中的 AsyncCommands2 项目。此代码负责解决初始解决方案中提及的所有问题：在第一个操作开始前，标签是隐藏的；有一个直接的忙碌状态指示器为用户提供反馈；捕获了异常，并且通过数据绑定更新了 UI；多个请求不再互相干扰。每个请求均创建一个新的 NotifyTaskCompletion 包装，其具有自己的独立 Result 和其他属性。NotifyTaskCompletion 作为异步操作的可数据绑定抽象。这允许多个请求，同时 UI 始终绑定到最新请求。但在许多真实情况中，相应解决方案是禁用多个请求。即，要在操作正在进行时让命令从 CanExecute 返回 false。对 AsyncCommand 进行些许修改即可，如图 10 所示。

图 10：禁用多个请求 


  
  
  1. public class AsyncCommand<TResult> : AsyncCommandBase, INotifyPropertyChanged
  2. {
  3.   public override bool CanExecute(object parameter)
  4.   {
  5.     return Execution == null || Execution.IsCompleted;
  6.   }
  7.   public override async Task ExecuteAsync(object parameter)
  8.   {
  9.     Execution = new NotifyTaskCompletion<TResult>(_command());
  10.     RaiseCanExecuteChanged();
  11.     await Execution.TaskCompletion;
  12.     RaiseCanExecuteChanged();
  13.   }
  14. }

现在，此代码匹配示例代码中的 AsyncCommands3 项目。此按钮在操作进行过程中被禁用。

添加取消

许多异步操作所用的时间量可能不同。例如，HTTP 请求通常可能非常快速地做出响应，甚至快于用户响应。但如果网络较慢，或者服务器繁忙，同一 HTTP 请求可能会导致相当长的延迟。设计异步 UI 的部分原因就是针对这种情况。当前解决方案已经具有忙碌状态指示器。设计异步 UI 时，您可能还选择为用户提供更多选择，取消操作是一个常见选择。

取消本身始终是同步操作 — 请求取消的行为需立即执行。取消的最棘手部分是它何时运行；应仅在异步命令正在进行时才能够执行。对图 11 中 AsyncCommand 的修改提供了嵌套的取消命令，并且在异步命令开始和结束时会发出该取消命令的通知。

图 11：添加取消 


  
  
  1. public class AsyncCommand<TResult> : AsyncCommandBase, INotifyPropertyChanged
  2. {
  3.   private readonly Func<CancellationToken, Task<TResult>> _command;
  4.   private readonly CancelAsyncCommand _cancelCommand;
  5.   private NotifyTaskCompletion<TResult> _execution;
  6.   public AsyncCommand(Func<CancellationToken, Task<TResult>> command)
  7.   {
  8.     _command = command;
  9.     _cancelCommand = new CancelAsyncCommand();
  10.   }
  11.   public override async Task ExecuteAsync(object parameter)
  12.   {
  13.     _cancelCommand.NotifyCommandStarting();
  14.     Execution = new NotifyTaskCompletion<TResult>(_command(_cancelCommand.Token));
  15.     RaiseCanExecuteChanged();
  16.     await Execution.TaskCompletion;
  17.     _cancelCommand.NotifyCommandFinished();
  18.     RaiseCanExecuteChanged();
  19.   }
  20.   public ICommand CancelCommand
  21.   {
  22.     get { return _cancelCommand; }
  23.   }
  24.   private sealed class CancelAsyncCommand : ICommand
  25.   {
  26.     private CancellationTokenSource _cts = new CancellationTokenSource();
  27.     private bool _commandExecuting;
  28.     public CancellationToken Token { get { return _cts.Token; } }
  29.     public void NotifyCommandStarting()
  30.     {
  31.       _commandExecuting = true;
  32.       if (!_cts.IsCancellationRequested)
  33.         return;
  34.       _cts = new CancellationTokenSource();
  35.       RaiseCanExecuteChanged();
  36.     }
  37.     public void NotifyCommandFinished()
  38.     {
  39.       _commandExecuting = false;
  40.       RaiseCanExecuteChanged();
  41.     }
  42.     bool ICommand.CanExecute(object parameter)
  43.     {
  44.       return _commandExecuting && !_cts.IsCancellationRequested;
  45.     }
  46.     void ICommand.Execute(object parameter)
  47.     {
  48.       _cts.Cancel();
  49.       RaiseCanExecuteChanged();
  50.     }
  51.   }
  52. }

将“取消”按钮（和取消的标签）添加到 UI 十分简单，如图 12 所示。

图 12：添加“取消”按钮 

<Grid>
  <TextBox Text="{Binding Url}" />
  <Button Command="{Binding CountUrlBytesCommand}" Content="Go" />
  <Button Command="{Binding CountUrlBytesCommand.CancelCommand}" Content="Cancel" />
  <Grid Visibility="{Binding CountUrlBytesCommand.Execution,
    Converter={StaticResource NullToVisibilityConverter}}">
    <!--Busy indicator-->
    <Label Content="Loading..."
      Visibility="{Binding CountUrlBytesCommand.Execution.IsNotCompleted,
      Converter={StaticResource BooleanToVisibilityConverter}}" />
    <!--Results-->
    <Label Content="{Binding CountUrlBytesCommand.Execution.Result}"
      Visibility="{Binding CountUrlBytesCommand.Execution.IsSuccessfullyCompleted,
      Converter={StaticResource BooleanToVisibilityConverter}}" />
    <!--Error details-->
    <Label Content="{Binding CountUrlBytesCommand.Execution.ErrorMessage}"
      Visibility="{Binding CountUrlBytesCommand.Execution.IsFaulted,
      Converter={StaticResource BooleanToVisibilityConverter}}" Foreground="Red" />
    <!--Canceled-->
    <Label Content="Canceled"
      Visibility="{Binding CountUrlBytesCommand.Execution.IsCanceled,
      Converter={StaticResource BooleanToVisibilityConverter}}" Foreground="Blue" />
  </Grid>
</Grid>

现在，如果您执行该应用程序（示例代码中的 AsyncCommands4），您将发现“取消”按钮最初被禁用。当您单击“开始”按钮时会启用该按钮，并且其启用状态会一直保持到操作完成为止（无论成功、失败还是取消）。您现在拥有了可以说是完整的异步操作 UI。

简单工作队列

到目前为止，我一直在着重探讨一次只针对一个操作的 UI。在许多情况下这些都是必要的，但有时您需要能够启动多个异步操作。我认为，作为一个社区，我们尚未拥有用于处理多个异步操作的真正好的 UX。两个常用方法是使用工作队列或通知系统，但这两个方法都不理想。

工作队列显示集合中的所有异步操作；这会为用户提供最大的可见性和控制，但对于典型最终用户来说处理起来太过复杂。通知系统会在操作正在运行时隐藏它们，如果其中任何一个操作失败，该系统都会弹出通知（当它们成功完成时也可能弹出通知）。通知系统更便于用户使用，但它不提供全面可见性和工作队列的功能）（例如，难以将取消插入基于通知的系统中）。我必须找到可处理多个异步操作的理想 UX。

也就是说，此时可扩展示例代码，以便不太困难地支持多操作情况。在现有代码中，“开始”按钮和“取消”按钮在概念上均与单一异步操作相关。新 UI 将更改“开始”按钮，使其表示“启动一个新异步操作并将其添加到操作列表中”。这意味着“开始”按钮现在实际上是同步的。我将一个简单（同步）的 DelegateCommand 添加到了解决方案中，现在可更新 ViewModel 和 XAML，如图 13 和图 14 所示。

图 13：用于多个命令的 ViewModel 


  
  
  1. public sealed class CountUrlBytesViewModel
  2. {
  3.   public CountUrlBytesViewModel(MainWindowViewModel parent, string url,
  4.     IAsyncCommand command)
  5.   {
  6.     LoadingMessage = "Loading (" + url + ")...";
  7.     Command = command;
  8.     RemoveCommand = new DelegateCommand(() => parent.Operations.Remove(this));
  9.   }
  10.   public string LoadingMessage { get; private set; }
  11.   public IAsyncCommand Command { get; private set; }
  12.   public ICommand RemoveCommand { get; private set; }
  13. }
  14. public sealed class MainWindowViewModel : INotifyPropertyChanged
  15. {
  16.   public MainWindowViewModel()
  17.   {
  18.     Url = "http://www.example.com/";
  19.     Operations = new ObservableCollection<CountUrlBytesViewModel>();
  20.     CountUrlBytesCommand = new DelegateCommand(() =>
  21.     {
  22.       var countBytes = new AsyncCommand<int>(token =>
  23.         MyService.DownloadAndCountBytesAsync(
  24.         Url, token));
  25.       countBytes.Execute(null);
  26.       Operations.Add(new CountUrlBytesViewModel(this, Url, countBytes));
  27.     });
  28.   }
  29.   public string Url { get; set; } // Raises PropertyChanged
  30.   public ObservableCollection<CountUrlBytesViewModel> Operations
  31.     { get; private set; }
  32.   public ICommand CountUrlBytesCommand { get; private set; }
  33. }

图 14：用于多个命令的 XAML 

<Grid>
  <TextBox Text="{Binding Url}" />
  <Button Command="{Binding CountUrlBytesCommand}" Content="Go" />
  <ItemsControl ItemsSource="{Binding Operations}">
    <ItemsControl.ItemTemplate>
      <DataTemplate>
        <Grid>
          <!--Busy indicator-->
          <Label Content="{Binding LoadingMessage}"
            Visibility="{Binding Command.Execution.IsNotCompleted,
            Converter={StaticResource BooleanToVisibilityConverter}}" />
          <!--Results-->
          <Label Content="{Binding Command.Execution.Result}"
            Visibility="{Binding Command.Execution.IsSuccessfullyCompleted,
            Converter={StaticResource BooleanToVisibilityConverter}}" />
          <!--Error details-->
          <Label Content="{Binding Command.Execution.ErrorMessage}"
            Visibility="{Binding Command.Execution.IsFaulted,
            Converter={StaticResource BooleanToVisibilityConverter}}"
            Foreground="Red" />
          <!--Canceled-->
          <Label Content="Canceled"
            Visibility="{Binding Command.Execution.IsCanceled,
            Converter={StaticResource BooleanToVisibilityConverter}}"
            Foreground="Blue" />
          <Button Command="{Binding Command.CancelCommand}" Content="Cancel" />
          <Button Command="{Binding RemoveCommand}" Content="X" />
        </Grid>
      </DataTemplate>
    </ItemsControl.ItemTemplate>
  </ItemsControl>
</Grid>

此代码等同于示例代码中的 AsyncCommandsWithQueue 项目。当用户单击“开始”按钮时，将创建一个新 AsyncCommand，并且会将其包装到子 ViewModel (CountUrlBytesViewModel) 中。然后该子 ViewModel 实例会被添加到操作列表中。与这个特殊操作相关联的所有信息（各个标签和“取消”按钮）显示在工作队列的数据模板中。我还添加了一个简单的按钮“X”，该按钮会将项目从队列中移除。

这是一个非常基本的工作队列，我做出了一些有关设计的假设。例如，在将操作从队列中移除时，不会自动取消此操作。当您开始使用多个异步操作时，我建议您最少问自己三个额外问题：

  1. 用户如何知道哪个通知或工作项针对哪个操作？（例如，在该工作队列示例中的忙碌状态指示器包含其正在下载的 URL）。
  2. 用户是否需要知道每个结果？（例如，仅通知用户错误即可，或者自动将成功操作从工作队列中移除）。

总结

目前对于异步命令还没有适合每个人需求的通用解决方案。开发者社区仍在探索异步 UI 模式。在本文中，我的目标是展示如何在 MVVM 应用程序上下文中考虑异步命令，尤其是考虑在 UI 变为异步时必须解决的 UX 问题。但记住，本文以及示例代码中的模式只是范例，应根据应用程序的需求调整它们。

特别要指出的是，关于多个异步操作还没有完美案例。工作队列和通知都有弊端，在我看来今后应有通用的 UX。当更多 UI 变为异步时，将会有更多人思考该问题，革命性的突破可能会马上出现。亲爱的读者，请谈谈您对该问题的想法。或许您将是新 UX 的发现者。

另外可别忘了发布。在本文中，我从最基本的异步 ICommand 实现开始，然后逐渐添加功能，最后得到适用于大多数新型应用程序的结果。其结果还完全可进行单元测试；由于 async void ICommand.Execute 方法仅调用返回任务的 IAsyncCommand.ExecuteAsync 方法，因此您可以在单元测试中直接使用 ExecuteAsync。

在我的上一篇文章中，我开发了 NotifyTaskCompletion<T>，这是围绕 Task<T> 的一个数据绑定包装。在这篇文章中，我展示了如何开发 AsyncCommand<T> 的一个类型，即，ICommand 的异步实现。在我的下一篇文章中，我将涉及异步服务。请记住，异步 MVVM 模式仍是非常新的概念；不要担心违背它们，革新您自己的解决方案。

Stephen Cleary 生活在密歇根州北部，他是一位丈夫、父亲和程序员。他已从事了 16 年的多线程和异步编程工作，自第一个 CTP 以来便在使用 Microsoft .NET Framework 中的异步支持。他的主页（包括博客）位于 stephencleary.com。

衷心感谢以下 Microsoft 技术专家对本文的审阅：James McCaffrey 和 Stephen Toub

 

连环炮
关注
WPF异步加载DataGrid
08-08
WPF制作的DataGrid异步加载程序，使用MVVM设计模式
【WPF】使用异步任务来执行耗时的操作，保持UI的响应性。
资深全栈开发工程师
12-07 2263
这些方法都可以实现后台执行耗时操作，并在操作完成后切换回UI线程以进行操作结果的处理。具体使用哪种方法，取决于你的需求和个人偏好。方法将操作切换回UI线程。这样可以避免在多个线程上同时访问UI元素而导致的线程安全问题。需要注意的是，在异步任务中访问UI元素时，应使用。WPF提供了多种方法来实现异步任务，包括使用。希望以上信息对你有所帮助！
WPF 异步
最新发布
m0_58717895的博客
09-19 1054
WPF 中的异步操作通过asyncawait和Task类实现，能够防止 UI 冻结，提升用户体验。异步任务中的 UI 更新需要通过Dispatcher切换到 UI 线程。和分别提供了任务取消和进度报告的支持。使用异步编程可以更高效地处理 I/O 密集型任务和计算密集型任务，同时保持 UI 的响应性。
WPF 异步编程
yh_belief
04-29 1437
WPF 异步编程在C#5.0引入”async”和”await”关键字，使异步编程变得更轻松. APM 异步编程模型，Asynchronous Programming Model EAP 基于事件的异步编程模式，Event-based Asynchronous Pattern TAP 基于任务的异步编程模式，Task-
WPF 异步(转)
csdn_aspnet的专栏
12-18 2343
 【WPF】请注意一个 异步绑定 的陷阱！ WPF的异步绑定在很大程度上简化了延迟较大的绑定操作，大大提高了生产力。但在这个糖果里存在一个天大的陷阱。 如果你不能发现这个陷阱，轻则导致延迟严重，重则导致程序崩溃。 请看第一个案例：  Image Source="http://images.cnblogs.com/adminlogo.gif" /> 这段代码贴入VS2010以
WPF 异步线程
weixin_44538156的博客
09-17 1035
下面代码实现了在WPF中如何进行多任务同时执行。使用MVVM框架。 View层按钮代码 <local:ButtonEx Content="开始" Width="120" ButtonType="Normal" Height="55" Foreground="White" FontSize="20" Command="{Binding StartingTestCommand}" Grid.Column="0" CommandParameter="{Binding ElementName=startBu
WPF 简单命令DEMO
10-16
**WPF简单命令DEMO** 在Windows Presentation Foundation（WPF）框架中，命令是实现用户界面（UI...在实际开发中，你可能会遇到更复杂的命令需求，如参数传递、异步执行等，但这个DEMO已经足够展示WPF命令的基本用法。
异步等待窗口
09-14
异步等待窗口是一种在计算机程序设计中用于提升用户体验的技术，特别是在执行长时间运行操作时。它通常会在后台执行任务，同时显示一个窗口，让用户知道程序正在处理数据，避免用户感到程序无响应。这样的机制有助于...
WPF 使用 SharpDx 异步渲染
lindexi
06-29 2219
本文告诉大家如何通过 SharpDx 进行异步渲染，但是因为在 WPF 是需要使用 D3DImage 画出来，所以渲染只是画出图片，最后的显示还是需要 WPF 在他自己的主线程渲染
WPF xaml Command用法介绍
琅嬛福地
11-15 398
WPF (Windows Presentation Foundation) 中的命令设计模式是一种用于分离用户界面逻辑和业务逻辑的方法。在WPF中，这种模式通过命令接口（如ICommand）实现，使得用户界面组件（如按钮、菜单项等）可以触发不直接与它们相关的逻辑操作。
【WPF】AsyncCommand的实现
mccoy39082的博客
10-20 1232
1. AsyncCommand和AsyncCommand<TResult>类： public static class AsyncCommand { public static AsyncCommand<object> Create(Func<Task> command) { return new AsyncCommand<object>(async _ => { await command(); return nul
C# WPF 异步编程详细使用教程与注意事项
weixin_39604653的博客
09-06 1259
在 C# 和 WPF 应用程序中，异步编程的主要目的是避免阻塞用户界面（UI）线程，确保应用程序在执行耗时操作时（例如文件操作、网络请求或数据库查询）仍然保持响应。WPF 提供了良好的异步支持，可以使用 async 和 await 关键字来编写异步代码，确保不会阻塞 UI 线程。
WPF 异步执行
weixin_34087503的博客
01-12 618
  private void Operate_OnClick(object sender, RoutedEventArgs e) { AsyncFindBox(); RadWindow.Alert("测试测试！"); } private void AsyncFindBox() { #region 需要将返回结果返回到UI上。 //异步任...
WPF中异步操作
Yuanben_wuxin的博客
12-07 3121
在WPF中直接开辟一个线程执行异步操作时，如果与UI界面有交互则会直接报错，此时我们使用如下方法实现异步操作 private void checkoutOnLine() { Dispatcher.BeginInvoke(DispatcherPriority.SystemIdle, new Action(() =&gt; ...
WPF：在异步操作中使用CommandManager手动更新Command执行状态（转载）
weixin_30455661的博客
05-09 287
WPF判断命令（Command）是否能够执行是通过ICommand.CanExecute事件，在实际程序中路由命令一般是通过CommandBinding来使命令得到实际操作代码，但是这个CanExecute事件的调用是由WPF控制的，有些时候，比如命令执行后进行一些异步耗时操作，操作完成后会影响CanExecute事件结果，但是WPF不会立即做出反应，那么这个时侯就需要手动调用Comm...
wpf 异步操作
qiaoqiaodidaqiang的专栏
06-07 766
new Thread(() => { this.Dispatcher.BeginInvoke(new Action(() => { //添加操作 })); }).Start();public partial class
WPF 异步调用
一切皆有联系
05-20 6876
次线程不能直接修改主线程UI的界面，需要使用以下方法方法1： this.Dispatcher.Invoke(DispatcherPriority.Normal, new Action(() => { //调用主线程UI的的代码 }
WPF 实现异步调用
曾俊的博客
10-21 3457
在WPF中，实现异步调用的代码如下： System.Windows.Threading.Dispatcher.Invoke( new Action(()=> { CallMethodName(); //要异步调用的方法或异步执行的语句 }), System.Windows.Threading.DispatcherPriority.Background);
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值