Question

我熟悉WPF和MVVM模式。现在，我尝试使用Autofac在我的新WPF应用程序中练习依赖注入模式。我想弄清楚如何将依赖注入MVVM View Model类。

如下面附带的代码，我有一个根视图模型类MainViewModel，它可以在需要时创建其他视图模型（例如。MonitorPageViewModel）实例。在MonitorPageViewModel中，还需要在需要时创建其他子视图模型（例如。MonitorDashboardViewModel）实例。所有这些视图模型都可能有多个依赖项（ILogger，IRepository<RawMessage>，IParsingService等等。

在我之前没有使用任何IoC容器的WPF项目中，我总是new在父视图模型中需要时使用子视图模型，并使用ServiceLocator提供所需的服务。现在，我想找出更多依赖注入方式来做到这一点。

我有几种方法（在下面的代码中演示），但我对其中的任何一种都不满意。

使用IoC容器获取响应以创建MainViewModel;并将IoC Container实例注入MainViewModel;然后，使用IoC容器实例来解析子视图模型构造函数所需的每个对象。如果子视图模型类需要解析其他类，则将IoC注入其中。 [听起来是另一个ServiceLocator ]。
注入MainViewModel及其后代视图模型所需的所有服务，并沿视图模型链传递服务。并且new视图模型实例需要它。 [需要注入大量服务并将其传递]

我不想在此项目中使用Caliburn.Micro等MVVM框架。有一个简单而优雅的解决方案吗？

public interface ILogger
{
    // ...
}

public interface IRepository<T>
{
    // ...
}

public interface IStatisticsService
{
    // ...
}

public class RawMessage
{
    // ...
}

public class Device
{
    // ...
}

public class Parser
{
    // ...
}


public interface IParsingService
{
    void Parse(Parser parser);
}

public class DockPaneViewModel : ViewModelBase
{
    // ...
}

public class HomePageViewModel : DockPaneViewModel
{
    public HomePageViewModel(ILogger logger)
    {
        // ...
    }
}

public class MonitorDashboardViewModel : DockPaneViewModel
{
    public MonitorDashboardViewModel(IStatisticsService statisticsService)
    {
        // ...
    }
}

public class MonitorPageViewModel : DockPaneViewModel
{
    public MonitorPageViewModel(ILogger logger, IRepository<RawMessage> repository,
        IRepository<Parser> parserRepository, IParsingService parsingService)
    {
        // ...
    }

    public void CreateDashboard()
    {
        IStatisticsService statisticsService = ??; // how to resolve the service?
        var dashBoardVm = new MonitorDashboardViewModel(statisticsService); // how to create this? 
    }
}

public class ResourceManagementViewModel : DockPaneViewModel
{
    public ResourceManagementViewModel(ILogger logger, IRepository<Device> deviceRepository)
    {
        // ...
    }
}

以下是带有替代构造函数的MainViewModel

public class MainViewModel : ViewModelBase
{
    public ObservableCollection<DockPaneViewModel> DockPanes
    {
        get;
        set;
    } = new ObservableCollection<DockPaneViewModel>();

    #region approach 1
    // use the IOC container take the response to create MainViewModel;
    // and inject the Ioc Container instance to MainViewModel;
    // then, use the IOC container instance to resovle every thing the child view models need
    private readonly ISomeIocContainer _ioc;
    public MainViewModel(ISomeIocContainer ioc)
    {
        _ioc = ioc;
    }

    public void ResetPanes_1()
    {
        DockPanes.Clear();
        DockPanes.Add(new HomePageViewModel(_ioc.Resolve<ILogger>())); // how to new child view model and how to provide the constructor parameters?
        DockPanes.Add(new MonitorPageViewModel(_ioc.Resolve<ILogger>(),
            _ioc.Resolve< IRepository<RawMessage>>(), 
            _ioc.Resolve<IRepository<Parser>>(),
            _ioc.Resolve<IParsingService>())); // also need to inject ISomeIocContainer to MonitorDashboardViewModel for resolve IStatisticsService
        DockPanes.Add(new ResourceManagementViewModel(_ioc.Resolve<ILogger>(), 
            _ioc.Resolve<IRepository<Device>>()));
        // add other panes
    }
    #endregion

    #region approach 2
    // pasing all dependencies of MainViewModel and all descendant View Models in to MainViewModel,
    // and pass dependencies along the ViewModel chain.
    private readonly ILogger _logger;
    private readonly IRepository<RawMessage> _repository;
    private readonly IRepository<Parser> _parserRepository;
    private readonly IRepository<Device> _deviceRepository;
    private readonly IParsingService _parsingService;
    private readonly IStatisticsService _statisticsService;
    public MainViewModel(ILogger logger, IRepository<RawMessage> repository,
        IRepository<Parser> parserRepository, IRepository<Device> deviceRepository,
        IParsingService parsingService, IStatisticsService statisticsService)
    {
        _logger = logger;
        _repository = repository;
        _parserRepository = parserRepository;
         _deviceRepository = deviceRepository;
        _parsingService = parsingService;
        _statisticsService = statisticsService;
    }

    public void ResetPanes_2()
    {
        DockPanes.Clear();
        DockPanes.Add(new HomePageViewModel(_logger)); // how to new child view model and how to provide the constructor parameters?
        DockPanes.Add(new MonitorPageViewModel(_logger, _repository, _parserRepository, _parsingService)); // also need pass statisticsService down 
        DockPanes.Add(new ResourceManagementViewModel(_logger, _deviceRepository));
        // add other panes
    }
    #endregion
}

Answer 1

有些时候回归基础并保持简单（KISS）往往有效。

这种情况的想法是The Explicit Dependency Principle和Pure Dependency Injection。

MainViewModel通过注入容器（大而不是没有）或者有很多依赖关系（代码味道）显而易见。尝试缩小该类假设要做的事情（SRP）

所以要说主视图模型需要一组窗格。那么为什么不给它所需要的呢。

public class MainViewModel : ViewModelBase {
    public ObservableCollection<DockPaneViewModel> DockPanes { get; set; }

    //Give the view model only what it needs
    public MainViewModel(IEnumerable<DockPaneViewModel> panes) {
        DockPanes = new ObservableCollection<DockPaneViewModel>(panes);
    }

    public void ResetPanes() {
        foreach (var pane in DockPanes) {
            pane.Reset();
        }
        //notify view
    }
}

请注意对基本面板的轻微更改

public abstract class DockPaneViewModel : ViewModelBase {
    // ...

    public virtual void Reset() {
        //...
    }
}

主视图模型不应该关注如何创建依赖项。它只关心它得到明确要求的东西。

这同样适用于不同的窗格实现。

如果视图模型需要能够创建多个子项，则将该责任委派给工厂。

public class MonitorPageViewModel : DockPaneViewModel {
    public MonitorPageViewModel(ILogger logger, IRepository<RawMessage> repository,
        IRepository<Parser> parserRepository, IParsingService parsingService, 
        IPaneFactory factory) {
        // ...
    }

    public void CreateDashboard() {
        var dashBoardVm = factory.Create<MonitorDashboardViewModel>();

        //...
    }
}

此外，主题应尽可能减少责任。

View First或ViewModel First被视为实现问题，如果遵循约定优于配置模型，则无关紧要。

如果设计做得好，使用框架或纯代码无关紧要。

虽然这些框架在将所有内容放在一起时会派上用场。最简单和最优雅的解决方案是创建对象图，但如果没有这些，您可以自己在组合根中构建它。

如何将依赖注入MVVM View Model类？

1 个答案: