Dependency Injection in C#

Refer this article : https://www.c-sharpcorner.com/article/dependency-injection-in-asp-net-mvc-5

https://www.c-sharpcorner.com/blogs/dependency-injection-di-c-sharp

Dependency Injection (DI) in C# is a design pattern used to provide a class with the dependencies it needs instead of creating them inside the class.

For example, instead of a class creating its own ILogger, the logger is passed through the constructor. This makes the code more flexible, testable, and easier to maintain.

Common types of Dependency Injection are:

• Constructor Injection – dependencies are provided through the constructor.

• .Property Injection – dependencies are assigned through properties.

• Method Injection – dependencies are passed as method parameters.

Dependency Injection (DI) in C# is a simple way to provide an object with the things it needs instead of creating them inside the class itself.

For example, without DI, we might write:

class OrderService
{
    private EmailService emailService = new EmailService();

    public void PlaceOrder()
    {
        emailService.SendEmail();
    }
}

Here, OrderService creates its own EmailService, so both classes are tightly connected.

With Dependency Injection, we can do this:

class OrderService
{
    private readonly EmailService emailService;

    public OrderService(EmailService emailService)
    {
        this.emailService = emailService;
    }

    public void PlaceOrder()
    {
        emailService.SendEmail();
    }
}

Now EmailService is passed into OrderService from outside. This makes the code easier to test and maintain. If we want to replace EmailService with another implementation later, we can do that without changing OrderService.

In simple words, Dependency Injection means “don’t create the dependency yourself let someone else provide it to you.”

ASP.NET Core has built-in support for DI, which makes this approach very easy to use.

Hi Boobalan Thiyagarajan,

Dependency Injection (DI) in C# is a design pattern where one passes dependencies into class instead of class creating them itself.

Example - without DI

public class OrderService
{
    private readonly EmailSender _emailSender = new EmailSender(); // tightly coupled
}

Example - with DI

public class OrderService
{
    private readonly IEmailSender _emailSender;
    public OrderService(IEmailSender emailSender)
    {
        _emailSender = emailSender;
    }
}

Here, OrderService depends on interface (IEmailSender), which makes it easier to test and swap implementations.

Advantages:

• Looser coupling

• Easier maintenance

• Clear dependency graph

• Better testability

Below is one of the best article with complete reference about Dependency Injection in C#

• Understanding Dependency Injection (DI) in .NET Core with Simple Examples

Glad to help! Please mark this answer as the accepted answer if it helped you out!