Dependency Injection: Part 1

In this Article I am going to discuss about "Dependency injection" on which I am working and exploring. In this article I am going to discuss about what is dependency injection and why there is need of this software design pattern.

Dependency injection

To understand dependency injection better way, let’s consider below code,

Public class client  
{  
     Public static void main()  
     {  
        NeedDependencyClass a = new NeedDependencyClass();  
     }  
}  
  
public class NeedDependencyClass  
{  
  Private readonly DependencyClass _b;  
  public NeedDependencyClass ()  
  {  
     _b = new DependencyClass();  
  }  
  public void Test()  
  {  
     _b.Test();  
  }  
}  
  
public class DependencyClass  
{  
  public void Test()  
  {  
    // code for text method  
  }  
}  

In above code class client creates NeedDependencyClass and use it, then class NeedDependencyClass consume service of class DependencyClass to perform task i.e. class NeedDependencyClass is depend on class DependencyClass to perform task. This kind of the code is hardcoded dependency.

Image above shows the representation of creation and use of the objects.

1. Class NeedDependencyClass itself responsible for creating its own dependency.
2. Code is tightly coupled, because dependency cannot be replaceable.
3. Code also violate “Open Closed” rule of SOLID principal which says that "software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification". Because do changes in the Test method I need to modify DependencyClass.
4. Testing of Class NeedDependencyClass becomes difficult as I cannot replace Dependency class DependencyClass with other dependency.

Dependency injection is software development pattern which introduced to resolve above problems.

Definition of this pattern is: Remove hard coded dependency and make it possible to replace at run-time or compile time.

In following section I am going to describe how problem listed above get resolved with the Dependency injection pattern.

Solution

1)Make client i.e. first class in dependency graph which consume service to create all dependent object

Resolution to the first problem of code above, pass the responsibility of supplying all required dependency to the first in dependency graph i.e. client class which is first class of the dependency graph.

So the code will change like this

Public class client  
{  
     Public static void main()  
     {  
        NeedDependencyClass a = new NeedDependencyClass(new DependencyClass());  
      }  
}  
  
public class NeedDependencyClass  
{  
  Private readonly DependencyClass _b;  
  public NeedDependencyClass(DependencyClass b)  
  {  
     _b = b;  
  }  
  public void Test()  
  {  
     _b.Test();  
  }  
}  
  
public class DependencyClass  
{  
  public void Test()  
  {  
    // code for text method  
  }  
}  

Image below shows object creation only done by client class object and others class down the line use supplied defendant object.

2)Removes tight coupling between object i.e allow to define loose coupling

To understand the second problem better way, let’s consider with the real life scenario of Computer or laptop.

As you can see in the above image we have the port for each device external device to which I can associate external device and do our work.

But problem with this is I cannot attach my keybord on printer port and vice versa, same problem occurs with the other devices. So this is like tight coupling that I cannot change my external device on the give interface i.e. on which I am depends.

Solution to this is USB port.

If I have USB port than I can easily attach any device to my machine and perform my task.

What is tight coupling between classes? (In programming)

Let start with simple example:

public class NeedDependencyClass  
{  
  Private readonly DependencyClass _b;  
  public NeedDependencyClass(DependencyClass b)  
  {  
     _b = b;  
  }  
  public void Test()  
  {  
     _b.Test();  
  }  
}  
  
public class DependencyClass  
{  
  public void Test()  
  {  
    // code for text method  
  }  
}  

Now as you see in above code class NeedDependencyClass utilized class DependencyClass, this means that class NeedDependencyClass is depend on class DependencyClass. This type of dependency is tight dependency between class NeedDependencyClass and class DependencyClass. Because class DependencyClass is passed as parameter to class NeedDependencyClass and class NeedDependencyClass utilizing method of class DependencyClass. Now if the why it called as tightly coupled. If code is like this to create

NeedDependencyClass a = new NeedDependencyClass(new DependencyClass());   

now if I created class DependencyClass1 like as follows public

class DependencyClass1 {   
      public void Test()   
      { //code for text method }   
}