Three Ways to Implement Dependency Injection in .NET Applications

Three Ways to Implement Dependency Injection in .NET Applications

he dependency injection pattern, also knows as Inversion of Control, is one of the most popular design paradigms today. It facilitates the design and implementation of loosely coupled, reusable, and testable objects in your software designs by removing dependencies that often inhibit reuse. Dependency injection can help you design your applications so that the architecture links the components rather than the components linking themselves.

This article presents an overview of the dependency injection pattern, the advantages of using dependency injection in your designs, the different types of dependency injection, and the pros and cons of each of these types, with code examples where appropriate.

Object Dependency Explained
When an object needs another object to operate properly, we say that the former is dependent on the latter. This behavior is transitive in nature. Consider three objects, namely, A, B, and C. If object A is coupled to object B, and B is in turn coupled to C, then object A is effectively coupled to object C?it is dependent on C. I’ve used the terms coupling and dependency interchangeably in this article.

Objects can be coupled in two ways: tight coupling and loose coupling. When an object is loosely coupled with another object, you can change the coupling with ease; when the coupling is tight, the objects are not independently reusable and hence are difficult to use effectively in unit test scenarios.

Here’s an example of tight coupling. Consider two classes, C1 and C2, where C1 is tightly coupled with C2 and requires it to operate. In this case C1 is dependent on C2, as shown below:

   public class C2   {     //Some code   }   public class C1   {      C2 bObject = new C2();      //Some code   }

The tight coupling between the two classes shown above occurs because C1 (which is dependent on C2) creates and contains an instance of the class C2. It’s “tight” because you can eliminate or change the dependency only by modifying the container class (C1). This is where dependency injection fits in.

What is Dependency Injection?
Dependency injection eliminates tight coupling between objects to make both the objects and applications that use them more flexible, reusable, and easier to test. It facilitates the creation of loosely coupled objects and their dependencies. The basic idea behind Dependency Injection is that you should isolate the implementation of an object from the construction of objects on which it depends. Dependency Injection is a form of the Inversion of Control Pattern where a factory object carries the responsibility for object creation and linking. The factory object ensures loose coupling between the objects and promotes seamless testability.

Advantages and Disadvantages of Dependency Injection
The primary advantages of dependency injection are:

  • Loose coupling
  • Centralized configuration
  • Easily testable

Code becomes more testable because it abstracts and isolates class dependencies.

However, the primary drawback of dependency injection is that wiring instances together can become a nightmare if there are too many instances and many dependencies that need to be addressed.

Types of Dependency Injection
There are three common forms of dependency injection:

  1. Constructor Injection
  2. Setter Injection
  3. Interface-based injection

Constructor injection uses parameters to inject dependencies. In setter injection, you use setter methods to inject the object’s dependencies. Finally, in interface-based injection, you design an interface to inject dependencies. The following section shows how to implement each of these dependency injection forms and discusses the pros and cons of each.

Implementing Constructor Injection
I’ll begin this discussion by implementing the first type of dependency injection mentioned in the preceding section?constructor injection. Consider a design with two layers; a BusinessFacade layer and the BusinessLogic layer. The BusinessFacade layer of the application depends on the BusinessLogic layer to operate properly. All the business logic classes implement an IBusinessLogic interface.

With constructor injection, you’d create an instance of the BusinessFacade class using its argument or parameterized constructor and pass the required BusinessLogic type to inject the dependency. The following code snippet illustrates the concept, showing the BusinessLogic and BusinessFacade classes.

   interface IBusinessLogic   {     //Some code   }      class ProductBL : IBusinessLogic   {     //Some code   }      class CustomerBL : IBusinessLogic   {     //Some code   }   public class BusinessFacade   {      private IBusinessLogic businessLogic;      public BusinessFacade(IBusinessLogic businessLogic)      {         this.businessLogic = businessLogic;      }   }

You’d instantiate the BusinessLogic classes (ProductBL or CustomerBL) as shown below:

   IBusinessLogic productBL = new ProductBL();

Then you can pass the appropriate type to the BusinessFacade class when you instantiate it:

   BusinessFacade businessFacade = new BusinessFacade(productBL);

Note that you can pass an instance of either BusinssLogic class to the BusinessFacade class constructor. The constructor does not accept a concrete object; instead, it accepts any class that implements the IBusinessLogic interface.

Even though it is flexible and promotes loose coupling, the major drawback of constructor injection is that once the class is instantiated, you can no longer change the object’s dependency. Further, because you can’t inherit constructors, any derived classes call a base class constructor to apply the dependencies properly. Fortunately, you can overcome this drawback using the setter injection technique.

Implementing Setter Injection
Setter injection uses properties to inject the dependencies, which lets you create and use resources as late as possible. It’s more flexible than constructor injection because you can use it to change the dependency of one object on another without having to create a new instance of the class or making any changes to its constructor. Further, the setters can have meaningful, self-descriptive names that simplify understanding and using them. Here’s an example that adds a property to the BusinessFacade class which you can use to inject the dependency.

The following is now our BusinessFacade class with the said property.

   public class BusinessFacade     {      private IBusinessLogic businessLogic;         public IBusinessLogic BusinessLogic         {          get          {            return businessLogic;          }               set          {            businessLogic = value;          }        }     }

The following code snippet illustrates to implement setter injection using the BusinessFacade class shown above.

   IBusinessLogic productBL = new ProductBL();   BusinessFacade businessFacade = new BusinessFacade();   businessFacade.BusinessLogic = productBL;

The preceding code snippet uses the BusinessLogic property of the BusinessFacade class to set its dependency on the BusinessLogic type.The primary advantage of this design is that you can change the dependency between the BusinessFacade and the instance of BusinessLogic even after instantiating the BusinessFacade class.

Even though setter injection is a good choice, its primary drawback is that an object with setters cannot be immutable?and it can be difficult to identify which dependencies are needed, and when. You should normally choose constructor injection over setter injection unless you need to change the dependency after instantiating an object instance, or cannot change constructors and recompile.

Implementing Interface Injection
You accomplish the last type of dependency injection technique, interface injection, by using a common interface that other classes need to implement to inject dependencies. The following code shows an example in which the classes use the IBusinessLogic interface as a base contract to inject an instance of any of the business logic classes (ProductBL or CustomerBL) into the BusinessFacade class. Both the business logic classes ProductBL and CustomerBL implement the IBusinessLogic interface:

   interface IBusinessLogic   {     //Some code   }      class ProductBL : IBusinessLogic   {     //Some code   }      class CustomerBL : IBusinessLogic   {     //Some code   }      class BusinessFacade : IBusinessFacade   {      private IBusinessLogic businessLogic;      public void SetBLObject(IBusinessLogic businessLogic)      {         this.businessLogic = businessLogic;      }   }

In the code snippet above, the SetBLObject method of the BusinessFacade class accepts a parameter of type IBusinessLogic. The following code shows how you’d call the SetBLObject() method to inject a dependency for either type of BusinessLogic class:

   IBusinessLogic businessLogic = new ProductBL();   BusinessFacade businessFacade = new BusinessFacade();   businessFacade.SetBLObject(businessLogic);


   IBusinessLogic businessLogic = new CustomerBL();   BusinessFacade businessFacade = new BusinessFacade();   businessFacade.SetBLObject(businessLogic);

All three forms of dependency injection discussed in this article passed a reference to a BusinssLogic type rather than an instance of the type by using interfaces. According to Jeremy Weiskotten, a senior software engineer for Kronos:

“Coding to well-defined interfaces, particularly when using the dependency injection pattern, is the key to achieving loose coupling. By coupling an object to an interface instead of a specific implementation, you have the ability to use any implementation with minimal change and risk.”

Dependency Injection can reduce the coupling between software components and it promises to become the paradigm of choice for designing loosely coupled, maintainable and testable objects. It can be used to abstract the dependencies of an object outside of it and make such objects loosely coupled with each other.


About Our Editorial Process

At DevX, we’re dedicated to tech entrepreneurship. Our team closely follows industry shifts, new products, AI breakthroughs, technology trends, and funding announcements. Articles undergo thorough editing to ensure accuracy and clarity, reflecting DevX’s style and supporting entrepreneurs in the tech sphere.

See our full editorial policy.

About Our Journalist