Please enable Javascript to correctly display the contents on Dot Net Tricks!

Implementation of Dependency Injection Pattern in C#

 Print 
  Author : Shailendra Chauhan
Posted On : 12 Apr 2013
Total Views : 270,163   
Updated On : 26 Sep 2016
 

Dependency Injection (DI) is a software design pattern that allow us to develop loosely coupled code. DI is a great way to reduce tight coupling between software components. DI also enables us to better manage future changes and other complexity in our software. The purpose of DI is to make code maintainable.

The Dependency Injection pattern uses a builder object to initialize objects and provide the required dependencies to the object means it allows you to "inject" a dependency from outside the class.

For example, Suppose your Client class needs to use a Service class component, then the best you can do is to make your Client class aware of an IService interface rather than a Service class. In this way, you can change the implementation of the Service class at any time (and for how many times you want) without breaking the host code.

We can modify this code by the DI different ways. We have following different ways to implement DI :

Constructor Injection

  1. This is the most common DI.

  2. Dependency Injection is done by supplying the DEPENDENCY through the class’s constructor when instantiating that class.

  3. Injected component can be used anywhere within the class.

  4. Should be used when the injected dependency is required for the class to function.

  5. It addresses the most common scenario where a class requires one or more dependencies.

public interface IService
{
 void Serve();
}
 
public class Service : IService
{
 public void Serve()
 {
 Console.WriteLine("Service Called");
 //To Do: Some Stuff
 }
}
 
public class Client
{
 private IService _service;
 
 public Client(IService service)
 {
 this._service = service;
 }
 
 public void Start()
 {
 Console.WriteLine("Service Started");
 this._service.Serve();
 //To Do: Some Stuff
 }
}
class Program
{
 static void Main(string[] args)
 {
Client client = new Client(new Service());
 client.Start();
 
 Console.ReadKey();
 }
}

The Injection happens in the constructor, by passing the Service that implements the IService-Interface. The dependencies are assembled by a "Builder" and Builder responsibilities are as follows:

  1. knowing the types of each IService

  2. according to the request, feed the abstract IService to the Client

Property injection

  1. Also called Setter injection.

  2. Used when a class has optional dependencies, or where the implementations may need to be swapped. Different logger implementations could be used this way.

  3. May require checking for a provided implementation throughout the class(need to check for null before using it).

  4. Does not require adding or modifying constructors.

public interface IService
{
 void Serve();
}

public class Service : IService
{
 public void Serve()
 {
 Console.WriteLine("Service Called");
 //To Do: Some Stuff
 }
}

public class Client
{
 private IService _service;

 public IService Service
 {
 set
 {
 this._service = value;
 }
 }

 public void Start()
 {
 Console.WriteLine("Service Started");
 this._service.Serve();
 //To Do: Some Stuff
 }
}
class Program
{
 static void Main(string[] args)
 {
 Client client = new Client();
 client.Service = new Service();
 client.Start();

 Console.ReadKey();
 }
}

Method injection

  1. Inject the dependency into a single method, for use by that method.

  2. Could be useful where the whole class does not need the dependency, just the one method.

  3. Generally uncommon, usually used for edge cases.

public interface IService
{
 void Serve();
}

public class Service : IService
{
 public void Serve()
 {
 Console.WriteLine("Service Called");
 //To Do: Some Stuff
 }
}

public class Client
{
 private IService _service;

 public void Start(IService service)
 {
 this._service = service;
 Console.WriteLine("Service Started");
 this._service.Serve();
 //To Do: Some Stuff
 }
}
class Program
{
 static void Main(string[] args)
 {
 Client client = new Client();
 client.Start(new Service());

 Console.ReadKey();
 }
}

Key points about DI

  1. Reduces class coupling

  2. Increases code reusing

  3. Improves code maintainability

  4. Improves application testing

What do you think?

I hope, you will enjoy the various ways of implementing DI pattern. I would like to have feedback from my blog readers. Your valuable feedback, question, or comments about this article are always welcome.



Free Interview Books
 
COMMENTS
Hrushikesh Phapale Reply 236 days 13 hours 56 mins ago

Very nice article.....

Rishi Trivedi Reply 270 days 9 hours 20 mins ago

Nice article. Very helpful to understand DI concept with basic example. There are so many articles but your way of writing is bit different. I also really like your pdfs that you have written for AngularJS and MVC questions. Keep writing.

Chandrasekhar Reply 280 days 6 hours 51 mins ago

Very Nice article with clear examples. Confusion cleared about DI Design pattern. Thanks to author.

Reply 399 days 47 mins ago

1000 thanks. Finally, I understand Dependency Injection. By the way, you write in the article, "The dependencies are assembled by a" Builder "and Builder ansvar are as follows:" What mender you mean, what is a builder? Is it Ninject?

Reply 422 days 8 hours 3 mins ago

This is very nicely created article that is very easy to understand. Excellent.

16 JAN
Developing Microsoft Azure Solutions (Online)
07:00 AM-09:00 AM IST/ 07:30 PM -09:30 PM CST
16 JAN
React with Redux (Online)
07:00 AM-08:30 AM IST
15 JAN
Big Data Hadoop Developer (Online)
05:00 PM to 06:30Pm IST / 06:30AM to 08:00AM CST
8 JAN
ASP.NET Core with Angular4 (Online)
09:00 Pm to 11:00 Pm IST (+5:30Gmt)
8 JAN
Big Data Hadoop Developer (Online)
07:00 AM - 08:30 AM IST(+5:30 GMT)
16 DEC
ASP.NET MVC with Angular4 (Classroom)
10:00 AM - 01::00 PM IST(+5:30 GMT)
12 DEC
ASP.NET MVC with Angular4 (Online)
09:00 PM - 11:00 PM IST(+5:30 GMT)
2 DEC
Developing Microsoft Azure Solutions (Online)
07:00 AM-09:00 AM IST / 08:30 PM Central Time
2 DEC
Angular2+4 with Firebase (Online)
10:30 AM-12:30 PM IST(+5.30 GMT)
27 NOV
ASP.NET Core (Online)
07:00 AM to 09:00 AM IST (+5:30 GMT)
11 NOV
ASP.NET MVC (Online)
08:00 AM-10:00 AM IST / 09:30 PM To 11:30 PM(CST)
16 OCT
ASP.NET Core (Online)
09:00 PM - 11:00 PM IST(+5:30 GMT)
SUBSCRIBE TO OUR YOUTUBE CHANNEL
 
 
 
LIKE US ON FACEBOOK
 
+