¿Cómo funciona la inyección de dependencias en .NET?

Question

Accepted Answer

**Dependency Injection (DI)** está integrado en .NET moderno — el framework incluye un contenedor de DI que construye automáticamente clases e **inyecta sus dependencias**. Registras servicios (mapeando interfaces a implementaciones) y el contenedor los resuelve, permitiendo código débilmente acoplado y comprobable. Es fundamental para ASP.NET Core. ## Registrando servicios ```csharp // in Program.cs — register services with a LIFETIME builder.Services.AddScoped(); // interface → implementation builder.Services.AddSingleton(); builder.Services.AddTransient(); ``` Registras cada mapeo de servicios asignando una **interfaz a una implementación** con una duración de vida. Luego, cualquier cosa que dependa de la interfaz obtiene la implementación registrada. ## Inyección en constructor (el patrón estándar) ```csharp public class UserService { private readonly IUserRepository _repo; private readonly IEmailSender _email; // dependencies are declared in the constructor — the container INJECTS them automatically public UserService(IUserRepository repo, IEmailSender email) { _repo = repo; _email = email; } } // you never `new UserService(...)` manually — the container builds it, resolving the chain ``` Las dependencias se declaran como parámetros del constructor (tipificados como interfaces); el contenedor construye la clase e inyecta las implementaciones registradas, resolviendo automáticamente el gráfico de dependencias completo. ## Duraciones de servicios (importante elegir correctamente) ```text Singleton → ONE instance for the entire app lifetime (shared; must be thread-safe) Scoped → one instance PER request (the common default for web — e.g. DbContext) Transient → a NEW instance every time it's requested (lightweight, stateless services) → Choosing wrong (e.g. a singleton capturing a scoped DbContext) causes subtle bugs. ``` ## Los beneficios: acoplamiento débil y comprobabilidad ```csharp // because UserService depends on INTERFACES, you can inject MOCKS in tests var service = new UserService(mockRepo, mockEmail); // no real DB/email needed ``` ## Por qué es importante La inyección de dependencias es fundamental en .NET moderno — está **integrada en el framework** y es la base de ASP.NET Core, por lo que comprenderla es esencial para cualquier desarrollo moderno de aplicaciones en C#. El contenedor de DI integrado del framework construye automáticamente clases e inyecta sus dependencias (resolviendo el gráfico de dependencias completo), así que registras servicios y dejas que el contenedor conecte todo en lugar de instanciar manualmente las dependencias. Los beneficios principales son significativos y centrales para entender por qué se enfatiza DI: **acoplamiento débil** (depender de interfaces en lugar de clases concretas, para que las implementaciones se puedan cambiar) y especialmente **comprobabilidad** (inyectando implementaciones mock en las pruebas en lugar de dependencias reales como bases de datos o servicios de correo electrónico — haciendo que las pruebas unitarias exhaustivas sean prácticas). Comprender cómo registrar servicios (mapeando interfaces a implementaciones), inyección en constructor (el patrón estándar), y — importantemente — las **duraciones de servicios** (`Singleton`, `Scoped`, `Transient`) es esencial: elegir la duración incorrecta causa bugs sutiles y difíciles de depurar (p. ej., un singleton manteniendo un `DbContext` scoped, o problemas de seguridad de hilos con singletons compartidos), así que entender cuándo aplica cada duración de vida (Scoped por solicitud para cosas como DbContext, Singleton para servicios sin estado compartido, Transient para los ligeros) es crítico. Como DI está integrado en .NET, sustenta la arquitectura de ASP.NET Core, y es la clave para escribir código débilmente acoplado y comprobable, dominarlo — el contenedor, inyección en constructor, diseño basado en interfaces, y especialmente las duraciones de servicios — es conocimiento importante y frecuentemente aplicado a nivel senior para construir aplicaciones modernas en C# mantenibles y comprobables, y es un tema común en entrevistas.