Dependency Injection (Constructor Injection) In C#

Before starting to discuss Constructor Injection, let’s discuss Dependency Injection. What exactly it is? What is the use of it?

 

Dependency Injection is a Software Design Pattern (Answer of What). It allows developing loosely coupled code (Answer of Why). Now a days most of the enterprise level application is on Microservices architecture, in this type of architecture we treat each component separately. It means that we are not developing code tightly coupled. The purpose of DI is to make code maintainable and easy to update.

 

In addition, an object’s dependencies should be on interfaces instead of concrete objects. So, what is concrete object? An object created with "new" keyword is a concrete object. Through loose coupling, you are able to achieve better maintainability and greater reusability.

 

We can implement Dependency Injection in 3 ways. These are also called types of Dependency Injection.

• Constructor Injection
• Property/Setter Injection
• Method Injection

In this article, we are going to discuss Constructor Injection.

 

Advantages

• This is widely used to implement Dependency Injection
• This is done by supplying the dependency through the class at the time of creating the instance/object of class
• There can be the case when we need to use multiple dependency, at that time Constructor Injection solve this most common scenario
• The component which is injected in the class get access within the class and can get used within the class

Check the Below code,

public interface IFacility
{
    void DoSomething();
}
public class Transport : IFacility
{
    public void DoSomething() { Console.WriteLine("Transport Service Called"); }
}
public class Utility : IFacility
{
    public void DoSomething() { Console.WriteLine("Utility Service Called"); }
}
public class Facility
{
    private IFacility _service;
    public Facility(IFacility service)
    {
        this._service = service;
    }
    public ShowOutputMethod() { this._service.DoSomething(); }
}

Here we have inherited the same interface with different implementation in different classes. Now we will try to call this with the help of Constructor Injection

class Program
{
    static void Main(string[] args)
    {
        //creating object
        Transport objT = new Transport();
        //passing dependency
        Facility c1 = new Facility(objT);

        Utility objU = new Utility();
        //passing dependency
        c1 = new Facility(objU);

    }
}

This is the overall implementation of the Constructor injection. Let’s check multiple dependency in a single constructor

public interface IEmail
{
    void SendEmail();
}
public class EmailCommunication : IEmail
{
    public void SendEmail() { Console.WriteLine("Email Sent Successfully"); }
}

Now let’s rewrite the Facility class

public class Facility
{
    private IFacility _service;
    private IEmail _emailService;
    public Facility(IFacility service)
    {
        this._service = service;

    }

    public Facility(IFacility service, IEmail emailService)
    {
        this._service = service;
     this._emailService = emailService;

    }

    public ShowOutputMethod() { this._service.DoSomething(); }
public SendEmailMethod() { this._emailService.SendEmail(); }

}

And use it in Main Program

class Program
{
    static void Main(string[] args)
    {
        //creating object
        Transport objT = new Transport();
 EmailCommunication objEmail = new EmailCommunication();
        //passing dependency
        Facility c1 = new Facility(objT, objEmail);

        Utility objU = new Utility();
        //passing dependency
        c1 = new Facility(objU);

    }
}

This way we can use same class with single or multiple dependencies.

 

The Injection happens in the constructor, bypassing the Facility that implements the IFacility Interface. The dependencies are assembled according to the request, feed the abstract IFacility to the Client.

 

--Happy Coding--