Overview

Dependency Injection (DI) in .NET is a design pattern and a core feature of the ASP.NET Core framework, aimed at achieving Inversion of Control (IoC) between classes and their dependencies. By enabling classes to receive their dependencies from an external source rather than creating them internally, DI facilitates loose coupling, easier unit testing, and better management of cross-cutting concerns.

Key Concepts

1. Inversion of Control (IoC): Shifting the control of creating dependencies from the class itself to an external container or framework.
2. Service Lifetimes: Understanding transient, scoped, and singleton lifetimes in DI to manage object creation and disposal correctly.
3. Dependency Injection Container: A central location where classes and their dependencies are registered and resolved.

Common Interview Questions

Basic Level

1. What is Dependency Injection and why is it important in .NET development?
2. How do you register and resolve services in .NET Core's built-in DI container?

Intermediate Level

3. Explain the difference between transient, scoped, and singleton lifetimes in .NET Core DI.

Advanced Level

4. How does Dependency Injection improve unit testing in .NET applications?

Detailed Answers

1. What is Dependency Injection and why is it important in .NET development?

Answer: Dependency Injection is a design pattern used to implement Inversion of Control, allowing a class's dependencies to be injected at runtime rather than the class creating them internally. This is important in .NET development for several reasons:
- Loose Coupling: Classes do not have hard-coded dependencies, which means changing a class's dependencies does not require changes to the class code.
- Easier Unit Testing: Dependencies can be replaced with mocks or stubs, making it easier to test classes in isolation.
- Improved Code Maintenance: Central management of class dependencies makes the application easier to update and maintain.

Key Points:
- Promotes loose coupling and high cohesion.
- Facilitates easier unit testing and code maintenance.
- Integral to modern .NET and ASP.NET Core applications.

Example:

public interface IMessageService
{
    void Send(string message);
}

public class EmailService : IMessageService
{
    public void Send(string message)
    {
        // Send email with the message
    }
}

public class NotificationController
{
    private readonly IMessageService _messageService;

    public NotificationController(IMessageService messageService)
    {
        _messageService = messageService;
    }

    public void Notify(string message)
    {
        _messageService.Send(message);
    }
}

2. How do you register and resolve services in .NET Core's built-in DI container?

Answer: Services are registered in the Startup.cs file of a .NET Core application within the ConfigureServices method. Resolving services is typically done by the framework, but can also be done manually using the service provider.

Key Points:
- Services are registered with specific lifetimes.
- The .NET Core framework resolves these services when required.
- Manual resolution is possible but should be done with caution.

Example:

public void ConfigureServices(IServiceCollection services)
{
    // Registering the service with transient lifetime
    services.AddTransient<IMessageService, EmailService>();
}

public class HomeController : Controller
{
    private readonly IMessageService _messageService;

    public HomeController(IMessageService messageService)
    {
        _messageService = messageService;
    }

    public IActionResult Index()
    {
        _messageService.Send("Welcome to the application!");
        return View();
    }
}

3. Explain the difference between transient, scoped, and singleton lifetimes in .NET Core DI.

Answer: In .NET Core DI, services can be registered with one of three lifetimes, controlling how instances are created and shared:
- Transient: A new instance is created each time the service is requested.
- Scoped: A single instance is created per client request (e.g., HTTP request in a web application).
- Singleton: A single instance is created and shared across all requests and the application's lifetime.

Key Points:
- Transient services are best for lightweight, stateless services.
- Scoped services are ideal for services that maintain state within a request.
- Singletons are suitable for long-lived, stateful services shared across the application.

Example:

public void ConfigureServices(IServiceCollection services)
{
    services.AddTransient<ITransientService, TransientService>();
    services.AddScoped<IScopedService, ScopedService>();
    services.AddSingleton<ISingletonService, SingletonService>();
}

4. How does Dependency Injection improve unit testing in .NET applications?

Answer: Dependency Injection facilitates unit testing by allowing developers to inject mock implementations of dependencies into the classes being tested. This makes it easier to isolate the class under test and control its environment, leading to more reliable and straightforward tests.

Key Points:
- Enables testing classes in isolation.
- Simplifies the process of mocking dependencies.
- Leads to higher quality, more maintainable code.

Example:

public class UserServiceTest
{
    [Fact]
    public void TestUserCreation()
    {
        var mockRepository = new Mock<IUserRepository>();
        mockRepository.Setup(repo => repo.Create(It.IsAny<User>())).Returns(true);

        var userService = new UserService(mockRepository.Object);
        bool result = userService.CreateUser(new User());

        Assert.True(result);
    }
}

This example uses the Moq library to mock the IUserRepository dependency, demonstrating how DI makes it easier to test the UserService class by injecting a mock repository.