.NET Interview Questions

What is Dependency Injection?

Key Concepts

• Dependency: An object that another object depends on.

• Inversion of Control (IoC): A principle where the control of object creation and management is transferred from the consumer to an external entity (like a DI container).

• Service Container: A central location where services (dependencies) are registered and resolved.

• Dependency Lifecycle: The lifetime of a dependency, which determines how instances are created and managed.

Benefits of Dependency Injection

1. Loose Coupling: Classes are less dependent on concrete implementations, making it easier to change or replace dependencies without modifying the consumer class.

2. Improved Testability: Dependencies can be easily mocked or stubbed, allowing for more straightforward unit testing.

3. Centralized Configuration: All dependencies are configured in one place, making it easier to manage and understand the application's architecture.

4. Enhanced Maintainability: Changes in dependencies require minimal changes in the consumer classes, leading to easier maintenance.

Types of Dependency Injection

1. Constructor Injection: Dependencies are provided through the class constructor. This is the most common form of DI.

2. Setter Injection: Dependencies are provided through public properties or setter methods. This allows for optional dependencies.

3. Interface Injection: The dependency provides an injector method that will inject the dependency into any client that passes itself to the injector.

Dependency Lifecycles

1. Singleton: A Singleton service is created once and shared throughout the entire application. The same instance is used every time the service is requested.

2. Scoped: A Scoped service is created once per request (or per scope). In a web application, this typically means one instance per HTTP request.

3. Transient: A Transient service is created each time it is requested. A new instance is provided every time the service is requested from the DI container.

Implementing Dependency Injection in .NET

1. Registering Services: Services are registered in the IServiceCollection during application startup, specifying their lifecycle.

public void ConfigureServices(IServiceCollection services) {
    services.AddSingleton<IMessageWriter, MessageWriter>();
    services.AddScoped<IMyService, MyService>();
    services.AddTransient<ITransientService, TransientService>();
}

2. Resolving Services: Services can be resolved using constructor injection in controllers or other services.

public class MyController : Controller {
    private readonly IMyService _myService;

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

3. Running the Application: The application can be run using the Host class, which manages the service provider.

public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureServices((hostContext, services) => {
            services.AddHostedService<Worker>();
        });

Keyed Services in .NET 8

How to Register Keyed Services

public class ExampleService {
    public ExampleService([FromKeyedServices("queue")] IMessageWriter writer) {
        // Use the writer implementation based on the key
    }
}

Benefits of Keyed Services

1. Flexibility: Keyed services provide a more flexible way to manage multiple implementations of the same interface without the need for complex factory methods.

2. Simplified Code: By using keyed services, you can reduce boilerplate code associated with creating and managing factories or service locators.

3. Enhanced Readability: The use of keys makes it clear which implementation is being used, improving the readability of the code.

Use Cases for Keyed Services

• Multiple Implementations: When you have different implementations of an interface that need to be resolved based on specific criteria (e.g., different storage mechanisms like local and cloud storage).

• Dynamic Behavior: When the behavior of a service needs to change based on runtime conditions, keyed services allow you to switch implementations easily.

Example of Keyed Services in Action

public interface IMessageWriter {
    void Write(string message);
}

public class MemoryMessageWriter : IMessageWriter {
    public void Write(string message) {
        Console.WriteLine("Memory: " + message);
    }
}

public class QueueMessageWriter : IMessageWriter {
    public void Write(string message) {
        Console.WriteLine("Queue: " + message);
    }
}

public class ExampleService {
    private readonly IMessageWriter _writer;

    public ExampleService([FromKeyedServices("queue")] IMessageWriter writer) {
        _writer = writer;
    }

    public void SendMessage(string message) {
        _writer.Write(message);
    }
}

// In Startup.cs or Program.cs
public void ConfigureServices(IServiceCollection services) {
    services.AddKeyedSingleton<IMessageWriter, MemoryMessageWriter>("memory");
    services.AddKeyedSingleton<IMessageWriter, QueueMessageWriter>("queue");
    services.AddTransient<ExampleService>();
}

// Usage
var serviceProvider = services.BuildServiceProvider();
var exampleService = serviceProvider.GetRequiredService<ExampleService>();
exampleService.SendMessage("Hello, Keyed Services!");