从 SQL 服务器数据库返回异步列表并在数据网格 WPF 应用程序中使用

Question

我目前正面临一种非常奇怪的行为，我不确定我是否做错了什么，但这就是问题所在。

我尝试使用 Prism 从存储库异步返回列表并将其加载到 WPF 应用程序中的数据网格中。 当我同步返回列表时，它加载得很好，但是一旦我使用它异步程序运行，但界面不会显示并且不会触发错误。

如果您需要更多信息，请不要犹豫 - 提前致谢。

这是代码 - 为简单起见缩短：

风景

<UserControl>
    <Grid>
        <DataGrid ItemsSource="{Binding Products}" />
    </Grid>
</UserControl>

视图model：

public class ProductViewModel : BindableBase, INavigationAware
{
    private readonly IProductRepo _repo = new ProductRepo();

    public ObservableCollection<Data.Models.Product> Products { get; set; }
    
    public ProductViewModel()
    {
        Products = new ObservableCollection<Data.Models.Product>(this._repo.GetAll().Result);
    }
}

DbContext ：

public class ApplicationDbContext : DbContext
{
    public ApplicationDbContext()
    {
    }

    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options) : base(options)
    {
    }

    public DbSet<Product> Products { get; set; }
}

IProductRepo接口：

public interface IProductRepo
{
    Task<List<Product>> GetAll();
}

实现IProductRepo接口的ProductRepo class：

public class ProductRepo : IProductRepo
{
    private readonly ApplicationDbContext _context;

    public ProductRepo()
    {
        this._context = new ApplicationDbContext();
    }

    public async Task<List<Product>> GetAll()
    {
        return await this._context.Products.ToListAsync();
    }
}

我试图在视图 model 中创建一个异步私有方法来加载数据，然后在构造函数中调用 function，但这不起作用。

public void LoadData()
{
    List<Data.Models.Product> ProductFromDB = this._repo.GetAll().Result;

    foreach (var p in ProductFromDB)
    {
        Products.Add(p);
    }
}

Answer 1

如果您真的认为需要在初始化时加载所有数据，那么一个简单的解决方案是从视图加载数据。

关键是在异步方法上调用Task.Result很可能会导致死锁。
此外，长时间运行的构造函数可能会干扰甚至破坏控件 (UI) 的初始化例程。
此外，不等待async方法将导致未定义的行为，因为调用者的上下文继续执行，而async方法仍在运行并等待返回。
例如，调用者现在可以过早地离开方法 scope 并且async方法永远不会返回。

确保构造函数快速返回且重量轻不仅仅是最佳实践。 他们不应该分配昂贵的资源，也不应该启动后台线程，这通常会让调用者感到惊讶。
除了将其实例成员初始化为合理的默认值外，构造函数并不意味着执行任何类型的操作。 即使是高级实例配置也应该在构造函数之外进行。

另请注意， ToList或ToListAsync将强制在客户端评估查询。 这会严重损害应用程序性能，尤其是当表很大时。 另一方面，数据库经过高度优化，可以高效地执行查询，这使得服务器端查询评估变得有利。
由于您只是获取完整的表格，因此在您的场景中并不重要。 但在高级查询的情况下，它可以有所作为。

以下示例显示如何从视图执行异步初始化。 根据具体情况，可以应用其他解决方案。
该示例假设ProductViewModel由主视图 model class 创建和公开。但是调用者无关紧要。 只需让创建实例的控件调用长时间运行的初始化例程：

IInitializable.cs
引入专用接口甚至允许在应用程序组合中匿名调用所有async和长时间运行的初始化例程，例如在依赖注入上下文中。
这通常适用于任何组合上下文，例如当使用组合来管理类的层次结构时。
在这个例子中，所有视图模型的组合根将是主视图 model class。

public interface IInitializable
{
  Task<bool> InitializeAsync();
  bool IsInitialized { get; }
}

ProductViewModel.cs

public class ProductViewModel : BindableBase, INavigationAware, IInitializable
{
  private readonly IProductRepo _repo = new ProductRepo();

  public ObservableCollection<Data.Models.Product> Products { get; }
  public bool IsInitialized { get; private set; }
    
  public ProductViewModel()
  {
    // Only initialize to a reasonable default. 
    // Expensive initialization is deferred.
    this.Products = new ObservableCollection<Data.Models.Product>();
  }

  // Allow to defer long-running initialization routines.
  // Such routines can be both, synchronous or asynchronous.
  public async Task<bool> InitializeAsync()
  {
    if (this.IsInitialized)
    {
      return;
    }

    // You should rename 'GetAll' to 'GetAllAsync'
    List<Product> allProducts = await this._repo.GetAll();
    allProducts.ForEach(this.Products.Add);   

    this.IsInitialized = true;
    return this.IsInitialized;
  }
}

MainWindowViewModel.cs

public class MainWindowViewModel : BindableBase, INavigationAware, IInitializable
{
  public ProductViewModel ProductViewModel { get; }
  public bool IsInitialized { get; private set; }
  
  private IList<IInitializable> InitializableDependencies { get; }
    
  public MainWindowViewModel()
  {
    // The container for polymorphic and anonymous iteration
    this.InitializableDependencies = new List<IInitializable>();

    // Create the composition tree. 
    // Because expensive initialization of dependencies is deferred,
    // the type construction is cheap and guaranteed to return fast.
    this.ProductViewModel = new ProductViewModel();

    // Store potential IInitialize implementation for later initialization.
    // This allows to use polymorphism to improve the code.
    // Additionally, we avoid explicit knowledge whether the instantiated type implements this interface or not.
    // This enhances extensibility significantly.
    TryAddInitializable(this.ProductViewModel);
  }

  // Store IInitializable implementations anonymously for later iteration.
  private bool TryAddInitializable(object instance)
  {        
    if (instance is IInitializable initializableInstance)
    {    
      this.InitializableDependencies.Add(initializableInstance);
      return true;
    }

    return false;
  }

  // Allow to defer long-running initialization routines.
  // Such routines can be both, synchronous or asynchronous.
  public async Task<bool> InitializeAsync()
  {
    if (this.IsInitialized)
    {
      return;
    }

    // Cascade IInitializeAsync calls. In context of dependency injection
    // this wouldn't be necessary as the IoC container would allow to filter
    // all types that implement IInitializable to call InitializeAsync on each type explicitly.
    // Because we only need to know the IINitializable interface, the calls are anonymous, allowing easy extension of the code.
    foreach (IInitializable initializableInstance in this.InitializableDependencies)
    {
      // Trigger the cascade of InitializeAsync calls, 
      // given that the ProductViewModel is the composition root of other view model classes 
      // or classes that implement IInitializable.
      bool isSuccesfullyInitialized = await initializableInstance.InitializeAsync();
    }

    this.IsInitialized = true;
    return this.IsInitialized;
  }
}

MainWindow.xaml.cs
这个想法是从合理元素的FrameworkElement.Loaded事件开始延迟初始化（在本例中是MainWindow ）。
如果ProductViewModel由另一个视图 model class 创建，则您必须让此视图 model 也实现IInitializable并级联InitializeAsync方法调用。

partial class MainWindow : Window
{
  private MainWindowViewModel ViewModel { get; }
 
  public MainWindow()
  {
    InitializeComponent();

    this.ViewModel = new MainWindowViewModel();
    this.DataContext = this.ViewModel;
    this.Loaded += OnLoaded;
  }
  
  // Use the Loaded event to execute long-running or resource intensive routines
  // outside the constructor.
  // Define handler as 'async void' to await the async method calls.
  private async void OnLoaded(object sender, RoutedEventArgs e)
  {
    if (this.ViewModel is IInitializable initializableViewModel)
    {
      // Trigger the cascade of InitializeAsync calls, 
      // given that the MainWindowViewModel is the composition root of all view model classes 
      // or classes that implement IInitializable in general.
      _ = await initializableViewModel.InitializeAsync();
    }
  }
}

主窗口.xaml

<Window>
  <ProductView DataGridItemsSource="{Binding ProductViewModel.Products}" />
</Window>