Autofac DI Framework

Autofac is a popular open-source dependency injection (DI) framework for .NET applications.

It provides a powerful and flexible way to manage object dependencies and resolve them at runtime. In this tutorial, we will explore the history, features, and examples of Autofac.

History of Autofac

Autofac was created by Nicholas Blumhardt and Alex Meyer-Gleaves in 2006. It was initially developed as an alternative to the existing DI frameworks for .NET, with the goal of providing a lightweight and easy-to-use solution. Over the years, Autofac has gained popularity and has become one of the most widely used DI frameworks in the .NET ecosystem.

Features of Autofac

Autofac offers a wide range of features that make it a powerful choice for managing dependencies in .NET applications. Let's take a look at some of its key features:

1. Dependency Injection

At its core, Autofac is a DI framework that helps in managing object dependencies. It allows you to define the dependencies of your classes and automatically resolves them at runtime. This helps in decoupling the components of your application and makes it easier to maintain and test.

Here's an example of how you can use Autofac for constructor injection:

public class Foo
{
    private readonly IBar _bar;

    public Foo(IBar bar)
    {
        _bar = bar;
    }

    public void DoSomething()
    {
        _bar.DoSomething();
    }
}

public interface IBar
{
    void DoSomething();
}

public class Bar : IBar
{
    public void DoSomething()
    {
        Console.WriteLine("Doing something...");
    }
}

// Configure Autofac container
var builder = new ContainerBuilder();
builder.RegisterType<Bar>().As<IBar>();
builder.RegisterType<Foo>();

// Resolve the dependencies
using (var container = builder.Build())
{
    var foo = container.Resolve<Foo>();
    foo.DoSomething();
}

In this example, the Foo class depends on the IBar interface. Autofac resolves this dependency by automatically providing an instance of the Bar class when creating an instance of Foo.

2. Container Configuration

Autofac provides a fluent API to configure the container and register your dependencies. You can define the lifetime and other settings for your objects during the registration process. This allows you to have fine-grained control over how your dependencies are created and managed.

Here's an example of configuring the container with different lifetime scopes:

// Configure Autofac container
var builder = new ContainerBuilder();

// Singleton registration
builder.RegisterType<MySingleton>().SingleInstance();

// Instance per dependency registration
builder.RegisterType<MyService>().InstancePerDependency();

// Instance per lifetime scope registration
builder.RegisterType<MyScopedService>().InstancePerLifetimeScope();

// Resolve the dependencies
using (var container = builder.Build())
{
    var singleton1 = container.Resolve<MySingleton>();
    var singleton2 = container.Resolve<MySingleton>();

    var service1 = container.Resolve<MyService>();
    var service2 = container.Resolve<MyService>();

    using (var scope = container.BeginLifetimeScope())
    {
        var scopedService1 = scope.Resolve<MyScopedService>();
        var scopedService2 = scope.Resolve<MyScopedService>();
    }
}

In this example, the MySingleton class is registered as a singleton, meaning that the same instance will be used throughout the application. The MyService class is registered as an instance per dependency, meaning that a new instance will be created each time it is resolved. The MyScopedService class is registered as an instance per lifetime scope, meaning that a new instance will be created for each lifetime scope.

3. Interceptors

Autofac supports interceptors, which allow you to add behavior to your objects at runtime. Interceptors can be used to implement cross-cutting concerns such as logging, caching, authorization, and more. Autofac provides an easy way to apply interceptors to your dependencies.

Here's an example of using an interceptor with Autofac:

public class LoggingInterceptor : IInterceptor
{
    public void Intercept(IInvocation invocation)
    {
        Console.WriteLine($"Executing method: {invocation.Method.Name}");

        invocation.Proceed();
    }
}

// Configure Autofac container with interceptor
var builder = new ContainerBuilder();
builder.RegisterType<MyService>().EnableInterfaceInterceptors();
builder.Register(c => new LoggingInterceptor());

// Resolve the dependencies
using (var container = builder.Build())
{
    var service = container.Resolve<MyService>();
    service.DoSomething();
}

In this example, the MyService class is registered with the EnableInterfaceInterceptors() method, which enables interception for interfaces implemented by MyService. The LoggingInterceptor class is registered as an interceptor and will be invoked for each method call on MyService.

4. Integration with Other Libraries and Frameworks

Autofac integrates seamlessly with other libraries and frameworks in the .NET ecosystem. It provides integration packages for popular frameworks like ASP.NET Core, ASP.NET MVC, WCF, and more. These integration packages simplify the configuration and usage of Autofac in these frameworks.

For example, to use Autofac with ASP.NET Core, you can install the Autofac.Extensions.DependencyInjection NuGet package and configure Autofac as the DI container for your application.

Conclusion

In this tutorial, we explored the introduction, history, features, and examples of Autofac. We learned how Autofac helps in managing object dependencies through dependency injection and how to configure the container, use interceptors, and integrate Autofac with other libraries and frameworks. Autofac provides a powerful and flexible solution for managing dependencies in .NET applications, making them more maintainable, testable, and scalable.

For more information and detailed documentation, you can visit the official Autofac website: https://autofac.org/