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

Абстракции (интерфейсы или абстрактные классы): Высокоуровневые модули должны зависеть от абстракций, а не от конкретных реализаций. Низкоуровневые модули также должны зависеть от тех же абстракций.

// Абстракция
public interface ILogger
{
    void Log(string message);
}

// Высокоуровневый модуль, зависящий от абстракции
public class Service
{
    private readonly ILogger _logger;

    public Service(ILogger logger) // Внедрение зависимости
    {
        _logger = logger;
    }

    public void DoWork()
    {
        _logger.Log("Doing work...");
    }
}

// Низкоуровневый модуль (реализация), зависящий от той же абстракции
public class ConsoleLogger : ILogger
{
    public void Log(string message)
    {
        Console.WriteLine(message);
    }
}

// Пример использования - создание и внедрение зависимости
ILogger consoleLogger = new ConsoleLogger();
Service service = new Service(consoleLogger);
service.DoWork();

Внедрение зависимостей (Dependency Injection, DI): Механизм, при котором зависимости объекта предоставляются извне, а не создаются самим объектом. Это может быть выполнено через конструктор, свойства или методы.
- Внедрение через конструктор (Constructor Injection): Наиболее распространенный и рекомендуемый подход. Зависимости передаются в конструктор объекта.
```
public class MyClass
{
    private readonly IDependency _dependency;

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

    public void DoSomething()
    {
        _dependency.Execute();
    }
}
```
- Внедрение через свойство (Property Injection): Зависимости устанавливаются через общедоступное свойство. Используется, когда зависимость не всегда обязательна для корректной работы объекта, или при циклической зависимости.
```
public class MyClass
{
    public IDependency Dependency { get; set; } // Внедрение через свойство

    public void DoSomething()
    {
        Dependency?.Execute(); // Проверка на null
    }
}
```
- Внедрение через метод (Method Injection): Зависимость передается в определенный метод. Используется, когда зависимость нужна только для выполнения конкретной задачи метода.
```
public class MyClass
{
    public void DoSomething(IDependency dependency) // Внедрение через метод
    {
        dependency.Execute();
    }
}
```

Контейнеры IoC (Inversion of Control): Фреймворки, автоматизирующие процесс управления зависимостями. Они регистрируют зависимости и resolve (разрешают) их при запросе объектов. Популярные примеры: ASP.NET Core DI (встроенный), Autofac, Ninject, StructureMap, Unity.

// Пример с использованием встроенного в ASP.NET Core DI
public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // Регистрация зависимости
        services.AddTransient<ILogger, ConsoleLogger>();
        services.AddTransient<Service>(); // Регистрация класса, который зависит от ILogger
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env, Service service)
    {
        // Service будет автоматически создан с внедренным ConsoleLogger
        service.DoWork();
    }
}

Грамотное применение этих подходов позволяет создавать более гибкий, тестируемый и поддерживаемый код.

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