.NET Dependency Injection with Autofac: A Complete Guide

A detailed guide to mastering dependency injection in .NET with Autofac, complete with examples and best practices.

Table of Contents

• Introduction to Dependency Injection
• Why Choose Autofac?
• Getting Started with Autofac
• Registering Services in Autofac
• Lifetime Management in Autofac
• Advanced Usage and Modules
• Integrating Autofac with ASP.NET Core
• Best Practices with Autofac
• Conclusion

Introduction to Dependency Injection

Dependency Injection (DI) is a design pattern used to achieve Inversion of Control (IoC) between classes and their dependencies. Instead of instantiating dependencies within a class, they are injected externally, promoting loose coupling and making the code easier to test and maintain.

In .NET, the built-in DI container is robust, but sometimes we need more advanced features. Autofac is a powerful IoC container that extends the capabilities of the default .NET Core DI framework.

Why Choose Autofac?

Autofac offers several advantages over the default .NET Core DI container:

• Rich Features: Autofac supports advanced features like property injection, module-based configuration, and assembly scanning.
• Custom Scoping: It allows granular control over service lifetimes and scopes.
• Ease of Use: Autofac's fluent API makes it easy to register services and manage dependencies.
• Compatibility: Autofac integrates seamlessly with .NET Core and other frameworks like ASP.NET, WPF, and Xamarin.

Getting Started with Autofac

To use Autofac in your .NET project, you first need to install the Autofac NuGet package. You can do this using the following command:

dotnet add package Autofac.Extensions.DependencyInjection

After installation, you'll configure Autofac in your project. Let's explore how to set up Autofac in an ASP.NET Core application.

Registering Services in Autofac

Service registration in Autofac is straightforward. You can register types using the ContainerBuilder class. Here’s an example:

var builder = new ContainerBuilder();
builder.RegisterType<MyService>().As<IMyService>();
var container = builder.Build();

In this example, MyService is registered as an implementation of the IMyService interface.

Lifetime Management in Autofac

Autofac provides flexible lifetime management options for services:

• InstancePerDependency: A new instance is created for every dependency.
• SingleInstance: A single instance is shared across the application.
• InstancePerLifetimeScope: A single instance is created per lifetime scope.

builder.RegisterType<MyService>().As<IMyService>().SingleInstance();

Advanced Usage and Modules

Autofac supports advanced configurations through modules. A module is a reusable unit for organizing registrations:

public class MyModule : Module {
    protected override void Load(ContainerBuilder builder) {
        builder.RegisterType<MyService>().As<IMyService>();
    }
}

Modules help keep large projects organized.

Integrating Autofac with ASP.NET Core

To integrate Autofac with ASP.NET Core, replace the default DI container in the Program.cs file:

public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .UseServiceProviderFactory(new AutofacServiceProviderFactory())
        .ConfigureWebHostDefaults(webBuilder =>
        {
            webBuilder.UseStartup<Startup>();
        });

Best Practices with Autofac

• Avoid Overuse: Use dependency injection only for true dependencies.
• Use Constructor Injection: Prefer constructor injection for required dependencies.
• Organize Registrations: Use modules and assembly scanning for better organization.

Conclusion

Autofac is a powerful tool for implementing dependency injection in .NET applications. Its advanced features, ease of use, and flexibility make it a popular choice for developers. By following best practices and leveraging its full potential, you can build maintainable, scalable, and testable applications.

© 2025 Sandeep Mhaske. All rights reserved.