Can I use DI container down in the hierarchy?

Question

Can I use DI container down in the hierarchy to create new objects? For each DI container you setup dependencies and then say getInstance by type and it creates the instance properly. Also, you can read lots of articles that explain that DI container should be on the top of the hierarchy in the main function and it should not be passed around or a singleton. But what if I want to get an instance from the container down in the hierarchy of my objects?

Answer 1

Avoid letting application code (other than the start-up code) take a direct dependency on the container or an abstraction over the container; this is an anti-pattern known as Service Locator. The start-up code is commonly referred to as the Composition Root.

The Composition Root is a separate layer in your application. This layer lies on top of the other layers, such as Presentation Layer and Business Layer.

This doesn't however mean that you can't use the container to create parts of the object graph in a lazy manner after some condition. Here's an example:

// Defined in a shared library of your application, accessible to all other
// code in your application.
public interface ICommandProcessor
{
    public void Process(object command);
}

Possible usage of this interface is as follows:

this.commandProcessor.Process(new ShipOrderCommand(orderId));

While the abstraction doesn't note anything about the use of a possible container, the implementation of this abstraction can still depend on one. But since application code should not depend on the container, this implementation should be defined inside the Composition Root (the start-up path of your application). This allows the application to stay oblivious off the existence of such tool, while the container can still be used to resolve object graphs. Here is an example implementation:

public class CommandProcessor : ICommandProcessor
{
    private readonly Container container;
    public CommandProcessor(Container container) {
        this.container = container;
    }
    public void Process(object command) {
        Type handlerType = typeof(ICommandHandler<>).MakeGenericType(command.GetType());
        dynamic handler = this.container.GetInstance(handlerType);
        handler.Handle((dynamic)command);
    }
}

So long story short, you can use the container for creating object graphs in a delayed fashion, as long as the only layer in your application that uses the Container is your Composition Root.