Dependency Injection (DI)

Introduction

The dependency injection pattern one of the most popular design paradigms today. It is process of removing dependency of object which creates the independent business objects. It is very useful for Test Driven Development.

Background

This tip presents an overview of the dependency injection pattern, the different types of dependency injection, and the advantages and drawback of DI with c# source code examples.

Scenario of Object Dependency

Object dependency means one object needs another object to execute properly, in multitier application (Presentation Tier, Business Logic Tier and Service Tier), the very common scenario is; Presentation Tier dependent on Business Logic and Business Logic requires different services on the basis of end user selection. For instance for Insurance domain, different services could be like ClaimService, AdjudicationService, and PaymentService. If we need some property of Payment service then the Client calls Business object and Business logic requires an object of Service objects so that Business object is dependent on Service object. Business object is coupled with Service object.

Class BusinessLogicImplementation
{
  ClaimService claim=new ClaimService();

  AdjudicationService Adjudication=new AdjudicationService ();
  PaymentService Payment=new PaymentService(); 
}

In the above example class BusinessLogicImplementation dependent (coupled) on different service objects. The tightly coupled objects all most impossible to reuse and implement unit test because of the dependencies.

Definition of DI

The process of injecting (converting) coupled (dependent) objects into decoupled (independent) objects is called Dependency Injection.

Types of Dependency Injection

There are four types of DI:

1. Constructor Injection
2. Setter Injection
3. Interface-based injection
4. Service Locator Injection

Constructor Injection

Constructor is used to interface parameter that exposed through the parameterized contractor. It injects the dependencies through a contractor method as object creation other classes. The following code sample illustrates the concept, showing the BusinessLogicImplementation and Service classes. Class BusinessLogicImplementation has a constructor with IService interface as parameter of constructor.

Code Implementation Constructor Injection

public interface IService
{
    string ServiceMethod();
}

Service Interface implementation for Claim Service

public class ClaimService:IService 
{
    public string ServiceMethod()
    {
        return "ClaimService is running";
    }
}

Service Interface implementation for Adjudication Service

public class AdjudicationService:IService
{
    public string ServiceMethod()
    {
        return "AdjudicationService is running";
    }
}

Service Interface implementation for Payment Service

public class PaymentService:IService
{
   public string ServiceMethod()
    {
        return "PaymentService is running";
    }
}

Constructor Injection Implementation for all services

public  class BusinessLogicImplementation
{  
   private IService client;
   public BusinessLogicImplementation(IService client)
   {
       this.client = client;
       Console.WriteLine("Constructor Injection Injection ==> 
                 Current Service : {0}",client.ServiceMethod());
      
   } 

Consuming Constructor Injection

BusinessLogicImplementation  ConInjBusinessLogic = 
                      new BusinessLogicImplementation(new ClaimService());

Getter and Setter Injection

Getter and Setter Injection injects the dependency by using default public properties procedure such as Gettter(get(){}) and Setter(set(){}). The following code sample illustrates the concept, a public property Client has get and set properties of IService interface that accepts the reference of different services.

Code Implementation Getter and Setter Injection

Business Logic

//Implementing Getter and Setter Injection
public  class BusinessLogicImplementation
{
private IService  _client;
 
   public IService  Client
   {
       get { return _client; }
       set { _client = value; }
   }
   public void testSetterInj()
   {
       Console.WriteLine("Getter and Setter Injection ==> 
               Current Service : {0}", Client.ServiceMethod());
   }
}

Consuming Getter and Setter Injection

BusinessLogicImplementation ConInjBusinessLogic = new BusinessLogicImplementation();
ConInjBusinessLogic.Client = new ClaimService();
ConInjBusinessLogic.testSetterInj();

Interface Injection

Interface Injection is similar to Getter and Setter DI, the Getter and Setter DI uses default getter and setter but Interface Injection uses support interface a kind of explicit getter and setter which sets the interface property. The following code sample illustrates the concept, ISetService is a support interface which has method setServiceRunService which set the interface property.

Code Implementation Interface Injection

Business Logic

//Support interface
interface ISetService
{
    void setServiceRunService(IService client);
}
//Implementing Interface Injection  
public class BusinessLogicImplementationInterfaceDI : ISetService
{
   IService _client1;
   public void setServiceRunService(IService client)
   {
       _client1 = client;
       Console.WriteLine("Interface Injection ==> 
            Current Service : {0}", _client1.ServiceMethod());
   }
}

Consuming Interface Injection

BusinessLogicImplementationInterfaceDI objInterfaceDI = 
         new BusinessLogicImplementationInterfaceDI();
objInterfaceDI= new ClaimService();
objInterfaceDI.setServiceRunService(serviceObj);

Service Locator Injection

Service Locator Injection is also known as Dependency Absorption. It is used to replacement of new operator. It hides the class dependency by invoking methods directly (without creating object). The following code sample illustrates the concept, in the consumption setService method is invoked by class name BusinessLogicImplementation without creating object.

Code Implementation Service Locator Injection

Business Logic

//Implementing Service Locator Injection
public  class BusinessLogicImplementation
{
   private static IService _clientLocator;
 
   public static IService getService()
   {
       return _clientLocator;
   }
 
   public static void setService(IService clientSL)
   {
       _clientLocator = clientSL; 
   }
}

Consuming Service Locator Injection

BusinessLogicImplementation.setService(new PaymentService());
IService client2 = BusinessLogicImplementation.getService();
Console.WriteLine("Service Locator => Current Service : {0}",client2.ServiceMethod());

Advantages of DI

• Reduces class coupling
• Increases code reusability
• Improves code maintainability
• Improves application testing
• Centralized configuration

Drawback

The main drawback of dependency injection is that using many instances together can become a very difficult if there are too many instances and many dependencies that need to be resolved.

History

• 09-25-2013: First version.