在顶层使用DependencyInjection，了解如何将服务传递到体系结构中

使用Unity、AutoFac或其他IOC容器，您必须注册并解析IInterface才能获得实例。这是你在应用程序类中所做的一切的根源。

在做了注册/解决的事情后，我正在创建我的主控制器，并将所有解决的服务传递给他们，如：

protected void Application_Start(object sender, EventArgs e)
{
    var builder = new ContainerBuilder();
    builder.Register<IUserService1, UserService1>();
    builder.Register<IUserService2, UserService2>();
    builder.Register<IUserService3, UserService3>();
            builder.Register<IAnotherService, AnotherService>();
    // And many more Services...
    _container = builder.Build();
    var userService1 = _container.Resolve<IUserService1>();
    var userService2 = _container.Resolve<IUserService2>();
    var userService3 = _container.Resolve<IUserService3>();
var anotherService = _container.Resolve<IAnotherService>();     
    var vm = new MainController(userService1,userService2,userService3,anotherService)
}
public class MainController
{    
    private UserController1 _userVM1;
    private UserController2 _userVM2;
    private UserController3 _userVM3;
    public MainController(IUserService1 userService1,IUserService2 userService2,IUserService3 userService3,anotherService)
    {    
        _userVM1 = new UserController1(userService1,anotherService);
        _userVM2 = new UserController2(userService2,...,...);
        _userVM3 = new UserController3(userService3,...,...,...);     
    }
} 
// Such a Controller class needs to be created 10 times... and what I do here is typical for all Controllers driving the GUI
public class UserController1
{
    private readonly IUserService1 _userService1; 
    public UserController1(IUserService1 userService1,IAnotherService anotherService)
    {
        _userService1 = userService1;           
        //Bind data to GUI
        UserData1Collection = ConvertModelIntoViewModelCollection(userService1,anotherService);
    }
    public ObservableCollection<UserData1> UserData1Collection { get; set; }
    private ObservableCollection<UserData1ViewModel> ConvertModelIntoViewModelCollection(IAnotherService anotherService)
    {      
        var userData1ViewModelCollection = new ObservableCollection<UserData1ViewModel>();
        _userService1.GetUserData1().ForEach(user =>
        {
            userData1ViewModelCollection.Add(new UserData1ViewModel(user, anotherService,...));
        });           
        return userData1ViewModelCollection; 
    }
}

现在的问题是：

有很多失败/失败的服务，因为例如，当视图模型的属性通过gui控件上的lost_focus更改时，我必须调用服务。

我这样做可以吗？你觉得有什么缺点吗？或者你会怎么做？

更新

DI的东西是对我坏习惯的大规模攻击：p

1. 你是那个意思吗？

2. Btw。为什么我要做控制器工厂？那为什么不建立一个ServiceFactory呢。。。然后我们回到ServiceLocator。。。

3. 我现在如何在MainViewModel中获得控制器实例？通过用许多附加参数扩展我的MVM的构造函数？最后有30个参数。。。

 

protected override void OnStartup(StartupEventArgs e)
{
    IContainerBuilder builder = new ContainerBuilder();
    // Firstly Register ALL existing Services            
    builder.Register<IAdminService, AdminService>();
    builder.Register<IDocumentService, DocumentService>();
    builder.Register<ILessonPlannerService, LessonPlannerService>();
    builder.Register<IMediator, Mediator>();
    builder.Register<IMainRepository, MainRepository>();           
    builder.Register<MainViewModel>();
    IContainer _container = builder.Build();
    // THEN Register ALL Controllers needing the previously registered Services
    IControllerFactory factory = new ControllerFactory(builder);
    IDailyPlanner controller1 = factory.Create<IDailyPlanner>();
    IWeeklyPlanner controller2 = factory.Create<IWeeklyPlanner>();
    SchoolclassAdministrationViewModel controller3 = factory.Create<SchoolclassAdministrationViewModel>();
    // THEN Register the mainViewModel(MainController) which should take ALL Services and ALL Controller... WOW thats a massive Ctor param count... is that pure? Did you mean it that way???
    MainViewModel mainViewModel = _container.Resolve<MainViewModel>();
    //MainWindow mainWindow = _container.Resolve<MainWindow>();
    //mainWindow.DataContext = mainViewModel;   
    //mainWindow.ShowDialog();   
} 
public class ControllerFactory : IControllerFactory
{
    private readonly IContainerBuilder _builder;
    private readonly IContainer _container;
    /// <summary>
    /// Takes the IOC container to register all Controllers
    /// </summary>
    public ControllerFactory(IContainerBuilder builder)
    {
        _builder = builder;
        _builder.Register<SchoolclassAdministrationViewModel>();
        _builder.Register<IDailyPlanner, LessonPlannerDailyViewModel>();
        _builder.Register<IWeeklyPlanner, LessonPlannerWeeklyViewModel>();
        _container = _builder.Build();
    }
    /// <summary>
    /// Returns an Instance of a given Type
    /// </summary>
    public T Create<T>()
    {
        return _container.Resolve<T>();
    }
}

更新2：

现在，我更改了MainViewModel接受IControllerFactory作为参数的代码，并将以下两行代码添加到应用程序类：

builder.Register<IControllerFactory, ControllerFactory>();
builder.Register<IContainerBuilder, ContainerBuilder>(); 

这样，我就不需要传递MainViewModel Ct中的所有控制器，或者MainViewModel从工厂获取控制器实例。

我能在这里做点什么吗？或者这是一个可以接受的好解决方案？我根本没有DI的经验，所以我问：）

更新3

好的，我做了一些代码重构，并为其他人做了评论，让他们了解最终的解决方案是什么：

protected override void OnStartup(StartupEventArgs e)
{
    IContainerBuilder builder = new ContainerBuilder();
    // Firstly Register ALL existing Services          
    builder.Register<IAdminService, AdminService>();
    builder.Register<IDocumentService, DocumentService>();
    builder.Register<ILessonPlannerService, LessonPlannerService>();
    builder.Register<IMediator, Mediator>();
    builder.Register<IMainRepository, MainRepository>();
    builder.Register<IControllerFactory, ControllerFactory>();              
    builder.Register<IDailyPlanner, LessonPlannerDailyViewModel>();
    builder.Register<IWeeklyPlanner, LessonPlannerWeeklyViewModel>();
    // Just for visual separation THEN register the MainController driving all other Controllers created via the IControllerFactory          
    builder.Register<MainViewModel>();
    // Build the container
    IContainer container = builder.Build();
    // THEN Register the MainController which should take ALL IServices and the IFactory
    MainViewModel mainViewModel = container.Resolve<MainViewModel>();
    // LATER in the mainViewModel`s Ctor you can create all 10 Controller instances with the IControllerFactory like this
    // _dailyPlannerController = controllerFactory.Create<IDailyPlanner>();
    MainWindow mainWindow = new MainWindow();
    mainWindow.DataContext = mainViewModel;   
    mainWindow.ShowDialog();   
}
public class ControllerFactory : IControllerFactory
{
    private readonly IContainer _container;
    /// <summary>
    /// Takes the IOC container to resolve all Controllers
    /// </summary>
    public ControllerFactory(IContainer container)
    {
        _container = container; 
    }
    /// <summary>
    /// Returns an Instance of a given Type
    /// </summary>
    public T Create<T>()
    {
        return _container.Resolve<T>();
    }
}

非常感谢您抽出时间，@Can。我学到了很多！

protected void Application_Start(object sender, EventArgs e)
{
    var builder = new ContainerBuilder();
    builder.Register<IUserService1, UserService1>();
    builder.Register<IUserService2, UserService2>();
    builder.Register<IUserService3, UserService3>();
    builder.Register<IAnotherService, AnotherService>();
    builder.Register<MainController, MainController>();
    // And many more Services...
    _container = builder.Build();
    //let the container inject all the required dependencies into MainController..
    var vm = _container.Resolve<MainController>();
}