Dependency Injection

Explain the Inversion of Control (IoC) principle and how DI is a mechanism for implementing it.

Explain the Single Responsibility Principle (SRP) and how it is supported by DI.

Recognize constructor over-injection as a code smell indicating a potential SRP violation.

Explain the Dependency Inversion Principle (DIP) and how DI facilitates adherence to it by depending on abstractions.

Register services in an IServiceCollection using the AddTransient, AddScoped, and AddSingleton methods.

Explain how constructor injection works and how the container resolves dependency graphs automatically.

Resolve services manually from an IServiceProvider and identify when this is appropriate versus when it is an anti-pattern.

Inject a logger (ILogger<T>) into a service using the built-in logging integration.

Describe the behavior of the Transient, Scoped, and Singleton lifetimes and identify appropriate use cases for each.

Explain the concept of a 'scope' via IServiceScope and its relevance in web and desktop applications (e.g., WPF).

Diagnose and resolve captive dependency problems (e.g., a Singleton capturing a Scoped service).

Enable and use scope validation during development to automatically detect lifetime mismatches.

Create and manage custom scopes using IServiceScopeFactory for scenarios like per-dialog lifetimes in WPF.

Register services conditionally using the TryAdd methods to avoid overwriting existing registrations.

Register services using factory delegates for complex construction logic or when runtime data is needed.

Register open generic types (e.g., `IRepository<>`) to handle multiple closed generic service registrations with a single line of code.

Replace or remove existing service registrations within the IServiceCollection.

Bind configuration sections to strongly-typed classes and inject them using the IOptions<T> pattern.

Implement the Strategy pattern by injecting an abstraction and registering different concrete implementations.

Implement the Decorator pattern to wrap services with cross-cutting concerns like logging or caching.

Implement the Composite pattern by registering multiple implementations of an interface and resolving them as an IEnumerable<T>.

Implement an abstract factory for creating objects that require runtime parameters not known at composition time.

Use keyed services (.NET 8+) to register and resolve specific, named implementations of an interface.

Explain how the DI container manages the disposal of IDisposable and IAsyncDisposable services for each lifetime.

Identify and refactor code that uses the Service Locator anti-pattern.

Evaluate when to use dependency injection versus when it might introduce unnecessary complexity.

Articulate best practices for organizing service registrations for maintainability in a large application.

Design classes that are easily testable by depending on abstractions via constructor injection.

Write a unit test for a class by injecting test doubles (e.g., mocks or stubs) for its dependencies.

Structure the Composition Root of a WPF MVVM application effectively.

Analyze a simple WPF application to identify areas for improvement using DI principles.