Click here to Skip to main content
12,829,316 members (40,019 online)
Click here to Skip to main content
Add your own
alternative version

Tagged as


35 bookmarked
Posted 25 Sep 2013

Dependency Injection (DI)

, 25 Sep 2013 CPOL
Rate this:
Please Sign up or sign in to vote.
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

You may also be interested in...


Comments and Discussions

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
Member 103101541-Oct-13 21:07
memberMember 103101541-Oct-13 21:07 
AnswerRe: Is Code Implementation Interface Injection > Consuming Interface Injection right?? Pin
Bhim Bahadur Thapa3-Oct-13 3:29
memberBhim Bahadur Thapa3-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.

Permalink | Advertise | Privacy | Terms of Use | Mobile
Web02 | 2.8.170326.1 | Last Updated 25 Sep 2013
Article Copyright 2013 by Bhim Bahadur Thapa
Everything else Copyright © CodeProject, 1999-2017
Layout: fixed | fluid