Topic 8318 min readStructured Tutorial

Dependency Injection Basics in C# Interfaces

Quick Answer

Dependency Injection (DI) in C# uses interfaces to decouple components, making code more modular and testable. By injecting dependencies via interfaces, you can swap implementations easily without changing dependent classes, enhancing maintainability and flexibility.

Learning Objectives

Explain the purpose of Dependency Injection Basics in a practical learning context.
Identify the main ideas, terms, and decisions involved in Dependency Injection Basics.
Apply Dependency Injection Basics in a simple real-world scenario or practice task.

Introduction to Dependency Injection with Interfaces

Dependency Injection (DI) is a design pattern that helps create loosely coupled, maintainable, and testable code.

In C#, interfaces play a crucial role in DI by defining contracts that implementations must follow, enabling easy swapping of components.

“Dependency Injection promotes loose coupling and increases code flexibility.”

What is Dependency Injection?

Dependency Injection is a technique where an object receives other objects it depends on, rather than creating them internally.

This approach separates the creation of dependencies from their usage, improving modularity.

Reduces tight coupling between classes
Improves code testability
Simplifies maintenance and updates

Role of Interfaces in Dependency Injection

Interfaces define contracts that implementations must follow, allowing dependencies to be injected without binding to specific classes.

Using interfaces in DI enables swapping implementations without changing the dependent code.

Defines clear expectations for dependencies
Supports multiple implementations
Facilitates mocking for unit testing

How to Implement Dependency Injection with Interfaces in C#

You can inject dependencies via constructor injection, property injection, or method injection, with constructor injection being the most common.

The dependent class declares an interface type in its constructor, and the concrete implementation is passed in when creating the object.

Define an interface for the dependency
Create one or more classes implementing the interface
Inject the implementation into the dependent class via constructor

Example: Constructor Injection

Below is a simple example demonstrating dependency injection using interfaces and constructor injection.

Practical Example

This example shows an ILogger interface and a ConsoleLogger implementation. UserService depends on ILogger and receives it via constructor injection, allowing flexible logging implementations.

Examples

Simple Dependency Injection with Interfaces in C#

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

public class ConsoleLogger : ILogger {
    public void Log(string message) {
        Console.WriteLine($"Log: {message}");
    }
}

public class UserService {
    private readonly ILogger _logger;

    public UserService(ILogger logger) {
        _logger = logger;
    }

    public void CreateUser(string username) {
        // User creation logic here
        _logger.Log($"User '{username}' created.");
    }
}

// Usage
ILogger logger = new ConsoleLogger();
UserService userService = new UserService(logger);
userService.CreateUser("Alice");

This example shows an ILogger interface and a ConsoleLogger implementation. UserService depends on ILogger and receives it via constructor injection, allowing flexible logging implementations.

Best Practices

Use interfaces to define clear contracts for dependencies.
Prefer constructor injection for mandatory dependencies.
Avoid creating dependencies inside classes; inject them instead.
Use dependency injection containers for managing complex dependencies.
Write unit tests by mocking interfaces to isolate components.

Common Mistakes

Injecting concrete classes instead of interfaces, leading to tight coupling.
Creating dependencies inside classes rather than injecting them.
Overusing property or method injection when constructor injection is more appropriate.
Ignoring the benefits of DI and tightly coupling code.

Hands-on Exercise

Implement Dependency Injection with Interfaces

Create an interface IDataStore with methods to save and retrieve data. Implement two classes: FileDataStore and MemoryDataStore. Inject IDataStore into a DataManager class using constructor injection and demonstrate switching implementations.

Expected output: DataManager should work with both FileDataStore and MemoryDataStore implementations without code changes.

Hint: Define IDataStore interface first, then implement classes. Use constructor injection in DataManager.

Interview Questions

What is Dependency Injection and why is it useful in C#?

Interview

Dependency Injection is a design pattern where dependencies are provided to a class rather than created by it, promoting loose coupling, easier testing, and better maintainability.

How do interfaces facilitate Dependency Injection in C#?

Interview

Interfaces define contracts that allow different implementations to be injected, enabling flexible swapping of dependencies without changing the dependent code.

What are common ways to inject dependencies in C#?

Interview

The common methods are constructor injection, property injection, and method injection, with constructor injection being the most widely used.