Register Container Itself Using Autofac

Question

I was wondering is there's any side effect to registering the container within itself

IContainer container;
ContainerBuilder builder = new ContainerBuilder();
container = builder.Build();
builder.RegisterInstance(container).As<IContainer>();

and the using it like this

builder.RegisterType<IManagmentServiceImp>().As<ManagmentServiceImp>()
    .WithParameter(new ResolvedParameter(
            (pi, ctx) => pi.ParameterType == typeof(IContainer) && pi.Name == "Container",
            (pi, ctx) => container
));

or whether it will even work.

Answer 1

Your code is not safe because you register an instance before it has been initialized.

If you need to have access to the container inside a component (which is not a good idea) you can have a dependency on ILifetimeScope which have Resolve methods.

public class ManagmentServiceImp 
{
    public ManagmentServiceImp(ILifetimeScope scope)
    {
    }
}

ILifetimeScope is automatically registered within Autofac you don't need to add registration for it.

See Controlling Scope and Lifetime from Autofac documentation for more information.

By the way, it is not a good practice to have dependency on your IoC container. It looks like you use Service Locator anti-pattern. If you need the container to lazy load dependency, you can use composition with Func<T> or Lazy<T>

public class ManagmentServiceImp 
{
    public ManagmentServiceImp(Lazy<MyService> myService)
    {
        this._myService = myService; 
    }

    private readonly Lazy<MyService> _myService;
}

In this case, MyService will be created when you first access it.

See Implicit Relationship from the Autofac documentation for more information.

Answer 2

You can use this extension method:

public static void RegisterSelf(this ContainerBuilder builder)
{
    IContainer container = null;
    builder.Register(c => container).AsSelf().SingleInstance();
    builder.RegisterBuildCallback(c => container = c);
}

use it like this: builder.RegisterSelf();

Answer 3

Since you need to provide an instance of the container to builder.RegisterInstance(), you need to initialize it BEFORE passing it as an argument, which you are currently not doing. However, if you structure your container builder to build AFTER registration (and container initialization), you can successfully resolve the container instance in your class.

Please note that this is most certainly a design smell in Dependency Injection and you absolutely should not do this. Your container/kernel should only exist at the top level of your object graph. If you begin injecting your container, you're almost certainly on your way to a Service Locator Anti-Pattern.

void Main()
{
    IContainer container = new ContainerBuilder().Build();
    ContainerBuilder builder = new ContainerBuilder();

    builder.RegisterInstance(container).As<IContainer>();

    builder.RegisterType<ManagementServiceImp>().As<IManagmentServiceImp>()
       .WithParameter(new ResolvedParameter(
            (pi, ctx) => pi.ParameterType == typeof(IContainer) && pi.Name == "Container",
            (pi, ctx) => container
    ));

    container = builder.Build();
    var instance = container.Resolve<IManagmentServiceImp>();
}

public class ManagementServiceImp : IManagmentServiceImp 
{ 
    private IContainer _container;

    public ManagementServiceImp(IContainer Container)
    {
        _container = Container;
        _container.Dump();
    }
}

public interface IManagmentServiceImp { }