Implementing Dependency Injection (IoC Basics)

What is Dependency Injection?

Dependency Injection is a design pattern where an object’s dependencies (services it uses) are provided externally rather than created inside the object.

Benefits of DI:

• Improves testability (e.g., mocking services)
• Reduces coupling between components
• Follows SOLID principles (especially the "D")

Without Dependency Injection

public class MessageService
{
    public void Send() => Console.WriteLine("Sending message...");
}

public class App
{
    private MessageService _service = new MessageService(); // tightly coupled
    public void Run() => _service.Send();
}

With Dependency Injection

We pass the dependency through the constructor (constructor injection):

public interface IMessageService
{
    void Send();
}

public class MessageService : IMessageService
{
    public void Send() => Console.WriteLine("Sending message via DI...");
}

public class App
{
    private readonly IMessageService _service;

    public App(IMessageService service)
    {
        _service = service;
    }

    public void Run() => _service.Send();
}

Using .NET’s Built-in DI Container

Install the package:

dotnet add package Microsoft.Extensions.DependencyInjection

Register and resolve services:

using Microsoft.Extensions.DependencyInjection;

var services = new ServiceCollection();
services.AddTransient<IMessageService, MessageService>();
services.AddTransient<App>();

var provider = services.BuildServiceProvider();
var app = provider.GetRequiredService<App>();
app.Run();

Service Lifetimes

• AddSingleton<T> – One instance for the app lifetime
• AddScoped<T> – One per scope (useful in ASP.NET Core)
• AddTransient<T> – A new instance every time it’s requested

With Dependency Injection, you gain flexibility, modularity, and cleaner code — even in simple console apps. In the next module, we’ll shift into ASP.NET Core and begin building web APIs.