Click here to Skip to main content
14,734,297 members
Articles » General Programming » Programming Tips » Design and Strategy
Posted 25 Sep 2013

Tagged as


48 bookmarked

Dependency Injection (DI)

Rate me:
Please Sign up or sign in to vote.
4.87/5 (29 votes)
25 Sep 2013CPOL
This tip presents an overview of the dependency injection pattern with mulit-tier application scenario and source code example.


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.


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

Service Interface
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();

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();

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


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.


  • 09-25-2013: First version.


This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)


About the Author

Comments and Discussions

Questioninterface injection in DI Pin
Member 894259820-Aug-20 22:27
MemberMember 894259820-Aug-20 22:27 
QuestionDependency inversion principle Pin
elamparuthidon25-Feb-19 2:31
Memberelamparuthidon25-Feb-19 2:31 
GeneralMy vote of 5 Pin
jfarinhote18-Dec-17 23:11
Memberjfarinhote18-Dec-17 23:11 
QuestionConsuming Interface DI Pin
Member 1054051413-Sep-17 19:55
MemberMember 1054051413-Sep-17 19:55 
QuestionQueries Regarding Consuming Interface Injection Pin
nomi ali26-Feb-17 20:53
professionalnomi ali26-Feb-17 20:53 
QuestionIs Code Implementation Interface Injection > Consuming Interface Injection right?? Pin
RaviSahu881-Oct-13 21:07
professionalRaviSahu881-Oct-13 21:07 
AnswerRe: Is Code Implementation Interface Injection > Consuming Interface Injection right?? Pin
Member 104093523-Oct-13 3:29
MemberMember 104093523-Oct-13 3:29 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.