.NET  

Understanding Dependency Injection in .NET with Practical Examples

Introduction

Dependency Injection (DI) is one of the most important concepts in modern .NET development. It helps developers write loosely coupled, testable, and maintainable code. With the introduction of .NET Core and later .NET versions, Dependency Injection is built into the framework, making it easy to implement without third-party libraries.

In this article, we will understand:

  • What Dependency Injection is

  • Why do we need it

  • Types of Dependency Injection

  • How to implement DI in .NET with real examples

What Is Dependency Injection?

Dependency Injection is a design pattern where an object receives its dependencies from an external source rather than creating them itself.

Without Dependency Injection

public class EmailService
{
    public void SendEmail(string message)
    {
        Console.WriteLine("Email sent: " + message);
    }
}

public class Notification
{
    private EmailService _emailService = new EmailService();

    public void Notify()
    {
        _emailService.SendEmail("Hello User");
    }
}

Problems with This Approach

  • Tight coupling between classes

  • Difficult to unit test

  • Hard to replace or extend functionality

Dependency Injection Approach

With Dependency Injection, dependencies are injected, not created.

public interface IEmailService
{
    void SendEmail(string message);
}

public class EmailService : IEmailService
{
    public void SendEmail(string message)
    {
        Console.WriteLine("Email sent: " + message);
    }
}

public class Notification
{
    private readonly IEmailService _emailService;

    public Notification(IEmailService emailService)
    {
        _emailService = emailService;
    }

    public void Notify()
    {
        _emailService.SendEmail("Hello User");
    }
}

Built-In Dependency Injection in .NET

.NET provides a built-in DI container through Microsoft.Extensions.DependencyInjection.

Registering Services

In Program.cs:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddScoped<IEmailService, EmailService>();
builder.Services.AddScoped<Notification>();

var app = builder.Build();

Using the Service

public class HomeController : Controller
{
    private readonly Notification _notification;

    public HomeController(Notification notification)
    {
        _notification = notification;
    }

    public IActionResult Index()
    {
        _notification.Notify();
        return View();
    }
}

Types of Dependency Injection

1. Constructor Injection (Recommended)

  • Dependencies are provided through the constructor

  • Most commonly used in .NET

2. Property Injection

  • Dependencies are set through public properties

  • Less preferred due to optional dependencies

3. Method Injection

  • Dependencies are passed through method parameters

  • Useful in specific scenarios

Service Lifetimes in .NET

.NET supports three service lifetimes:

1. Transient

  • New instance every time

builder.Services.AddTransient<IEmailService, EmailService>();

2. Scoped

  • One instance per request (recommended for web apps)

builder.Services.AddScoped<IEmailService, EmailService>();

3. Singleton

  • One instance for the entire application

builder.Services.AddSingleton<IEmailService, EmailService>();

Advantages of Dependency Injection

  • Loose coupling

  • Improved testability

  • Better code maintainability

  • Easy to extend and modify

  • Built-in support in .NET

Conclusion

Dependency Injection is a core concept every .NET developer should master. With built-in support in modern .NET, implementing DI is straightforward and highly beneficial. By following DI principles, your applications become cleaner, more testable, and easier to maintain.

Membership not found