Инъекция зависимостей в ASP.NET Core - Практический подход

// Жесткая связь — класс сам создает зависимость
public class OrderProcessor
{
    private readonly PaymentService _paymentService;
    
    public OrderProcessor()
    {
        _paymentService = new PaymentService(); // Вот она — жесткая связь
    }
}

public class OrderProcessor
{
    private readonly IPaymentService _paymentService;
    
    public OrderProcessor(IPaymentService paymentService)
    {
        _paymentService = paymentService; // Зависимость пришла извне
    }
}

services.AddScoped<IPaymentService, StripePaymentService>();

public interface IServiceProvider
{
    object GetService(Type serviceType);
}

services.AddTransient<IDataGenerator, RandomDataGenerator>();

services.AddScoped<IOrderRepository, SqlOrderRepository>();

services.AddSingleton<ICacheManager, MemoryCacheManager>();

// Опасно! Не делайте так в реальном коде!
services.AddSingleton<DbContext, MyAppDbContext>(); // неправильно!

// Правельно — DbContext должен быть scoped, чтобы жить внутри HTTP-запроса
services.AddDbContext<MyAppDbContext>(options =>
    options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

// До .NET 6 (в Startup.cs)
public void ConfigureServices(IServiceCollection services)
{
    services.AddScoped<IUserService, UserService>();
    services.AddTransient<INotificationService, EmailNotificationService>();
    services.AddSingleton<IConfiguration>(Configuration);
}
 
// В .NET 6+ (Program.cs)
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddScoped<IUserService, UserService>();
builder.Services.AddTransient<INotificationService, EmailNotificationService>();

services.AddTransient<IReportGenerator>(serviceProvider => {
    var config = serviceProvider.GetService<IConfiguration>();
    var templatesPath = config["ReportTemplatePath"];
    return new PdfReportGenerator(templatesPath);
});

if (env.IsDevelopment())
{
    services.AddScoped<IPaymentGateway, MockPaymentGateway>();
}
else
{
    services.AddScoped<IPaymentGateway, StripePaymentGateway>();
}

// Регистрируем все доступные платежные системы
services.AddTransient<StripePaymentGateway>();
services.AddTransient<PayPalPaymentGateway>();
services.AddTransient<BitcoinPaymentGateway>();
 
// И фабрику, которая выбирает конкретную реализацию
services.AddTransient<Func<string, IPaymentGateway>>(serviceProvider => gatewayName =>
{
    return gatewayName switch
    {
        "stripe" => serviceProvider.GetService<StripePaymentGateway>(),
        "paypal" => serviceProvider.GetService<PayPalPaymentGateway>(),
        "bitcoin" => serviceProvider.GetService<BitcoinPaymentGateway>(),
        _ => throw new ArgumentException($"Unknown gateway: {gatewayName}")
    };
});

public class PaymentProcessor
{
    private readonly Func<string, IPaymentGateway> _gatewayFactory;
 
    public PaymentProcessor(Func<string, IPaymentGateway> gatewayFactory)
    {
        _gatewayFactory = gatewayFactory;
    }
 
    public async Task ProcessPayment(Order order)
    {
        var gateway = _gatewayFactory(order.PreferredPaymentMethod);
        await gateway.ProcessPayment(order.Amount);
    }
}

public class SmtpSettings
{
    public string Server { get; set; }
    public int Port { get; set; }
    public string Username { get; set; }
    public string Password { get; set; }
}

services.Configure<SmtpSettings>(Configuration.GetSection("Smtp"));

public class EmailService
{
    private readonly SmtpSettings _settings;
 
    public EmailService(IOptions<SmtpSettings> options)
    {
        _settings = options.Value;
    }
 
    public void SendEmail(string to, string subject, string body)
    {
        // Использование _settings для отправки email
    }
}

// Антипаттерн! Scoped-сервис в Singleton-сервисе
public class GlobalCache // зарегистрирован как Singleton
{
private readonly MyDbContext _dbContext; // DbContext обычно Scoped!
 
public GlobalCache(MyDbContext dbContext)
{
    _dbContext = dbContext; // Опасность! Этот контекст никогда не обновится!
}
}

public class ComplexService
{
private readonly IServiceProvider _serviceProvider;
 
public ComplexService(IServiceProvider serviceProvider)
{
    _serviceProvider = serviceProvider;
}
 
public void ProcessSpecialCase(string caseType)
{
    // Получаем нужный обработчик в зависимости от типа кейса
    var handler = _serviceProvider.GetService(GetHandlerType(caseType));
    
    // Делаем что-то с handler
}
 
private Type GetHandlerType(string caseType)
{
    // Логика определения типа обработчика
    return typeof(DefaultCaseHandler);
}
}

public class BackgroundProcessor
{
private readonly IServiceScopeFactory _scopeFactory;
 
public BackgroundProcessor(IServiceScopeFactory scopeFactory)
{
    _scopeFactory = scopeFactory;
}
 
public async Task Process()
{
    // Создаем новый скоуп, аналогичный HTTP-запросу
    using (var scope = _scopeFactory.CreateScope())
    {
        // Получаем scoped-сервис из нового скоупа
        var dbContext = scope.ServiceProvider.GetRequiredService<MyDbContext>();
        
        // Работаем с сервисом
        var items = await dbContext.Items.ToListAsync();
        // ...
    } // При выходе из using скоуп закрывается, а dbContext уничтожается
}
}

// В Autofac это выглядело бы так:
builder.RegisterType<StripePaymentGateway>().Named<IPaymentGateway>("stripe");
builder.RegisterType<PayPalPaymentGateway>().Named<IPaymentGateway>("paypal");

services.AddTransient<IOriginalService, OriginalService>();
services.AddTransient<IOriginalService>(serviceProvider => {
    var original = serviceProvider.GetRequiredService<OriginalService>();
    return new DecoratorService(original);
});

[ApiController]
[Route("[controller]")]
public class UsersController : ControllerBase
{
    private readonly IUserService _userService;
    private readonly ILogger<UsersController> _logger;
 
    public UsersController(IUserService userService, ILogger<UsersController> logger)
    {
        _userService = userService;
        _logger = logger;
    }
 
    [HttpGet("{id}")]
    public async Task<ActionResult<UserDto>> GetUser(int id)
    {
        _logger.LogInformation("Fetching user with ID: {UserId}", id);
        
        var user = await _userService.GetByIdAsync(id);
        if (user == null)
            return NotFound();
            
        return Ok(user);
    }
}

public class UserService : IUserService
{
    private readonly IUserRepository _repository;
    private readonly ICacheService _cache;
    
    public UserService(IUserRepository repository, ICacheService cache)
    {
        _repository = repository;
        _cache = cache;
    }
    
    public async Task<UserDto> GetByIdAsync(int id)
    {
        // Сначала проверяем кэш
        var cachedUser = await _cache.GetAsync<UserDto>($"user:{id}");
        if (cachedUser != null)
            return cachedUser;
        
        // Если в кэше нет — получаем из репозитория
        var user = await _repository.GetByIdAsync(id);
        if (user != null)
        {
            // Сохраняем в кэш на будущее
            await _cache.SetAsync($"user:{id}", user, TimeSpan.FromMinutes(10));
        }
        
        return user;
    }
}

|-- Presentation Layer (Controllers, Views)
|   |-- depends on -->
|-- Business Logic Layer (Services)
|   |-- depends on -->
|-- Data Access Layer (Repositories)

public class AuditLogActionFilter : IActionFilter
{
    private readonly IAuditLogger _auditLogger;
 
    public AuditLogActionFilter(IAuditLogger auditLogger)
    {
        _auditLogger = auditLogger;
    }
 
    public void OnActionExecuting(ActionExecutingContext context)
    {
        // Логирование до выполнения действия
        _auditLogger.LogAction(
            context.HttpContext.User.Identity.Name,
            context.ActionDescriptor.DisplayName);
    }
 
    public void OnActionExecuted(ActionExecutedContext context)
    {
        // Можно логировать результат действия
    }
}

services.AddScoped<AuditLogActionFilter>();
services.AddMvc(options =>
{
    options.Filters.AddService<AuditLogActionFilter>();
});

public class ChatHub : Hub
{
    private readonly IChatService _chatService;
    private readonly IUserConnectionManager _connectionManager;
 
    public ChatHub(IChatService chatService, IUserConnectionManager connectionManager)
    {
        _chatService = chatService;
        _connectionManager = connectionManager;
    }
 
    public async Task SendMessage(string message)
    {
        var user = Context.User.Identity.Name;
        var formattedMessage = await _chatService.FormatMessage(user, message);
        
        // Сохраняем сообщение
        await _chatService.SaveMessageAsync(user, message);
        
        // Отправляем всем подключенным клиентам
        await Clients.All.SendAsync("ReceiveMessage", user, formattedMessage);
    }
}

[ApiController]
[Route("[controller]")]
public class PaymentController : ControllerBase
{
    private readonly IPaymentGateway _paymentGateway;
    
    public PaymentController(IPaymentGateway paymentGateway)
    {
        _paymentGateway = paymentGateway;
    }
    
    [HttpPost]
    public async Task<IActionResult> ProcessPayment([FromBody] PaymentRequest request)
    {
        var result = await _paymentGateway.ProcessPaymentAsync(
            request.CardNumber,
            request.ExpiryDate,
            request.Cvv,
            request.Amount);
            
        if (result.Success)
            return Ok(new { TransactionId = result.TransactionId });
            
        return BadRequest(new { Error = result.ErrorMessage });
    }
}

[Fact]
public async Task ProcessPayment_WithValidCard_ReturnsOk()
{
    // Arrange
    var mockGateway = new Mock<IPaymentGateway>();
    mockGateway.Setup(g => g.ProcessPaymentAsync(
        It.IsAny<string>(),
        It.IsAny<string>(),
        It.IsAny<string>(),
        It.IsAny<decimal>()
    )).ReturnsAsync(new PaymentResult { 
        Success = true, 
        TransactionId = "test-tx-123" 
    });
    
    var controller = new PaymentController(mockGateway.Object);
    var request = new PaymentRequest
    {
        CardNumber = "4111111111111111",
        ExpiryDate = "12/25",
        Cvv = "123",
        Amount = 99.99m
    };
    
    // Act
    var result = await controller.ProcessPayment(request);
    
    // Assert
    var okResult = Assert.IsType<OkObjectResult>(result);
    dynamic value = okResult.Value;
    Assert.Equal("test-tx-123", value.TransactionId);
}

public class PaymentApiTests : IClassFixture<WebApplicationFactory<Startup>>
{
    private readonly WebApplicationFactory<Startup> _factory;
    
    public PaymentApiTests(WebApplicationFactory<Startup> factory)
    {
        _factory = factory.WithWebHostBuilder(builder =>
        {
            builder.ConfigureServices(services =>
            {
                // Заменяем реальный сервис платежей на тестовый
                services.RemoveAll<IPaymentGateway>();
                services.AddScoped<IPaymentGateway, TestPaymentGateway>();
            });
        });
    }
    
    [Fact]
    public async Task PaymentEndpoint_WithValidRequest_ReturnsSuccess()
    {
        // Создаем HTTP-клиент с настроенными тестовыми сервисами
        var client = _factory.CreateClient();
        
        // Далее тестируем API через этот клиент
    }
}

@page "/counter"
@inject ICounterService CounterService
 
<h1>Counter</h1>
 
<p>Current count: @currentCount</p>
 
<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>
 
@code {
private int currentCount = 0;
 
protected override async Task OnInitializedAsync()
{
    currentCount = await CounterService.GetInitialCountAsync();
}
 
private async Task IncrementCount()
{
    currentCount = await CounterService.IncrementCountAsync(currentCount);
}
}

@page "/counter"
 
<h1>Counter</h1>
 
<p>Current count: @currentCount</p>
 
<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>
 
@code {
[Inject]
private ICounterService CounterService { get; set; }
 
private int currentCount = 0;
 
// ... остальной код как выше
}

// Startup.cs
[assembly: FunctionsStartup(typeof(MyNamespace.Startup))]
namespace MyNamespace
{
public class Startup : FunctionsStartup
{
    public override void Configure(IFunctionsHostBuilder builder)
    {
        builder.Services.AddHttpClient();
        builder.Services.AddScoped<IDataService, DataService>();
        builder.Services.AddSingleton<ICacheService, MemoryCacheService>();
    }
}
}

public class ProcessDataFunction
{
private readonly IDataService _dataService;
private readonly ICacheService _cacheService;
 
public ProcessDataFunction(IDataService dataService, ICacheService cacheService)
{
    _dataService = dataService;
    _cacheService = cacheService;
}
 
[FunctionName("ProcessData")]
public async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequest req,
    ILogger log)
{
    log.LogInformation("Processing data request");
    
    // Проверяем кэш
    string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
    var cacheKey = ComputeHash(requestBody);
    
    if (_cacheService.TryGetValue(cacheKey, out var cachedResult))
    {
        log.LogInformation("Cache hit!");
        return new OkObjectResult(cachedResult);
    }
    
    // Обрабатываем данные
    var data = JsonConvert.DeserializeObject<DataPayload>(requestBody);
    var result = await _dataService.ProcessAsync(data);
    
    // Сохраняем в кэш
    _cacheService.Set(cacheKey, result, TimeSpan.FromMinutes(15));
    
    return new OkObjectResult(result);
}
 
private static string ComputeHash(string input)
{
    // Хеш-функция для создания ключей кэша
    using var md5 = MD5.Create();
    var hashBytes = md5.ComputeHash(Encoding.UTF8.GetBytes(input));
    return Convert.ToBase64String(hashBytes);
}
}

public class UserProfileTagHelper : TagHelper
{
private readonly IUserService _userService;
 
public UserProfileTagHelper(IUserService userService)
{
    _userService = userService;
}
 
[HtmlAttributeName("user-id")]
public int UserId { get; set; }
 
public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
    var user = await _userService.GetByIdAsync(UserId);
    
    output.TagName = "div";
    output.Attributes.SetAttribute("class", "user-profile");
    
    if (user == null)
    {
        output.Content.SetHtmlContent("<p>User not found</p>");
        return;
    }
    
    output.Content.SetHtmlContent($@"
        <div class='profile-header'>
            <img src='{user.AvatarUrl}' alt='{user.Name}' />
            <h3>{user.Name}</h3>
        </div>
        <div class='profile-details'>
            <p>Joined: {user.JoinedDate.ToShortDateString()}</p>
            <p>Posts: {user.PostCount}</p>
        </div>
    ");
}
}

public class ServiceA
{
    private readonly ServiceB _serviceB;
    
    public ServiceA(ServiceB serviceB)
    {
        _serviceB = serviceB;
    }
}
 
public class ServiceB
{
    private readonly ServiceA _serviceA;
    
    public ServiceB(ServiceA serviceA)
    {
        _serviceA = serviceA;
    }
}

public class ServiceA
{
    private readonly IServiceProvider _serviceProvider;
    
    public ServiceA(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }
    
    public void DoSomething()
    {
        // Получаем ServiceB только когда нужно
        var serviceB = _serviceProvider.GetRequiredService<ServiceB>();
        serviceB.Execute();
    }
}

public interface IRepository<T> where T : class
{
    Task<T> GetByIdAsync(int id);
    Task<IEnumerable<T>> GetAllAsync();
    Task AddAsync(T entity);
    Task UpdateAsync(T entity);
    Task DeleteAsync(int id);
}
 
public class Repository<T> : IRepository<T> where T : class
{
    private readonly DbContext _context;
    
    public Repository(DbContext context)
    {
        _context = context;
    }
    
    // Реализация методов
}

services.AddScoped(typeof(IRepository<>), typeof(Repository<>));

public class UserService
{
    private readonly IRepository<User> _userRepository;
    
    public UserService(IRepository<User> userRepository)
    {
        _userRepository = userRepository;
    }
}
 
public class ProductService
{
    private readonly IRepository<Product> _productRepository;
    
    public ProductService(IRepository<Product> productRepository)
    {
        _productRepository = productRepository;
    }
}

services.AddTransient<IComplexService>(sp => {
    var config = sp.GetRequiredService<IConfiguration>();
    var dbContext = sp.GetRequiredService<AppDbContext>();
    var logger = sp.GetRequiredService<ILogger<ComplexService>>();
    
    var connectionString = config.GetConnectionString("SpecialApi");
    var timeout = config.GetValue<TimeSpan>("ApiTimeout");
    
    return new ComplexService(dbContext, logger, connectionString, timeout);
});

public class DynamicServiceConsumer
{
    private readonly Func<IServiceType> _serviceFactory;
    
    public DynamicServiceConsumer(Func<IServiceType> serviceFactory)
    {
        _serviceFactory = serviceFactory;
    }
    
    public void ProcessSomething()
    {
        // Создаем новый экземпляр каждый раз
        var service = _serviceFactory();
        service.DoWork();
    }
}

// Регистрация фабрики, которая принимает параметры
services.AddTransient<Func<string, int, IConfigurableService>>((sp, name, value) => {
    return new ConfigurableService(name, value);
});
 
// Использование
public class ServiceWithFactory
{
    private readonly Func<string, int, IConfigurableService> _factory;
    
    public ServiceWithFactory(Func<string, int, IConfigurableService> factory)
    {
        _factory = factory;
    }
    
    public void Execute()
    {
        var service1 = _factory("Service1", 100);
        var service2 = _factory("Service2", 200);
        
        // ...
    }
}

public class CompositeMessageService : IMessageService
{
    private readonly IServiceProvider _serviceProvider;
    private string _currentImplementationKey = "default";
    
    // Словарь с доступными реализациями
    private readonly Dictionary<string, Type> _implementations = new()
    {
        ["default"] = typeof(DefaultMessageService),
        ["premium"] = typeof(PremiumMessageService),
        ["fallback"] = typeof(FallbackMessageService)
    };
    
    public CompositeMessageService(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }
    
    public void SwitchImplementation(string key)
    {
        if (_implementations.ContainsKey(key))
        {
            _currentImplementationKey = key;
        }
        else
        {
            throw new ArgumentException($"Implementation {key} not found");
        }
    }
    
    public string GetMessage()
    {
        // Создаем нужную реализацию налету
        var implementationType = _implementations[_currentImplementationKey];
        var implementation = (IMessageService)ActivatorUtilities
            .CreateInstance(_serviceProvider, implementationType);
            
        return implementation.GetMessage();
    }
}

var messageService = serviceProvider.GetRequiredService<CompositeMessageService>();
 
// Переключаемся на premium-реализацию
messageService.SwitchImplementation("premium");

public class DataInitializerService : IHostedService
{
    private readonly DatabaseService _databaseService;
    
    public DataInitializerService(DatabaseService databaseService)
    {
        _databaseService = databaseService;
    }
    
    public async Task StartAsync(CancellationToken cancellationToken)
    {
        // Асинхронная инициализация
        await _databaseService.InitializeAsync();
    }
    
    public Task StopAsync(CancellationToken cancellationToken)
    {
        return Task.CompletedTask;
    }
}
 
// Регистрация
services.AddSingleton<DatabaseService>();
services.AddHostedService<DataInitializerService>();

public class LazyDatabaseService
{
    private readonly Lazy<Task<DbConnection>> _connection;
    
    public LazyDatabaseService(IConfiguration configuration)
    {
        _connection = new Lazy<Task<DbConnection>>(async () => {
            var connection = new SqlConnection(configuration.GetConnectionString("Default"));
            await connection.OpenAsync();
            return connection;
        });
    }
    
    public async Task<DbConnection> GetConnectionAsync()
    {
        return await _connection.Value;
    }
}

// Установите пакеты:
// Autofac
// Autofac.Extensions.DependencyInjection
 
public class Startup
{
    public IServiceProvider ConfigureServices(IServiceCollection services)
    {
        // Добавляем стандартные сервисы ASP.NET Core
        services.AddControllers();
        
        // Создаём контейнер Autofac
        var builder = new ContainerBuilder();
        
        // Регистрируем сервисы в Autofac
        builder.RegisterType<CustomService>().As<ICustomService>()
               .InstancePerLifetimeScope(); // Эквивалент AddScoped
        
        // Именованные регистрации (не поддерживается встроенным контейнером)
        builder.RegisterType<SqlOrderRepository>().Named<IOrderRepository>("sql");
        builder.RegisterType<MongoOrderRepository>().Named<IOrderRepository>("mongo");
        
        // Декорирование сервисов (не поддерживается встроенным контейнером)
        builder.RegisterType<BaseNotificationService>().As<INotificationService>();
        builder.RegisterDecorator<LoggingNotificationDecorator, INotificationService>();
        
        // Регистрация модулей
        builder.RegisterModule(new DataAccessModule());
        
        // Добавляем сервисы из стандартной коллекции в Autofac
        builder.Populate(services);
        
        // Строим контейнер и возвращаем его как IServiceProvider
        var container = builder.Build();
        return new AutofacServiceProvider(container);
    }
}

// Внедрение именованных сервисов
public class OrderProcessor
{
    private readonly IOrderRepository _repository;
    
    public OrderProcessor([Named("mongo")] IOrderRepository repository)
    {
        _repository = repository;
    }
}

// Регистрируем все классы, реализующие IHandler в сборке
builder.RegisterAssemblyTypes(Assembly.GetExecutingAssembly())
       .Where(t => t.IsAssignableTo<IHandler>())
       .AsImplementedInterfaces()
       .InstancePerDependency();

// Регистрируем базовую реализацию
services.AddScoped<IMailService, SmtpMailService>();
 
// Затем декорируем её
services.AddScoped<IMailService>(serviceProvider => {
    var originalService = serviceProvider.GetRequiredService<SmtpMailService>();
    return new LoggingMailServiceDecorator(
        originalService, 
        serviceProvider.GetRequiredService<ILogger<LoggingMailServiceDecorator>>()
    );
});

// Регистрируем все стратегии
services.AddTransient<CreditCardPaymentStrategy>();
services.AddTransient<PayPalPaymentStrategy>();
services.AddTransient<CryptoPaymentStrategy>();
 
// Регистрируем фабрику стратегий
services.AddTransient<Func<string, IPaymentStrategy>>(serviceProvider => strategyName => {
    return strategyName switch {
        "credit_card" => serviceProvider.GetService<CreditCardPaymentStrategy>(),
        "paypal" => serviceProvider.GetService<PayPalPaymentStrategy>(),
        "crypto" => serviceProvider.GetService<CryptoPaymentStrategy>(),
        _ => throw new ArgumentException($"Unknown strategy: {strategyName}")
    };
});
 
// Использование
public class PaymentProcessor
{
    private readonly Func<string, IPaymentStrategy> _strategyFactory;
    
    public PaymentProcessor(Func<string, IPaymentStrategy> strategyFactory)
    {
        _strategyFactory = strategyFactory;
    }
    
    public void ProcessPayment(Order order)
    {
        var strategy = _strategyFactory(order.PaymentMethod);
        strategy.Process(order.Amount);
    }
}

public class UserManager
{
    private readonly IUserValidator _validator;
    private readonly IPasswordHasher _hasher;
    private readonly IUserRepository _repository;
    private readonly IEmailService _emailService;
    
    public UserManager(
        IUserValidator validator,
        IPasswordHasher hasher,
        IUserRepository repository,
        IEmailService emailService)
    {
        _validator = validator;
        _hasher = hasher;
        _repository = repository;
        _emailService = emailService;
    }
    
    public async Task RegisterUser(string username, string password, string email)
    {
        // Каждый компонент делает своё дело
        _validator.ValidateNewUser(username, email);
        var hashedPassword = _hasher.HashPassword(password);
        
        var user = new User {
            Username = username,
            PasswordHash = hashedPassword,
            Email = email
        };
        
        await _repository.CreateUserAsync(user);
        await _emailService.SendWelcomeEmailAsync(email, username);
    }
}

// Безопасное получение сервиса, возвращает null если сервис не найден
var service = serviceProvider.GetService<IMyService>();
if (service != null) {
    // Используем сервис
}
 
// GetRequiredService выбросит исключение, если сервис не найден
try {
    var service = serviceProvider.GetRequiredService<IMyService>();
    // Используем сервис
} catch (InvalidOperationException ex) {
    // Обрабатываем ошибку
    logger.LogError(ex, "Failed to resolve IMyService");
}

services.AddTransient<IMyService>(sp => {
    try {
        // Пытаемся получить предпочтительную реализацию
        return sp.GetService<OptimalServiceImplementation>();
    }
    catch {
        // В случае ошибки используем запасной вариант
        return new FallbackServiceImplementation();
    }
});

public void ConfigureServices(IServiceCollection services)
{
    services.AddLogging(builder => {
        builder.AddConsole();
        builder.AddDebug();
        
        // Установите минимальный уровень логирования для Microsoft.Extensions.DependencyInjection
        builder.AddFilter("Microsoft.Extensions.DependencyInjection", LogLevel.Debug);
    });
    
    // Остальные регистрации...
}

public class DiagnosticsTool
{
    private readonly IServiceProvider _serviceProvider;
    
    public DiagnosticsTool(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }
    
    public bool CanResolve<T>()
    {
        try {
            _serviceProvider.GetService<T>();
            return true;
        } catch {
            return false;
        }
    }
    
    public void LogAllRegisteredServices(ILogger logger)
    {
        // В стандартном контейнере нет прямого доступа к регистрациям
        // С Autofac или другими контейнерами это было бы проще
        logger.LogInformation("Starting service resolution diagnostics");
        
        // Проверяем известные сервисы
        CheckAndLogService<IUserService>("IUserService");
        CheckAndLogService<IOrderService>("IOrderService");
        // ... и так далее
        
        void CheckAndLogService<T>(string serviceName)
        {
            try {
                var service = _serviceProvider.GetService<T>();
                logger.LogInformation(
                    "Service {ServiceName} resolved successfully. Implementation: {Implementation}",
                    serviceName,
                    service?.GetType().FullName ?? "null"
                );
            } catch (Exception ex) {
                logger.LogError(
                    ex,
                    "Failed to resolve {ServiceName}",
                    serviceName
                );
            }
        }
    }
}

// Было: длинная цепочка зависимостей
services.AddScoped<IUserValidator>();
services.AddScoped<IUserRepository>(); 
services.AddScoped<IUserService>();
services.AddScoped<IUserPermissionService>();
services.AddScoped<IUserController>();
 
// Стало: схлопнутые зависимости для критичного пути
services.AddScoped<IUserFacade>(); // Фасад объединяет несколько сервисов

// Этот сервис не хранит состояния и не меняется — идеальный кандидат в Singleton
services.AddSingleton<IDataValidator, DataValidator>();

// Создаем и кешируем фабрику контроллеров при старте приложения
services.AddSingleton<Func<ControllerContext, UserController>>(sp => 
{
var userService = sp.GetRequiredService<IUserService>();
var logger = sp.GetRequiredService<ILogger<UserController>>();
 
return (context) => new UserController(userService, logger) 
{
    ControllerContext = context
};
});

public static class ServiceLocator
{
private static readonly ConcurrentDictionary<Type, object> _services = new();
 
// Инициализация при старте
public static void Initialize(IServiceProvider provider)
{
    // Резолвим и сохраняем только нужные сервисы
    _services[typeof(IUserRepository)] = provider.GetRequiredService<IUserRepository>();
    // ...другие нужные сервисы
}
 
// Быстрый доступ без накладных расходов DI
public static T Get<T>() where T : class
{
    return _services.TryGetValue(typeof(T), out var service) 
        ? (T)service 
        : throw new InvalidOperationException($"Service {typeof(T).Name} not registered");
}
}

public class CustomMiddleware
{
private readonly RequestDelegate _next;
private readonly ILogger<CustomMiddleware> _logger;
private readonly IConfiguration _config;
 
// Получаем зависимости через конструктор
public CustomMiddleware(RequestDelegate next, ILogger<CustomMiddleware> logger, IConfiguration config)
{
    _next = next;
    _logger = logger;
    _config = config;
}
 
public async Task InvokeAsync(HttpContext context)
{
    _logger.LogInformation("Request incoming: {Path}", context.Request.Path);
    
    // Делаем что-то с контекстом
    context.Items["Timestamp"] = DateTime.UtcNow;
    
    // Передаем управление следующему middleware
    await _next(context);
}
}
 
// Регистрация через метод расширения
public static class CustomMiddlewareExtensions
{
public static IApplicationBuilder UseCustomMiddleware(this IApplicationBuilder app)
{
    return app.UseMiddleware<CustomMiddleware>();
}
}