Dependency Injection C# Interview Questions

Share on facebook
Facebook
Share on twitter
Twitter
Share on linkedin
LinkedIn
24-Hour Flash Sale. Courses from just $12.99

Never miss a post!

Sign up for our newsletter and get FREE Development Trends delivered directly to your inbox.

You can unsubscribe any time. Terms & Conditions.
Categories

ASP.NET Core supports the Dependency Injection (DI) to achieve Inversion of Control. It has a built-in DI container for internal services. Dependency Injection helps you to develop decoupled software application through constructor or property injection. The main idea behind DI is that a class should depend on abstractions rather than concrete implementations of classes.

Define What Is Dependency Injection

In real word, dependency means to rely on other things for the support. Before moving towards dependency injection, you must know what dependency in the programming is. If class A is using some functionality of the class B, which means you can say that the class A has a dependency on a class B to complete its functionality. Dependency Injection helps you to produce a loosely coupled code, which means that the two objects must be independent and both can use each other without having any dependency on each other.  The DI should handle if there is any change in the class without affecting the other objects. The software should not have any static or hard-coded configurations, but it should be done at run-time. It is a design pattern makes loosely coupled software components and reduces the risk of changing inter-connected dependencies if there is a change in just one object.

Provide An Overview Of How Dependency Injection Works

Dependency Injection is a technique to remove the dependencies of one class on another by making it independent and decouple the usage of shared objects. It uses a builder object to initialize the objects and injects the dependency from outside the class by providing the required dependencies.

Dependency Injection has the following responsibilities:

  • Create the objects of classes
  • Keep a track of classes that have dependency on other classes
  • Provide all the objects that are required by the classes to complete the functionality

What Are The Different Ways To Implement Dependency Injection.

Dependency Injection is a design pattern that allows you to implement IoC. Let us take an example of Account class, which has references to the Current Account and Saving Account.

public class SavingAccount  
{  
    public void GetData()  
    {  
        Console.WriteLine("Get Saving Account Data.");  
    }  
}  
  
public class CurrentAccount  
{  
    public void GetData()  
    {  
        Console.WriteLine("Get Current Account Data.");  
    }  
}  
//CustomerAccount is tightly dependent on Saving and Current Account classes 
public class CustomerAccount  
{  
    // Create object of the class SavingAccount


    SavingAccount objSavingAccount = new SavingAccount();  
  
    // Create object of the class CurrentAccount
    CurrentAccount objCurrentAccount = new CurrentAccount();  
  
    public void GetAccountData()  
    {  
        objSavingAccount.GetData();  
        objCurrentAccount.GetData();  
    }  
}   
public class Program  
{  
    static void Main(string[] args)  
    {  
        CustomerAccount objCustomerAccount = new CustomerAccount();  
        account.GetAccountData(); 
 
        Console.ReadLine();  
    }  
}

Constructor Injection

The Constructor Injection uses a parameter to inject dependencies in a class. This is the most common method of Dependency Pattern; therefore, there is one parameterized constructor but no default constructor and you need to pass the specified values to the constructor.

//Create ICustomerAccount  interface to decouple the objects  
public interface ICustomerAccount  
{  
    void GetData ();  
}  
  
//Implemented the IAccount interface in SavingAccount class  
public class SavingAccount  : ICustomerAccount  
{  
    public void GetData()  
    {  
        Console.WriteLine("Get Saving Account Data.");  
    }  
}  
  
public class CurrentAccount  : ICustomerAccount  
{  
    public void GetData()  
    {  
        Console.WriteLine("Get Current Account Data.");  
    }  
}  
  
public class CustomerAccount  
{  
    private ICustomerAccount  CustomerAccount;  
  
    //Passing ICustomerAccount  interface as a parameter 
    public Account(ICustomerAccount  account)  
    {  
        this.CustomerAccount = account;  
    }  
  
    public void GetAccountData()  
    {  
        CustomerAccount.GetData();  
    }  
}  
  
class Program  
{  
    static void Main()  
    {  
        //Create an object of SavingAccount() and  pass it to CustomerAccount constructor  
        ICustomerAccount savingAccount = new SavingAccount();  
        CustomerAccount account = new CustomerAccount (savingAccount);  
        account.GetAccountData();  
  
        //Create an object of CurrentAccount() and  pass it to CustomerAccount constructor  
        ICustomerAccount currentAccount = new CurrentAccount();  
        account = new CustomerAccount(currentAccount);  
        account.GetAccountData();  

        Console.ReadLine();  
    }  
}  

Setter Injection

The Setter Injection allows you to remove the dependencies through the properties of a class

public class CustomerAccount  
{  
    public ICustomerAccount  CustomerAccount {get; set;} 
    public void GetAccountData()  
    {  
        CustomerAccount.GetData();  
    }  
}  

class Program  
{  
    static void Main()  
    {  
        //Create an object of SavingAccount() and assign it to the property  
        CustomerAccount account = new CustomerAccount (); 
        account.CustomerAccount = new SavingAccount();
        account.GetAccountData();  
  
        //Create an object of CurrentAccount() and assign it to the property  
        CustomerAccount account = new CustomerAccount (); 
        account.CustomerAccount = new CurrentAccount();
        account.GetAccountData();  

        Console.ReadLine();  
    }  
}  

Interface-based injection

In Interface-based Injection, the injection is made directly into class through a method.

//Create ICustomerAccount  interface to decouple the objects  
public interface ICustomerAccount  
{  
    void GetData ();  
}  
  
//Implemented the IAccount interface in SavingAccount class  
public class SavingAccount  : ICustomerAccount  
{  
    public void GetData()  
    {  
        Console.WriteLine("Get Saving Account Data.");  
    }  
}  
  
public class CurrentAccount  : ICustomerAccount  
{  
    public void GetData()  
    {  
        Console.WriteLine("Get Current Account Data.");  
    }  
}  
  
public class CustomerAccount  
{  
    public void GetAccountData(ICustomerAccount  account)  
    {  
        account.GetData();  
    }  
}  
  
class Program  
{  
    static void Main()  
    {  
        //Create an object of SavingAccount() and  pass it to the method 
        CustomerAccount account = new CustomerAccount ();  
        account.GetAccountData(new SavingAccount());  
  
        //Create an object of CurrentAccount() and  pass it to the method 
        CustomerAccount account = new CustomerAccount ();  
        account.GetAccountData(new CurrentAccount());  

        Console.ReadLine();  
    }  
}

Service Locator Injection

Service Locator is a different injection pattern, which can return strong or generic type object. It helps you to locate the service. It suggests not creating an object of one class into another.

public interface IEmailService  
{  
    void ExecuteEmailService();  
}  

public class EmailService : IEmailService  
{  
     public void ExecuteEmailService ()  
     {  
         Console.WriteLine("Executing Email Service");  
     }  
}  

public static class ServiceLocator  
{  
    public static IEmailService  objService = null;  
          
    //Service locator function returning strong type   
    public static IEmailService  SetLocation(IEmailService  tmpser)  
    {  
        if (objService == null) return new EmailService ();  
            return objService;  
    }  
          
    //Execute service  
    public static void ExecuteEmailService ()  
    {  
            objService.ExecuteEmailService();  
    }  
}     

class Program  
{  
    static void Main(string[] args)  
    {  
       IEmailService svr =  EmailServiceLocator.SetLocation(new EmailService());  
       svr.ExecuteEmailService();  

       Console.ReadLine();  
    }  
}  

What Are The Advantages Of Dependency Injection

Dependency Injection has several benefits; some of them are listed below:

  • Maintainability

It helps in maintaining the code structure of a program. It is relatively easier to follow single principle.

  • Flexibility

It helps you in achieving the loosely coupled code, which makes it flexible to use in different ways.

  • Testability

It is easy to do the unit testing with different mock implementations when there are no tightly coupled objects.

  • Readability

The classes are well defined by having logic in constructors, openly declaring what is written in it.

What Are The Disadvantages Of Dependency Injection

  • Complexity

The Dependency Injection follows the Single Responsilibity Principle, the complexity of the program increases as it has more classes.

  • Runtime Errors

The Dependency Injection can have circular dependencies, bad bindings, etc. if the configurations are not done correctly. Such errors will not be catch at compile time.

  • DI Framework

If you are using any DI Framework to handle the code, your code is limited to the framework.

Difference Between Dependency Injection And Factory Pattern

Factory Patterns are responsible for creating the objects or instances of classes, whereas Dependency Injection is more likely to be concerned with the loose coupling and Inversion of Control.

Factory Pattern is like a tool to implement Dependency Injection, as it is a way to separate the responsibility of creating instances of classes, whereas DI is more like an architectural pattern for loosely coupled software programming.

Share on facebook
Facebook
Share on twitter
Twitter
Share on linkedin
LinkedIn

Our website uses cookies that help it to function, allow us to analyze how you interact with it, and help us to improve its performance. By using our website you agree by our Terms and Conditions and Privacy Policy.