Skip to content

Dependency Injection in .NET

Introduction to Dependency Injection

Dependency Injection (DI) is a design pattern that facilitates the decoupling of components in a system. Instead of a class creating its own dependencies, these dependencies are injected into the class from an external source. This inversion of control enhances modularity, testability, and maintainability.

Key Terms

  • Dependency: An object that another object relies on.

  • Injection: The process of providing dependencies to a class.

  • Inversion of Control (IoC): A principle where the control of object creation and binding is transferred from the object itself to an external entity.

Why Dependency Injection Matters in ASP.NET Core ?

ASP.NET Core is built with DI at its core. Leveraging DI in your applications offers several benefits:

  • Loose Coupling: Components are less dependent on each other, making it easier to modify or replace them without affecting others.

  • Enhanced Testability: Dependencies can be mocked or stubbed during testing, facilitating unit testing.

  • Maintainability: Clear separation of concerns makes the codebase easier to manage and extend.

  • Flexibility: Easily swap out implementations without changing the consuming code.

ASP.NET Core provides a built-in DI container that is simple yet powerful enough for most applications. Understanding how to effectively use this container is crucial for any ASP.NET Core developer.

Types of Dependency Injection

There are three primary types of Dependency Injection:

  • Constructor Injection

  • Property Injection

  • Method Injection

Each has its use cases, advantages, and limitations. Let’s explore them in detail with examples.

Constructor Injection

Constructor Injection is the most common form of DI. Dependencies are provided through a class’s constructor.

How It Works:

  • Define dependencies as parameters in the constructor.

  • The DI container resolves these dependencies and injects them when creating an instance of the class.

Example:

Imagine you have a service that sends notifications and another service that logs activities.

// Define the interfaces
public interface INotificationService
{
    void Send(string message);
}

public interface ILoggerService
{
    void Log(string message);
}

// Implement the interfaces
public class EmailNotificationService : INotificationService
{
    public void Send(string message)
    {
        // Logic to send email
        Console.WriteLine($"Email sent: {message}");
    }
}

public class LoggerService : ILoggerService
{
    public void Log(string message)
    {
        // Logic to log messages
        Console.WriteLine($"Log entry: {message}");
    }
}

// Consumer class using constructor injection
public class OrderController : ControllerBase
{
    private readonly INotificationService _notificationService;
    private readonly ILoggerService _loggerService;

    public OrderController(INotificationService notificationService, ILoggerService loggerService)
    {
        _notificationService = notificationService;
        _loggerService = loggerService;
    }

    public IActionResult CreateOrder(Order order)
    {
        // Business logic to create order
        _notificationService.Send("Order created successfully.");
        _loggerService.Log("Order creation logged.");
        return Ok();
    }
}

Use Case:

Use constructor injection when:

  • The dependency is mandatory for the class to function.

  • You want to ensure that the dependency is available and initialized before the class is used.

  • When you have multiple dependencies, promoting immutability.

Advantages:

  • Clear declaration of dependencies.

  • Ensures dependencies are not null.

  • Promotes immutability and thread-safety.

Limitations:

  • Can lead to constructor overload if there are too many dependencies.

  • Not suitable for optional dependencies.

Property Injection

Property Injection involves setting dependencies through public properties rather than constructors.

How It Works:

  • Define a public property for the dependency.

  • The DI container sets the property after the object is created.

Example:

// Consumer class using property injection
public class OrderController : ControllerBase
{
    public INotificationService NotificationService { get; set; }
    public ILoggerService LoggerService { get; set; }

    public IActionResult CreateOrder(Order order)
    {
        // Ensure services are injected
        if (NotificationService == null || LoggerService == null)
        {
            throw new InvalidOperationException("Dependencies not injected.");
        }

        // Business logic to create order
        NotificationService.Send("Order created successfully.");
        LoggerService.Log("Order creation logged.");
        return Ok();
    }
}

Use Case:

Use property injection when:

  • The dependency is optional.

  • You need to inject dependencies after object creation.

  • When using frameworks that support property injection.

Advantages:

  • Flexibility to set dependencies after object creation.

  • Suitable for optional dependencies.

Limitations:

  • Dependencies can be left unset, leading to runtime errors.

  • Less clear declaration of dependencies compared to constructor injection.

  • Not inherently thread-safe.

Method Injection

Method Injection involves passing dependencies directly through method parameters.

How It Works:

  • Define dependencies as parameters in the method that requires them.

  • The DI container provides the dependencies when the method is called.

Example:

// Consumer class using method injection
public class OrderController : ControllerBase
{
    private readonly ILoggerService _loggerService;

    public OrderController(ILoggerService loggerService)
    {
        _loggerService = loggerService;
    }

    public IActionResult CreateOrder(Order order, [FromServices] INotificationService notificationService)
    {
        // Business logic to create order
        notificationService.Send("Order created successfully.");
        _loggerService.Log("Order creation logged.");
        return Ok();
    }
}

Use Case:

Use method injection when:

  • The dependency is only needed within a specific method.

  • You want to limit the scope of the dependency.

  • Avoiding constructor overload for rarely used dependencies.

Advantages:

  • Limits the scope of dependencies to where they are needed.

  • Reduces constructor clutter.

Limitations:

  • Less intuitive and harder to track dependencies.

  • Not suitable for dependencies that are used across multiple methods.

Understanding Service Lifetimes

In ASP.NET Core, the DI container manages the lifetimes of services. Choosing the appropriate lifetime is crucial for application performance and correctness. The three primary service lifetimes are:

  1. Transient

  2. Scoped

  3. Singleton

Transient

Definition: A new instance of the service is created every time it’s requested.

Use Cases:

  • Lightweight, stateless services.

  • Services that do not hold any shared state.

Example Registration:

services.AddTransient<IMyService, MyService>();

Example:

public interface IGuidService
{
    Guid GetGuid();
}

public class GuidService : IGuidService
{
    private readonly Guid _guid;

    public GuidService()
    {
        _guid = Guid.NewGuid();
    }

    public Guid GetGuid()
    {
        return _guid;
    }
}

// Registration
services.AddTransient<IGuidService, GuidService>();

Behavior:

Each time IGuidService is injected, a new GuidService instance is created with a unique GUID.

Scoped

Definition: A new instance is created once per request.

Use Cases

  • Services that should maintain state within a single request but not across requests.

  • Database contexts, unit of work patterns.

Example Registration:

services.AddScoped<IMyService, MyService>();

Example:

public interface IOrderService
{
    void PlaceOrder(Order order);
}

public class OrderService : IOrderService
{
    private readonly Guid _guid;

    public OrderService()
    {
        _guid = Guid.NewGuid();
    }

    public void PlaceOrder(Order order)
    {
        // Use _guid to track operations within the same request
        Console.WriteLine($"Order placed with service ID: {_guid}");
    }
}

// Registration
services.AddScoped<IOrderService, OrderService>();

Behavior:

Within a single HTTP request, all IOrderService injections receive the same OrderService instance. Across different requests, new instances are created.

Singleton

Definition: A single instance is created once and shared throughout the application’s lifetime.

Use Cases:

  • Services that maintain shared state or configuration.

  • Caching, logging, and other cross-cutting concerns.

Example Registration:

services.AddSingleton<IMyService, MyService>();

Example:

public interface IConfigurationService
{
    string GetConfiguration();
}

public class ConfigurationService : IConfigurationService
{
    private readonly string _configValue;

    public ConfigurationService()
    {
        _configValue = "Application Configuration";
    }

    public string GetConfiguration()
    {
        return _configValue;
    }
}

// Registration
services.AddSingleton<IConfigurationService, ConfigurationService>();

Behavior:

All injections of IConfigurationService receive the same ConfigurationService instance with the same _configValue.

Choosing the Right Lifetime

  • Transient: When services are lightweight and stateless.

  • Scoped: When services need to maintain state within a single request.

  • Singleton: When services need to maintain state across the entire application lifecycle.

Registering and Consuming Services in Controllers

To utilize DI in your ASP.NET Core controllers, you need to:

  • Define Service Interfaces and Implementations

  • Register Services with the DI Container

  • Inject Services into Controllers

Let’s walk through these steps with a detailed example.

Step 1: Define Service Interfaces and Implementations

Example: Logging Service

// Define the interface
public interface ILoggerService
{
    void Log(string message);
}

// Implement the interface
public class LoggerService : ILoggerService
{
    public void Log(string message)
    {
        // In a real application, you might write to a file, database, etc.
        Console.WriteLine($"Log: {message}");
    }
}

Step 2: Register Services with the DI Container

Registration is typically done in the Program.cs file (for .NET 6 and above) or Startup.cs (for earlier versions).

Example: Registering LoggerService as Singleton

var builder = WebApplication.CreateBuilder(args);

// Register services
builder.Services.AddSingleton<ILoggerService, LoggerService>();

// Add controllers
builder.Services.AddControllers();

var app = builder.Build();

// Configure the HTTP request pipeline.
app.UseRouting();

app.MapControllers();

app.Run();

Step 3: Inject Services into Controllers

Use constructor injection to receive the service in your controller.

Example: Using LoggerService in a Controller

[ApiController]
[Route("api/[controller]")]
public class OrdersController : ControllerBase
{
    private readonly ILoggerService _loggerService;

    // Constructor Injection
    public OrdersController(ILoggerService loggerService)
    {
        _loggerService = loggerService;
    }

    [HttpPost]
    public IActionResult CreateOrder(Order order)
    {
        // Business logic to create order
        _loggerService.Log($"Order created with ID: {order.Id}");
        return Ok(new { Message = "Order created successfully." });
    }
}

Explanation:

  • The OrdersController depends on ILoggerService.

  • ASP.NET Core’s DI container automatically injects an instance of LoggerService when creating the controller.

Building Custom Services

Creating custom services allows you to encapsulate specific functionalities, making your application modular and easier to maintain. Let’s build a custom service that manages user information.

Step 1: Define the Service Interface

public interface IUserService
{
    User GetUserById(int id);
    IEnumerable<User> GetAllUsers();
    void AddUser(User user);
}

Step 2: Implement the Service

public class UserService : IUserService
{
    // In-memory user store for demonstration purposes
    private readonly List<User> _users = new List<User>
    {
        new User { Id = 1, Name = "Alice Johnson", Email = "[email protected]" },
        new User { Id = 2, Name = "Bob Smith", Email = "[email protected]" }
    };

    public User GetUserById(int id)
    {
        return _users.FirstOrDefault(u => u.Id == id);
    }

    public IEnumerable<User> GetAllUsers()
    {
        return _users;
    }

    public void AddUser(User user)
    {
        _users.Add(user);
    }
}

Step 3: Register the Service

Decide on the appropriate service lifetime. For UserService, Scoped is appropriate since it might involve data operations within a request.

var builder = WebApplication.CreateBuilder(args);

// Register services
builder.Services.AddScoped<IUserService, UserService>();

// Add controllers
builder.Services.AddControllers();

var app = builder.Build();

// Configure the HTTP request pipeline.
app.UseRouting();

app.MapControllers();

app.Run();

Step 4: Inject and Use the Service in a Controller

[ApiController]
[Route("api/[controller]")]
public class UsersController : ControllerBase
{
    private readonly IUserService _userService;

    // Constructor Injection
    public UsersController(IUserService userService)
    {
        _userService = userService;
    }

    // GET: api/users
    [HttpGet]
    public IActionResult GetAllUsers()
    {
        var users = _userService.GetAllUsers();
        return Ok(users);
    }

    // GET: api/users/1
    [HttpGet("{id}")]
    public IActionResult GetUserById(int id)
    {
        var user = _userService.GetUserById(id);
        if (user == null)
            return NotFound();

        return Ok(user);
    }

    // POST: api/users
    [HttpPost]
    public IActionResult AddUser(User user)
    {
        _userService.AddUser(user);
        return CreatedAtAction(nameof(GetUserById), new { id = user.Id }, user);
    }
}

Explanation:

  • The UsersController depends on IUserService.

  • By injecting IUserService, the controller can perform user-related operations without worrying about the underlying implementation.

Lab: Implementing Dependency Injection in an ASP.NET Core Application

To reinforce your understanding, let’s walk through a hands-on lab where you’ll set up DI in a new ASP.NET Core application.

Scenario:

Create an ASP.NET Core Web API that manages books in a library. Implement services to handle book data and logging, and inject these services into your controllers.

Step 1: Create a New ASP.NET Core Web API Project

Using Visual Studio:

  • Open Visual Studio.

  • Select Create a new project.

  • Choose ASP.NET Core Web API and click Next.

  • Configure the project name (e.g., LibraryAPI) and click Create.

  • Select .NET 8 as the target framework and click Create.

Using Command Line:

dotnet new webapi -n LibraryAPI
cd LibraryAPI

Step 2: Define the Models

Create a Models folder and add the Book class.

// Models/Book.cs
public class Book
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string Author { get; set; }
}

Step 3: Define Service Interfaces

Create a Services folder and add the following interfaces.

// Services/IBookService.cs
public interface IBookService
{
    IEnumerable<Book> GetAllBooks();
    Book GetBookById(int id);
    void AddBook(Book book);
    void DeleteBook(int id);
}

// Services/ILoggerService.cs
public interface ILoggerService
{
    void Log(string message);
}

Step 4: Implement the Services

// Services/BookService.cs
public class BookService : IBookService
{
    private readonly List<Book> _books = new List<Book>
    {
        new Book { Id = 1, Title = "1984", Author = "George Orwell" },
        new Book { Id = 2, Title = "To Kill a Mockingbird", Author = "Harper Lee" }
    };

    public IEnumerable<Book> GetAllBooks()
    {
        return _books;
    }

    public Book GetBookById(int id)
    {
        return _books.FirstOrDefault(b => b.Id == id);
    }

    public void AddBook(Book book)
    {
        _books.Add(book);
    }

    public void DeleteBook(int id)
    {
        var book = GetBookById(id);
        if (book != null)
            _books.Remove(book);
    }
}

// Services/LoggerService.cs
public class LoggerService : ILoggerService
{
    public void Log(string message)
    {
        // For simplicity, logging to console. In real apps, use proper logging frameworks.
        Console.WriteLine($"Log: {message}");
    }
}

Step 5: Register Services with the DI Container

Edit the Program.cs file to register your services.

var builder = WebApplication.CreateBuilder(args);

// Register services with appropriate lifetimes
builder.Services.AddScoped<IBookService, BookService>();
builder.Services.AddSingleton<ILoggerService, LoggerService>();

// Add controllers
builder.Services.AddControllers();

// Enable Swagger for API documentation
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

// Configure middleware
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseRouting();

app.UseAuthorization();

app.MapControllers();

app.Run();

Explanation:

  • IBookService is registered as Scoped because it manages data that could change per request.

  • ILoggerService is registered as Singleton because logging services are typically stateless and shared across the application.

Step 6: Create Controllers and Inject Services

BooksController

using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("api/[controller]")]
public class BooksController : ControllerBase
{
    private readonly IBookService _bookService;
    private readonly ILoggerService _loggerService;

    public BooksController(IBookService bookService, ILoggerService loggerService)
    {
        _bookService = bookService;
        _loggerService = loggerService;
    }

    // GET: api/books
    [HttpGet]
    public IActionResult GetAllBooks()
    {
        _loggerService.Log("Fetching all books.");
        var books = _bookService.GetAllBooks();
        return Ok(books);
    }

    // GET: api/books/1
    [HttpGet("{id}")]
    public IActionResult GetBookById(int id)
    {
        _loggerService.Log($"Fetching book with ID: {id}");
        var book = _bookService.GetBookById(id);
        if (book == null)
        {
            _loggerService.Log($"Book with ID: {id} not found.");
            return NotFound();
        }
        return Ok(book);
    }

    // POST: api/books
    [HttpPost]
    public IActionResult AddBook([FromBody] Book book)
    {
        _bookService.AddBook(book);
        _loggerService.Log($"Added book: {book.Title} by {book.Author}");
        return CreatedAtAction(nameof(GetBookById), new { id = book.Id }, book);
    }

    // DELETE: api/books/1
    [HttpDelete("{id}")]
    public IActionResult DeleteBook(int id)
    {
        _bookService.DeleteBook(id);
        _loggerService.Log($"Deleted book with ID: {id}");
        return NoContent();
    }
}

Explanation:

  • BooksController depends on both IBookService and ILoggerService.

  • Services are injected via the constructor, ensuring that the controller has access to these dependencies.

Step 7: Run and Test the Application

Start the Application:

  • If using Visual Studio, press F5 or click the Run button.

  • If using the command line, execute:

dotnet run

Access Swagger UI:

  • Navigate to https://localhost:{PORT}/swagger in your browser.

  • You’ll see the API documentation generated by Swagger.

Test Endpoints:

  • GET /api/books: Retrieve all books.

  • GET /api/books/{id}: Retrieve a book by ID.

  • POST /api/books: Add a new book.

  • DELETE /api/books/{id}: Delete a book by ID.

Observe Logging:

  • Check the console output to see log messages from LoggerService.

Best Practices for Dependency Injection

To make the most out of DI in ASP.NET Core, consider the following best practices:

Program to Interfaces:

  • Depend on abstractions (interfaces) rather than concrete implementations. This promotes flexibility and testability.

  • Example:

public class MyController : ControllerBase
{
    private readonly IMyService _myService;

    public MyController(IMyService myService)
    {
        _myService = myService;
    }
}

Use Appropriate Service Lifetimes:

  • Choose the correct lifetime (Transient, Scoped, Singleton) based on the service’s role and behavior.

  • Avoid using Singleton for services that maintain per-request state.

Avoid Service Locator Pattern:

  • Do not resolve services manually using IServiceProvider. Let the DI container handle it.

Bad Practice:

public class MyService
{
    private readonly IServiceProvider _serviceProvider;

    public MyService(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }

    public void DoSomething()
    {
        var dependency = _serviceProvider.GetService<IDependency>();
        dependency.Execute();
    }
}

Minimize Number of Dependencies:

  • Classes should have a single responsibility and not depend on too many services.

  • If a class has too many dependencies, consider refactoring to reduce complexity.

Use Constructor Injection Preferably:

  • Constructor injection is the most straightforward and ensures dependencies are available upon object creation.

Register Services in One Place:

  • Organize service registrations for better maintainability, possibly grouping related services.

Leverage Built-In Logging and Configuration:

  • Utilize ASP.NET Core’s built-in services for logging, configuration, and other cross-cutting concerns.

Use Dependency Injection for Testing:

  • Inject dependencies to allow easy substitution with mocks or stubs during unit testing.

Conclusion

Dependency Injection is a fundamental concept in ASP.NET Core that empowers developers to build clean, maintainable, and testable applications. By understanding the various types of DI, service lifetimes, and best practices, you can harness the full potential of ASP.NET Core’s DI container to create robust applications.

This guide covered:

  • Understanding Dependency Injection: The essence and importance of DI in software design.

  • Types of Dependency Injection: Constructor, Property, and Method Injection with detailed examples.

  • Service Lifetimes: Transient, Scoped, Singleton — what they are and when to use them.

  • Registering and Consuming Services: How to set up and inject services in controllers.

  • Building Custom Services: Creating and utilizing your own services.

  • Hands-On Lab: Implementing DI in a practical ASP.NET Core Web API project.

  • Best Practices: Guidelines to follow for effective and efficient use of DI.

By integrating DI effectively into your ASP.NET Core projects, you ensure that your applications are scalable, maintainable, and adaptable to changing requirements.