¿Qué mecanismos ayudan a mantener el principio de…

El principio de inversión de dependencias (Dependency Inversion Principle - DIP) se cumple mediante varios mecanismos interrelacionados:

Abstracciones:
- Las interfaces y clases abstractas definen contratos, no implementaciones concretas. Los módulos de alto nivel dependen de estas abstracciones, no de clases concretas de bajo nivel.

Inyección de dependencias (Dependency Injection - DI):

En lugar de que una clase cree sus dependencias directamente, estas se le pasan desde fuera. Esto permite reemplazar fácilmente las implementaciones de dependencias sin cambiar el código de la clase.

Sintaxis C# para inyección a través del constructor:

public class HighLevelModule
{
    private readonly ILowLevelDependency _dependency; // Dependencia de la abstracción

    public HighLevelModule(ILowLevelDependency dependency) // Inyección a través del constructor
    {
        _dependency = dependency;
    }

    public void PerformAction()
    {
        _dependency.Execute(); // Uso de la dependencia a través de la abstracción
    }
}

Sintaxis C# para inyección a través de la propiedad:

public class AnotherHighLevelModule
{
    public ILowLevelDependency Dependency { get; set; } // Inyección a través de la propiedad

    public void PerformAction()
    {
        Dependency?.Execute(); // Uso de la dependencia a través de la abstracción
    }
}

Sintaxis C# para inyección a través del método:

public class YetAnotherHighLevelModule
{
    public void PerformAction(ILowLevelDependency dependency) // Inyección a través del método
    {
        dependency.Execute(); // Uso de la dependencia a través de la abstracción
    }
}

Contenedores IoC (Inversion of Control Containers):

Frameworks que automatizan el proceso de gestión e inyección de dependencias. Se encargan de crear instancias de clases y resolver sus dependencias según las reglas configuradas.

Ejemplo de uso de un contenedor IoC popular (por ejemplo, StructureMap):

// Registro de dependencia
// container.Configure(cfg =>
// {
//     cfg.For<ILowLevelDependency>().Use<ConcreteLowLevelDependency>(); // Registro de la abstracción y su implementación concreta
//     cfg.For<HighLevelModule>().Use<HighLevelModule>();
// });

// Obtención de una instancia de la clase con dependencias resueltas
// var highLevelModule = container.GetInstance<HighLevelModule>();
// highLevelModule.PerformAction();

Fábricas:

Clases que se encargan de crear instancias de otras clases. Pueden ocultar detalles de creación de implementaciones concretas y devolver abstracciones.

Sintaxis C# para ejemplo de uso de una fábrica:

public interface ILowLevelDependencyFactory
{
    ILowLevelDependency Create();
}

public class LowLevelDependencyFactory : ILowLevelDependencyFactory
{
    public ILowLevelDependency Create()
    {
        return new ConcreteLowLevelDependency(); // Creación de una implementación concreta
    }
}

public class HighLevelModuleWithFactory
{
    private readonly ILowLevelDependency _dependency;

    public HighLevelModuleWithFactory(ILowLevelDependencyFactory factory) // Inyección de la fábrica
    {
        _dependency = factory.Create(); // Uso de la fábrica para crear la dependencia
    }

    public void PerformAction()
    {
        _dependency.Execute();
    }
}

Principio de mínimo conocimiento (Ley de Demeter):
- Aunque no es un mecanismo directo del DIP, seguir este principio (hablar solo con "tus amigos inmediatos") a menudo reduce las dependencias directas y facilita la aplicación del DIP.

¿Qué mecanismos ayudan a mantener el principio de inversión de dependencias?