Using Autofac to do DI in a static factory method

Question

I'm using Autofac to create one of my classes inside of a static factory method Create. This code is working and I haven't noticed any side effects yet. Admittedly, I've only used it in unit-tests so far but I'm wondering whether there could be any issues with it later when I take it into production code?

public static ICommandLineExecutor Create(ILogger logger)
{
    var containerBuilder = new ContainerBuilder();

    containerBuilder
        .RegisterType<CommandLineTokenizer>()
        .As<ICommandLineTokenizer>();

    containerBuilder
        .RegisterType<CommandLineParser>()
        .As<ICommandLineParser>();

    containerBuilder
        .RegisterType<CommandParameterFactory>()
        .WithParameter(new TypedParameter(typeof(TypeConverter), CommandParameterFactory.DefaultConverter))
        .As<ICommandParameterFactory>();

    containerBuilder
        .RegisterType<CommandLineExecutor>()
        .WithParameter(new TypedParameter(typeof(ILogger), logger))
        .As<ICommandLineExecutor>();

    using (var container = containerBuilder.Build())
    using (var scope = container.BeginLifetimeScope())
    {
        return scope.Resolve<ICommandLineExecutor>();
    }
}

Answer 1

What are you registering CommandLineTokenizer etc for? this whole code block is equivalent to

return new CommandLineExecutor(logger);

If all these types are somehow used after all (inside CommandLineExecutor .ctor?), remember that everything created Per LifeTime scope will be disposed at exit out of using and everything created Per Dependency scope will become your responsibility to Dispose.

Answer 2

I can't say for sure without seeing the whole code, but I think this is violating the core principle of DI. You should never access the DI container anywhere except the composition root, which is where you resolve the startup class of your project and start doing the actual work. So, the registration code should be in the composition root where you do all your other registration, and you should just be able to inject an ICommandLineExecutor into whatever other constructors need it.

AutoFac automatically resolves types as their interfaces, so the last part of this code is redundant:

containerBuilder
    .RegisterType<CommandLineTokenizer>()
    .As<ICommandLineTokenizer>();

If CommandLineTokenizer implements ICommandLineTokenizer, then it will automatically be registered as both CommandLineTokenizer and ICommandLineTokenizer. You shouldn't need to register types with parameters explicitly; AutoFac will look at the parameters and inject them automatically. Actually, you really shouldn't be registering types explicitly; I don't know the exact syntax, but you can register a whole assembly at once.

Finally, if you really do need a different container here, then what you do is inject an ILifetimeScope instance into your class and do something like:

using (var newScope = _lifetimeScope.BeginLifetimeScope())
{
    var item = newScope.Resolve<Item>();
    // write your code using `item` here, and the new scope will be used
}