Какие есть подходы внедрения в коры?

Подходы внедрения зависимостей в ядро ASP.NET Core

В ASP.NET Core внедрение зависимостей (Dependency Injection, DI) является фундаментальным паттерном проектирования, встроенным в саму платформу. Он позволяет создавать слабосвязанные, тестируемые и поддерживаемые приложения. Вот основные подходы к регистрации сервисов в DI-контейнере.

1. Регистрация через интерфейс и реализацию

Наиболее распространенный подход, где регистрируется конкретная реализация для определенного интерфейса.

// Определение интерфейса и реализации
public interface IDataService
{
    Task<string> GetDataAsync();
}

public class DataService : IDataService
{
    public async Task<string> GetDataAsync()
    {
        return await Task.FromResult("Data from service");
    }
}

// Регистрация в Startup.cs или Program.cs
services.AddScoped<IDataService, DataService>();

2. Регистрация конкретного типа

Когда интерфейс не требуется или используется сам тип как сервис.

// Регистрация без интерфейса
services.AddTransient<DataProcessor>();

// Использование в конструкторе
public class MyController : Controller
{
    private readonly DataProcessor _processor;
    
    public MyController(DataProcessor processor)
    {
        _processor = processor;
    }
}

3. Регистрация с фабричным методом

Позволяет контролировать процесс создания экземпляра сервиса.

services.AddSingleton<ICacheService>(serviceProvider =>
{
    var config = serviceProvider.GetService<IConfiguration>();
    var connectionString = config.GetConnectionString("Redis");
    return new RedisCacheService(connectionString);
});

4. Регистрация существующего экземпляра

Когда нужно зарегистрировать уже созданный объект как singleton.

var settings = new AppSettings { Mode = "Production" };
services.AddSingleton(settings);

5. Групповая регистрация

Регистрация нескольких реализаций одного интерфейса с последующим разрешением коллекции.

// Регистрация нескольких валидаторов
services.AddScoped<IValidator, EmailValidator>();
services.AddScoped<IValidator, PhoneValidator>();
services.AddScoped<IValidator, NameValidator>();

// Разрешение в потребителе
public class RegistrationService
{
    private readonly IEnumerable<IValidator> _validators;
    
    public RegistrationService(IEnumerable<IValidator> validators)
    {
        _validators = validators;
    }
    
    public bool Validate(User user)
    {
        return _validators.All(v => v.IsValid(user));
    }
}

6. Регистрация с помощью расширений

Кастомные расширения для группировки логики регистрации.

// Создание метода расширения
public static class ServiceCollectionExtensions
{
    public static IServiceCollection AddBusinessServices(this IServiceCollection services)
    {
        services.AddScoped<IOrderService, OrderService>();
        services.AddScoped<IPaymentService, PaymentService>();
        services.AddScoped<IShippingService, ShippingService>();
        return services;
    }
}

// Использование
services.AddBusinessServices();

Время жизни сервисов (Lifetime)

ASP.NET Core предоставляет три основных времени жизни:

Transient

Создается новый экземпляр при каждом запросе.

services.AddTransient<ILogger, ConsoleLogger>();
// Каждый раз новый объект

Scoped

Создается один экземпляр на область видимости (обычно на один HTTP-запрос).

services.AddScoped<IDatabaseContext, AppDbContext>();
// Один экземпляр на запрос

Singleton

Создается один экземпляр на все время работы приложения.

services.AddSingleton<IConfigurationService, ConfigurationService>();
// Один экземпляр на все приложение

Паттерны и лучшие практики

Constructor Injection

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

public class ProductService
{
    private readonly IProductRepository _repository;
    private readonly ILogger<ProductService> _logger;
    
    public ProductService(IProductRepository repository, ILogger<ProductService> logger)
    {
        _repository = repository;
        _logger = logger;
    }
}

Method Injection

Когда зависимость нужна только в одном методе.

public class ReportGenerator
{
    public void Generate(IReportFormatter formatter, ReportData data)
    {
        formatter.Format(data);
    }
}

Property Injection

Менее распространен в ASP.NET Core, но поддерживается некоторыми контейнерами.

public class NotificationService
{
    [FromServices] // Атрибут для property injection
    public IEmailSender EmailSender { get; set; }
}

Продвинутые сценарии

Цепочки зависимостей

Контейнер автоматически разрешает цепочки зависимостей.

services.AddScoped<IAuthService, AuthService>();
services.AddScoped<IUserService, UserService>(); // Зависит от IAuthService
services.AddScoped<IOrderService, OrderService>(); // Зависит от IUserService

Условная регистрация

Регистрация сервисов в зависимости от условий.

if (env.IsDevelopment())
{
    services.AddScoped<IDataService, MockDataService>();
}
else
{
    services.AddScoped<IDataService, ProductionDataService>();
}

Использование TryAdd

Предотвращение дублирования регистраций.

// Не перезапишет существующую регистрацию
services.TryAddSingleton<ICacheService, MemoryCacheService>();

Выбор подхода

При выборе подхода к внедрению зависимостей учитывайте:

1. Сложность объекта - для сложных объектов используйте фабричные методы
2. Тестируемость - всегда предпочитайте интерфейсы для легкого мокирования
3. Производительность - правильно выбирайте время жизни сервисов
4. Читаемость кода - используйте метод расширения для группировки связанных сервисов
5. Гибкость - оставляйте возможность для будущих изменений реализации

Внедрение зависимостей в ASP.NET Core - это мощный механизм, который при правильном использовании значительно улучшает архитектуру приложения, делая его более модульным, тестируемым и поддерживаемым.