Для чего нужен Dependency Injection?

# Dependency Injection (DI) - Инъекция зависимостей

Dependency Injection - это паттерн проектирования, который решает проблему управления зависимостями между компонентами приложения. Вместо того чтобы класс сам создавал свои зависимости, они передаются ему извне.

Основная идея

// БЕЗ DI - класс сам создает зависимости
public class UserService
{
    private IUserRepository _repository;
    private IEmailService _emailService;
    
    public UserService()
    {
        _repository = new UserRepository();  // Жесткая связь
        _emailService = new EmailService();   // Жесткая связь
    }
}

// С DI - зависимости передаются снаружи
public class UserService
{
    private readonly IUserRepository _repository;
    private readonly IEmailService _emailService;
    
    public UserService(IUserRepository repository, IEmailService emailService)
    {
        _repository = repository;      // Инъекция
        _emailService = emailService;  // Инъекция
    }
}

Для чего нужен DI?

1. Слабая связанность (Loose Coupling)

Классы не зависят от конкретных реализаций, а от интерфейсов:

// ХОРОШО - зависит от интерфейса
public class PaymentService
{
    private readonly IPaymentGateway _gateway;
    
    public PaymentService(IPaymentGateway gateway)
    {
        _gateway = gateway;
    }
    
    public void ProcessPayment(decimal amount)
    {
        _gateway.Charge(amount);
    }
}

// Можем использовать разные реализации
var stripeService = new PaymentService(new StripeGateway());
var paypalService = new PaymentService(new PayPalGateway());

2. Упрощение тестирования

Легко подменять реальные зависимости на mock'и:

[Fact]
public void ProcessPayment_WithMockGateway_ReturnsSuccess()
{
    // Arrange - создаём mock вместо реального сервиса
    var mockGateway = new Mock<IPaymentGateway>();
    mockGateway.Setup(x => x.Charge(It.IsAny<decimal>()))
               .Returns(true);
    
    var service = new PaymentService(mockGateway.Object);
    
    // Act
    var result = service.ProcessPayment(100);
    
    // Assert
    Assert.True(result);
    mockGateway.Verify(x => x.Charge(100), Times.Once);
}

3. Гибкость и расширяемость

Легко добавлять новые реализации без изменения существующего кода:

public interface ILogger
{
    void Log(string message);
}

public class ConsoleLogger : ILogger
{
    public void Log(string message) => Console.WriteLine(message);
}

public class FileLogger : ILogger
{
    public void Log(string message) => File.AppendAllText("log.txt", message);
}

public class CloudLogger : ILogger
{
    public void Log(string message) => SendToCloud(message);
}

// Приложение работает с любым логгером
public class Application
{
    private readonly ILogger _logger;
    
    public Application(ILogger logger)
    {
        _logger = logger;
    }
    
    public void Run()
    {
        _logger.Log("Application started");
    }
}

4. Управление жизненным циклом объектов

DI контейнер управляет созданием и уничтожением объектов:

// В ASP.NET Core Startup
public void ConfigureServices(IServiceCollection services)
{
    // Singleton - один экземпляр на всё приложение
    services.AddSingleton<IConfiguration>();
    
    // Transient - новый экземпляр каждый раз
    services.AddTransient<IUserRepository, UserRepository>();
    
    // Scoped - один экземпляр на каждый HTTP запрос
    services.AddScoped<IUserService, UserService>();
}

Способы инъекции зависимостей

1. Constructor Injection (Инъекция через конструктор) - РЕКОМЕНДУЕТСЯ

public class UserService
{
    private readonly IUserRepository _repository;
    private readonly ILogger _logger;
    
    public UserService(IUserRepository repository, ILogger logger)
    {
        _repository = repository ?? throw new ArgumentNullException(nameof(repository));
        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
    }
}

Преимущества:

• Явная декларация зависимостей
• Зависимости неизменяемы (readonly)
• Легко видеть все зависимости

2. Property Injection (Инъекция через свойства)

public class UserService
{
    public IUserRepository Repository { get; set; }
    public ILogger Logger { get; set; }
}

var service = new UserService
{
    Repository = new UserRepository(),
    Logger = new ConsoleLogger()
};

Недостатки:

• Сложнее отследить все зависимости
• Зависимости изменяемы
• Может быть забыто установить свойство

3. Method Injection (Инъекция через методы)

public class PaymentService
{
    public void ProcessPayment(decimal amount, IPaymentGateway gateway)
    {
        gateway.Charge(amount);
    }
}

Используется когда: Зависимость нужна только для одного метода

DI контейнеры в .NET

встроенный Microsoft.Extensions.DependencyInjection

var services = new ServiceCollection();

// Регистрация зависимостей
services.AddSingleton<ILogger, ConsoleLogger>();
services.AddScoped<IUserRepository, UserRepository>();
services.AddTransient<IUserService, UserService>();

var serviceProvider = services.BuildServiceProvider();

// Использование
var userService = serviceProvider.GetRequiredService<IUserService>();

Autofac

var builder = new ContainerBuilder();

builder.RegisterType<UserRepository>()
    .As<IUserRepository>();

builder.RegisterType<UserService>()
    .As<IUserService>();

var container = builder.Build();
var service = container.Resolve<IUserService>();

Ninject, Castle Windsor - другие популярные DI контейнеры

Лучшие практики

1. Всегда используй интерфейсы

// ПЛОХО
public UserService(UserRepository repository) { }

// ХОРОШО
public UserService(IUserRepository repository) { }

2. Разделяй публичные и приватные зависимости

public class ComplexService
{
    private readonly IPublicDependency _publicDep;  // Основная зависимость
    private readonly IInternalHelper _helper;       // Вспомогательная
    
    public ComplexService(IPublicDependency publicDep, IInternalHelper helper = null)
    {
        _publicDep = publicDep;
        _helper = helper ?? new DefaultInternalHelper();
    }
}

3. Не создавай граф зависимостей через DI

// ПЛОХО - слишком много параметров в конструкторе
public UserService(IRepository r, ILogger l, IEmailService e, 
    ICache c, IValidator v, IMapper m, IService1 s1, ...)
{
}

// ХОРОШО - группируй по функциональности
public interface IUserDependencies
{
    IRepository Repository { get; }
    ILogger Logger { get; }
    IEmailService EmailService { get; }
}

public UserService(IUserDependencies dependencies) { }

4. Используй фабрики для сложных объектов

public interface IUserServiceFactory
{
    IUserService CreateUserService(string mode);
}

public class UserServiceFactory : IUserServiceFactory
{
    public IUserService CreateUserService(string mode)
    {
        return mode switch
        {
            "production" => new ProductionUserService(),
            "testing" => new TestingUserService(),
            _ => throw new ArgumentException()
        };
    }
}

services.AddSingleton<IUserServiceFactory, UserServiceFactory>();

Пример в ASP.NET Core

// Программа.cs
var builder = WebApplication.CreateBuilder(args);

// Регистрация сервисов
builder.Services.AddScoped<IUserRepository, UserRepository>();
builder.Services.AddScoped<IUserService, UserService>();
builder.Services.AddScoped<IEmailService, SmtpEmailService>();

var app = builder.Build();

// Контроллер автоматически получает зависимости
[ApiController]
[Route("api/users")]
public class UserController : ControllerBase
{
    private readonly IUserService _userService;
    
    public UserController(IUserService userService)
    {
        _userService = userService;
    }
    
    [HttpGet("{id}")]
    public async Task<ActionResult<UserDto>> GetUser(int id)
    {
        var user = await _userService.GetUserAsync(id);
        return Ok(user);
    }
}

Заключение

Dependency Injection - это фундаментальный паттерн современной разработки. Он позволяет:

• Писать слабосвязанный код
• Упростить тестирование
• Облегчить поддержку и расширение
• Централизовать управление конфигурацией

Все популярные фреймворки (.NET, Java, Python) поддерживают DI из коробки, и это лучшая практика использовать его везде, где это имеет смысл.