using DependencyInjection at the top level, how to pass the services down the architecture?

Using an IOC-container like Unity,AutoFac or others you have to Register and Resolve the IInterface to get the instance. This you do in the app class the root of all.

After doing the Register/Resolve stuff I am creating my MainController and pass them ALL resolved Services like:

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; 
    }
}

Now the question:

There is a lot of falling through/passing trough services because I have to call services when for example properties of viewmodels change via lost_focus on gui controls.

Is that all right what I do? Do you see any disadvantage? Or how would you do it?

Update

That DI stuff is a massiv attack on my vicious habits :P

1. Did you meant it that way Can?

2. Btw. why should I do that controller factory? Why then not a ServiceFactory too... then we are back to the ServiceLocator...

3. How do I get now that controller instances in my MainViewModel? via extending the Constructor of my MVM with many additional params? ending up with 30 params? ...

 

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>();
    }
}

Update2:

Now I changed my code that the MainViewModel accepts the IControllerFactory as Parameter and added these two lines of code to the App class:

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

That way I dont need to pass all controllers in the MainViewModel Ctor instead the MainViewModel gets the controller instances from the Factory.

Is there anything better I can do here? Or is that an acceptable good solution? I have no experience at all with DI so I ask :)

Update3

OK I did some code refactoring and made comments for others so they understand whats the final solution:

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 resol开发者_如何学Gove 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>();
    }
}

Thank you very much for your time, @Can. I have learned a lot!

---

It seems to me that you have misunderstood how to use an IoC container. Instead of creating instances of your services and passing them as parameters, you need to ask the container to resolve them for you.

For example, you can refactor your code as follows to make use of IoC properly:

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>();
}

The container in this case should control the lifecycle of your MainController object and make sure that all the dependencies (properties and constructor parameters that need to be initialized) are injected and populated.

What will happen is that the container will understand that to create an instance of MainController, it needs IUserService1, IUserService2 and so forth, and in turn will look if it can create any instances of those, by looking at the other types registered with the container. This will be done in a recursive manner to build up a dependency tree until all the dependencies of a class can be satisified. The resulting MainController you get will already have all the dependencies injected in it.

Ideally, you should call Resolve() in as little places as possible in order to structure your application in a way that there is only one root. For an in depth view into Dependency Injection, I strongly recommend the book Dependency Injection in .NET by Mark Seeman, which is in my opinion one of the best introduction to DI one can have.

UPDATE:

The reason why I suggested to use a ControllerFactory was because you had a lot of UserController classes in your MainController, and passing all those as a dependency you would end up with 10+ constructor parameters, not to mention that having to add more when you create new controllers. If your viewmodels only have dependency on one controller, then it doesn't make sense to use the factory in that way and you can have a direct dependency on the required controller.

As for ServiceFactory, it is not needed, because each of your classes are not likely to require ALL the service classes available, just some of them. In that case it is better to specify them explicitly for each service in the constructor.

You should also register all your instances in one place (or in small installer classes) instead of within constructor for different classes.

Here's a question that is more specific to MVVM that should get you going on how to structure your classes and dependencies: How can I combine MVVM and Dependency Injection in a WPF app?