How to Use Dependency Injection in C#

This article will explore how to use dependency injection in C#. Dependency injection (DI) is a software design pattern that allows developers to remove hard-coded dependencies and make a codebase more flexible, testable, and maintainable.

Dependency injection is a way to remove hard-coded dependencies between objects, making it easier to change the objects that a class depends on without changing the class itself. This is done by injecting the dependencies into the class through its constructor or properties.

Several popular dependency injection frameworks exist for C#, including Microsoft’s built-in Dependency Injection (DI) framework, Autofac, Ninject, and Simple Injector. Each of these frameworks provides its features and advantages, and you can choose the one that best suits your needs.

In this article, we will be using Autofac as our dependency injection container. By the way, did you know that we offer a unique and powerful online course that boosts your C# career? Check it out here!

Dependency Registration Example Using Autofac

We need to install the Autofac package into our project by opening the NuGet Package Manager in Visual Studio and searching for “Autofac”, and clicking “Install.”

Once Autofac is installed, we can begin configuring our dependency injection container. This is typically done in the startup class of our application, such as the Main method in a console application or the ConfigureServices method in an ASP.NET Core application.

In the above example, we are registering an implementation of MyClass as the implementation of the IMyInterface interface. This tells Autofac that whenever an object of IMyInterface is needed, it should use an instance of MyClass.

Dependency Resolution Example Using Autofac

Once our container is configured. Now we can resolve instances of our registered types. This is typically done using the Resolve method on the container.

In this example, Autofac will return an instance of MyClass, since we have registered it as the implementation of IMyInterface.

It is also possible to register instances of objects rather than types. This can be useful for objects that have already been created, such as singletons.

In this example, we are registering the myObject instance of MyClass as the implementation of IMyInterface. This means that whenever an object of IMyInterface is needed, the myObject instance will be returned.

Benefits of Dependency Injection

Dependency injection helps by providing a way to manage objects’ dependencies in a decoupled and flexible manner. Instead of an object creating or instantiating its dependencies, they are provided to the object through the injection process. This allows for more flexibility and easier testing, as the dependencies can be easily swapped out or mocked. Additionally, it can also make code more maintainable and easier to understand, as the dependencies are clearly defined and not hidden within the object’s implementation. Dependency injection provides the following benefits when it’s done right.

• Loose coupling: Dependency injection promotes loose coupling between objects, making it easier to change or replace dependencies without affecting the dependent objects.
• Easier testing: Because dependencies are injected, it is easier to write unit tests for objects that use them, as you can pass in test doubles (mocks or stubs) for the dependencies.
• Flexibility: Dependency injection allows for greater flexibility in how objects are constructed and makes it easier to create and configure objects with many dependencies.
• Reusability: Classes that use dependency injection are more reusable, as they don’t have hard-coded dependencies and can be used in different contexts with different dependencies.
• Improved maintainability: Dependency injection can make it easier to maintain code, as it can clarify dependencies between classes and how it uses them.

If you want to skyrocket your C# career, check out our powerful ASP.NET full-stack web development course that also covers test-driven development and C# software architecture.

Switching Implementations Using Autofac

We registered the dependencies. But how can we swap the implementation? We can go back to our application’s startup again.

And replace the

with

Where the AnotherClass also implements IMyInterface.

You may also want to learn how to use dependency injection in ASP.NET using Microsoft’s dependency injection framework.

Conclusion

In the examples in this article, we used Autofac as our dependency injection container, but the concepts outlined here can also be applied to other DI frameworks.

In conclusion, Dependency Injection is a powerful technique that allows a developer to decouple the implementation of a class from the creation of its dependencies. Using a DI container such as Autofac, we can easily configure and resolve dependencies in our application, making it more testable and maintainable.