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:
- Constructor Injection
- Setter Injection
- Interface-based injection
- 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
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
interface ISetService
{
void setServiceRunService(IService client);
}
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
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.