Autofac dependency injection in C#
Writing modular and testable code is important. One powerful technique that helps in attaining this goal is dependency injection (DI). Dependency injection allows us to pass dependencies (services or objects) into a class instead of creating them within the class, enabling loose coupling and making our code more maintainable and testable.
In this Answer, we’ll see how to use Autofac in C#, but we need prior knowledge of basic syntax, dependency inject, and interfaces.
What is Autofac?
Autofac is an open-source dependency injection package for .NET applications. It simplifies managing object creation and helps organize our application’s components.
Install Autofac
We can install Autofac using .NET CLI or a package manager like NuGet.
Open the terminal, navigate to the project folder, and execute the command below:
dotnet add package Autofac
Note: We can run the command above in the terminal integrated in the playground below.
Working principle of Autofac
The basic configuration of Autofac works on the principle of registration and resolution. It registers all the dependencies in the centralized container and resolves the dependency when some component requires this service:
Creating a container
We need to create a container that registers the services by using the following syntax:
using Autofac;// Container buildervar builder = new ContainerBuilder();
The
builderfunction is an instance ofContainerBuilderclass fromAutofacnamespace to register the services.
Registration
After creating builder we need to register components (services, dependencies, or objects) in the container. This is typically done during the application’s start-up:
// Registering a componentbuilder.RegisterType<MyService>().As<IMyService>();// Build the container after registrationvar container = builder.Build();
The
RegisterType<>()function registers the typeMyServicewith the container. This means that Autofac is aware of its existence and can provide instances of it when requested.The
As<IMyService>()function specifies that when someone asks Autofac for an instance ofIMyService, it should provide an instance ofMyService. This is a way of associating an interface or abstractionIMyServicewith its concrete implementationMyService. It establishes the dependency relationship within the container.We need to build the configuration by calling the
Build()function.
Resolution
Whenever we require an instance of a registered component from the container, we need to call Resolve() function, which creates and returns an instance based on the component’s registration:
// Resolve the dependency of IMServicevar myService = container.Resolve<IMyService>();
The
Resolve<>()function will return the object ofIMServicetype.
Example
In this example, we have a simple IPrinter service that has a Print method. In the Models folder, we have an implementation of IPrinter service. This example uses Autofac for dependency injection. We need to execute the following commands in the terminal:
dotnet add package Autofacdotnet run
Test yourself
Press the “Run” button and execute the commands above:
using System;
using Autofac;
namespace autofacDemo
{
static public class Container
{
public static IContainer InitContainer()
{
var builder = new ContainerBuilder();
builder.RegisterType<PrintSuqare>().As<IPrinter>();
builder.RegisterType<Shape>().AsSelf().InstancePerDependency();
var container = builder.Build();
return container;
}
}
}
Let’s understand the Container.cs code:
Line 11: We create an instance of
ContainerBuilder.Lines 12–13: We register two components in the container: one service
PrintSuqareand second, we need to registerShapecomponent that depends uponIPrinterservice. Whenever we create an instance ofShape, the container will resolve theIPrinterservice for that instance.Line 14: We build the
container.Line 15: We return the
container.
Let’s understand the Program.cs code:
Lines 20–34: We have a class
Shapethat depends onIPrinter.Line 13: We initialize the
container.Line 14: We create
Sqobject of typeShape. Because we have registered our services and components tocontainer, so we usecontainer.Resove<>()function to resolve the dependency.
Conclusion
Autofac simplifies dependency injection in C# applications, promoting modular, testable, and maintainable code. By understanding the basics of Autofac and exploring its advanced features, we can leverage its power to enhance the architecture of our projects.
Free Resources