Принцип инверсии зависимостей (Dependency Inversion Principle - DIP) соблюдается с помощью нескольких взаимосвязанных механизмов:

Абстракции:
- Интерфейсы и абстрактные классы определяют контракты, а не конкретные реализации. Высокоуровневые модули зависят от этих абстракций, а не от низкоуровневых конкретных классов.

Внедрение зависимостей (Dependency Injection - DI):

Вместо того, чтобы класс создавал свои зависимости напрямую, они передаются ему извне. Это позволяет легко заменять реализации зависимостей без изменения кода самого класса.

Синтаксис C# для внедрения через конструктор:

public class HighLevelModule
{
    private readonly ILowLevelDependency _dependency; // Зависимость от абстракции

    public HighLevelModule(ILowLevelDependency dependency) // Внедрение через конструктор
    {
        _dependency = dependency;
    }

    public void PerformAction()
    {
        _dependency.Execute(); // Использование зависимости через абстракцию
    }
}

Синтаксис C# для внедрения через свойство:

public class AnotherHighLevelModule
{
    public ILowLevelDependency Dependency { get; set; } // Внедрение через свойство

    public void PerformAction()
    {
        Dependency?.Execute(); // Использование зависимости через абстракцию
    }
}

Синтаксис C# для внедрения через метод:

public class YetAnotherHighLevelModule
{
    public void PerformAction(ILowLevelDependency dependency) // Внедрение через метод
    {
        dependency.Execute(); // Использование зависимости через абстракцию
    }
}

IoC-контейнеры (Inversion of Control Containers):

Фреймворки, которые автоматизируют процесс управления зависимостями и внедрения. Они отвечают за создание экземпляров классов и разрешение их зависимостей согласно настроенным правилам.

Пример использования популярного IoC-контейнера (например, StructureMap):

// Регистрация зависимости
// container.Configure(cfg =>
// {
//     cfg.For<ILowLevelDependency>().Use<ConcreteLowLevelDependency>(); // Регистрация абстракции и её конкретной реализации
//     cfg.For<HighLevelModule>().Use<HighLevelModule>();
// });

// Получение экземпляра класса с разрешенными зависимостями
// var highLevelModule = container.GetInstance<HighLevelModule>();
// highLevelModule.PerformAction();

Фабрики:

Классы, которые отвечают за создание экземпляров других классов. Они могут скрывать детали создания конкретных реализаций и возвращать абстракции.

Синтаксис C# для примера использования фабрики:

public interface ILowLevelDependencyFactory
{
    ILowLevelDependency Create();
}

public class LowLevelDependencyFactory : ILowLevelDependencyFactory
{
    public ILowLevelDependency Create()
    {
        return new ConcreteLowLevelDependency(); // Создание конкретной реализации
    }
}

public class HighLevelModuleWithFactory
{
    private readonly ILowLevelDependency _dependency;

    public HighLevelModuleWithFactory(ILowLevelDependencyFactory factory) // Внедрение фабрики
    {
        _dependency = factory.Create(); // Использование фабрики для создания зависимости
    }

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

Принцип наименьших знаний (Law of Demeter):
- Хотя не является прямым механизмом DIP, соблюдение этого принципа (говорить только со своими непосредственными "друзьями") часто ведет к уменьшению прямых зависимостей и, как следствие, облегчает применение DIP.

Какие механизмы помогают соблюдать принцип инверсии зависимостей?