Dependency Injection Pattern

pendency 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

Façade defines

Definition

Provide a unified interface to a set of interfaces in a subsystem. Façade defines a higher-level interface that makes the subsystem easier to use.

Frequency of use:

High

---

UML class diagram

---

Participants

    The classes and objects participating in this pattern are:

• Facade   (MortgageApplication)
  • knows which subsystem classes are responsible for a request.
  • delegates client requests to appropriate subsystem objects.
• Subsystem classes   (Bank, Credit, Loan)
  • implement subsystem functionality.
  • handle work assigned by the Facade object.
  • have no knowledge of the facade and keep no reference to it.

---

Structural code in C#

This structural code demonstrates the Facade pattern which provides a simplified and uniform interface to a large subsystem of classes.

                 





using System;










namespace DoFactory.GangOfFour.Facade.Structural




{




  /// <summary>




  /// MainApp startup class for Structural




  /// Facade Design Pattern.




  /// </summary>




  class MainApp




  {




    /// <summary>




    /// Entry point into console application.




    /// </summary>




    public static void Main()




    {




      Facade facade = new Facade();










      facade.MethodA();




      facade.MethodB();










      // Wait for user




      Console.ReadKey();




    }




  }










  /// <summary>




  /// The 'Subsystem ClassA' class




  /// </summary>




  class SubSystemOne




  {




    public void MethodOne()




    {




      Console.WriteLine(" SubSystemOne Method");




    }




  }










  /// <summary>




  /// The 'Subsystem ClassB' class




  /// </summary>




  class SubSystemTwo




  {




    public void MethodTwo()




    {




      Console.WriteLine(" SubSystemTwo Method");




    }




  }










  /// <summary>




  /// The 'Subsystem ClassC' class




  /// </summary>




  class SubSystemThree




  {




    public void MethodThree()




    {




      Console.WriteLine(" SubSystemThree Method");




    }




  }










  /// <summary>




  /// The 'Subsystem ClassD' class




  /// </summary>




  class SubSystemFour




  {




    public void MethodFour()




    {




      Console.WriteLine(" SubSystemFour Method");




    }




  }










  /// <summary>




  /// The 'Facade' class




  /// </summary>




  class Facade




  {




    private SubSystemOne _one;




    private SubSystemTwo _two;




    private SubSystemThree _three;




    private SubSystemFour _four;










    public Facade()




    {




      _one = new SubSystemOne();




      _two = new SubSystemTwo();




      _three = new SubSystemThree();




      _four = new SubSystemFour();




    }










    public void MethodA()




    {




      Console.WriteLine("\nMethodA() ---- ");




      _one.MethodOne();




      _two.MethodTwo();




      _four.MethodFour();




    }










    public void MethodB()




    {




      Console.WriteLine("\nMethodB() ---- ");




      _two.MethodTwo();




      _three.MethodThree();




    }




  }




}


 
        
            

Output

MethodA() ----
SubSystemOne Method
SubSystemTwo Method
SubSystemFour Method

MethodB() ----
SubSystemTwo Method
SubSystemThree Method

---

Real-world code in C#

This real-world code demonstrates the Facade pattern as a MortgageApplication object which provides a simplified interface to a large subsystem of classes measuring the creditworthyness of an applicant.

                 





using System;










namespace DoFactory.GangOfFour.Facade.RealWorld




{




  /// <summary>




  /// MainApp startup class for Real-World 




  /// Facade Design Pattern.




  /// </summary>




  class MainApp




  {




    /// <summary>




    /// Entry point into console application.




    /// </summary>




    static void Main()




    {




      // Facade




      Mortgage mortgage = new Mortgage();










      // Evaluate mortgage eligibility for customer




      Customer customer = new Customer("Ann McKinsey");




      bool eligible = mortgage.IsEligible(customer, 125000);










      Console.WriteLine("\n" + customer.Name +




          " has been " + (eligible ? "Approved" : "Rejected"));










      // Wait for user




      Console.ReadKey();




    }




  }










  /// <summary>




  /// The 'Subsystem ClassA' class




  /// </summary>




  class Bank




  {




    public bool HasSufficientSavings(Customer c, int amount)




    {




      Console.WriteLine("Check bank for " + c.Name);




      return true;




    }




  }










  /// <summary>




  /// The 'Subsystem ClassB' class




  /// </summary>




  class Credit




  {




    public bool HasGoodCredit(Customer c)




    {




      Console.WriteLine("Check credit for " + c.Name);




      return true;




    }




  }










  /// <summary>




  /// The 'Subsystem ClassC' class




  /// </summary>




  class Loan




  {




    public bool HasNoBadLoans(Customer c)




    {




      Console.WriteLine("Check loans for " + c.Name);




      return true;




    }




  }










  /// <summary>




  /// Customer class




  /// </summary>




  class Customer




  {




    private string _name;










    // Constructor




    public Customer(string name)




    {




      this._name = name;




    }










    // Gets the name




    public string Name




    {




      get { return _name; }




    }




  }










  /// <summary>




  /// The 'Facade' class




  /// </summary>




  class Mortgage




  {




    private Bank _bank = new Bank();




    private Loan _loan = new Loan();




    private Credit _credit = new Credit();










    public bool IsEligible(Customer cust, int amount)




    {




      Console.WriteLine("{0} applies for {1:C} loan\n",




        cust.Name, amount);










      bool eligible = true;










      // Check creditworthyness of applicant




      if (!_bank.HasSufficientSavings(cust, amount))




      {




        eligible = false;




      }




      else if (!_loan.HasNoBadLoans(cust))




      {




        eligible = false;




      }




      else if (!_credit.HasGoodCredit(cust))




      {




        eligible = false;




      }










      return eligible;




    }




  }




}


 
 
       
            

Output

Ann McKinsey applies for $125,000.00 loan

Check bank for Ann McKinsey
Check loans for Ann McKinsey
Check credit for Ann McKinsey

Ann McKinsey has been Approved