dotnet add package Microsoft.Extensions.Hosting

public class LifecycleService
{
    private readonly IHostApplicationLifetime _lifetime;
    private readonly ILogger<LifecycleService> _logger;

    public LifecycleService(IHostApplicationLifetime lifetime, ILogger<LifecycleService> logger)
    {
        _lifetime = lifetime;
        _logger = logger;

        // Підписка на події життєвого циклу через CancellationToken
        _lifetime.ApplicationStarted.Register(OnStarted);
        _lifetime.ApplicationStopping.Register(OnStopping);
        _lifetime.ApplicationStopped.Register(OnStopped);
    }

    private void OnStarted()
    {
        _logger.LogInformation("Application has started successfully");
        // Тут можна виконати post-startup завдання: warming up caches, health check
    }

    private void OnStopping()
    {
        _logger.LogWarning("Application is stopping... Finishing current work");
        // Graceful shutdown: завершити активні операції, flush логів
    }

    private void OnStopped()
    {
        _logger.LogInformation("Application has stopped");
        // Cleanup: закрити з'єднання, зберегти стан
    }

    public void RequestShutdown()
    {
        _logger.LogWarning("Shutdown requested programmatically");
        _lifetime.StopApplication(); // Програмна зупинка всього застосунку
    }
}

public interface IHostedService
{
    Task StartAsync(CancellationToken cancellationToken);
    Task StopAsync(CancellationToken cancellationToken);
}

// ❌ НЕПРАВИЛЬНО - блокує запуск Host
public class BadHostedService : IHostedService
{
    public async Task StartAsync(CancellationToken cancellationToken)
    {
        // Блокуємо Host!
        while (!cancellationToken.IsCancellationRequested)
        {
            await ProcessQueueAsync();
            await Task.Delay(1000);
        }
    }

    public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
}

// ✅ ПРАВИЛЬНО - не блокує запуск Host
public class GoodHostedService : BackgroundService
{
    private readonly ILogger<GoodHostedService> _logger;

    public GoodHostedService(ILogger<GoodHostedService> logger)
    {
        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("Background service started");

        // ExecuteAsync виконується у фоновому Task - не блокує Host
        while (!stoppingToken.IsCancellationRequested)
        {
            await ProcessQueueAsync();
            await Task.Delay(1000, stoppingToken);
        }

        _logger.LogInformation("Background service stopped");
    }
}

// Реєстрація
builder.Services.AddHostedService<GoodHostedService>();

// ❌ Tight coupling - залежності створюються всередині класу
public class OrderService
{
    private readonly EmailService _emailService;
    private readonly PaymentProcessor _paymentProcessor;
    private readonly ILogger _logger;

    public OrderService()
    {
        // Hard-coded dependencies
        _emailService = new EmailService(new SmtpClient("smtp.gmail.com", 587));
        _paymentProcessor = new PaymentProcessor(new HttpClient());
        _logger = LogManager.GetLogger("OrderService");
    }

    public void ProcessOrder(Order order)
    {
        _paymentProcessor.Charge(order.Total);
        _emailService.SendConfirmation(order.CustomerEmail);
        _logger.LogInformation("Order processed: {OrderId}", order.Id);
    }
}

// ✅ Loose coupling - залежності отримуємо через конструктор
public class OrderService
{
    private readonly IEmailService _emailService;
    private readonly IPaymentProcessor _paymentProcessor;
    private readonly ILogger<OrderService> _logger;

    // Constructor Injection - єдиний спосіб отримати залежності
    public OrderService(
        IEmailService emailService,
        IPaymentProcessor paymentProcessor,
        ILogger<OrderService> logger)
    {
        _emailService = emailService;
        _paymentProcessor = paymentProcessor;
        _logger = logger;
    }

    public void ProcessOrder(Order order)
    {
        _paymentProcessor.Charge(order.Total);
        _emailService.SendConfirmation(order.CustomerEmail);
        _logger.LogInformation("Order processed: {OrderId}", order.Id);
    }
}

// Реєстрація в DI Container
var builder = WebApplication.CreateBuilder(args);

builder.Services.AddSingleton<IEmailService, EmailService>();
builder.Services.AddScoped<IPaymentProcessor, PaymentProcessor>();
builder.Services.AddScoped<OrderService>();

var app = builder.Build();

var builder = WebApplication.CreateBuilder(args);

// IServiceCollection - колекція ServiceDescriptor'ів
var services = builder.Services;

// Різні способи реєстрації:

// 1. Interface → Implementation
services.AddSingleton<IEmailService, EmailService>();

// 2. Concrete type (Interface = Implementation)
services.AddScoped<OrderService>();

// 3. Factory method
services.AddTransient<IPaymentProcessor>(sp =>
{
    var config = sp.GetRequiredService<IConfiguration>();
    var apiKey = config["PaymentGateway:ApiKey"];
    return new StripePaymentProcessor(apiKey);
});

// 4. Existing instance (only for singletons)
var cache = new MemoryCache(new MemoryCacheOptions());
services.AddSingleton<IMemoryCache>(cache);

// 5. Generic types
services.AddScoped(typeof(IRepository<>), typeof(Repository<>));

var app = builder.Build();

// IServiceProvider - resolver для отримання сервісів
var serviceProvider = app.Services;

// 1. GetRequiredService - кидає exception якщо не знайдено
var emailService = serviceProvider.GetRequiredService<IEmailService>();

// 2. GetService - повертає null якщо не знайдено
var optionalService = serviceProvider.GetService<IOptionalService>();

// 3. GetServices - повертає всі реєстрації (для multiple implementations)
var handlers = serviceProvider.GetServices<INotificationHandler>();

// 4. Constructor Injection (preferred way)
public class MyController : ControllerBase
{
    private readonly IEmailService _emailService;

    public MyController(IEmailService emailService)
    {
        _emailService = emailService;
    }
}

services.AddTransient<IGuidService, GuidService>();

public class GuidService : IGuidService
{
    private readonly Guid _instanceId = Guid.NewGuid();

    public Guid GetInstanceId() => _instanceId;
}

// Usage
public class MyController : ControllerBase
{
    private readonly IGuidService _guidService1;
    private readonly IGuidService _guidService2;

    public MyController(IGuidService guidService1, IGuidService guidService2)
    {
        _guidService1 = guidService1;
        _guidService2 = guidService2;
    }

    [HttpGet("transient")]
    public IActionResult Test()
    {
        // ❗ _guidService1 та _guidService2 — це РІЗНІ інстанси
        return Ok(new
        {
            service1 = _guidService1.GetInstanceId(),
            service2 = _guidService2.GetInstanceId()
        });
        // Output: {"service1": "abc-123", "service2": "def-456"}
    }
}

services.AddScoped<IGuidService, GuidService>();

// В ASP.NET Core - один scope = один HTTP request
public class MyController : ControllerBase
{
    private readonly IGuidService _guidService1;
    private readonly IGuidService _guidService2;

    public MyController(IGuidService guidService1, IGuidService guidService2)
    {
        _guidService1 = guidService1;
        _guidService2 = guidService2;
    }

    [HttpGet("scoped")]
    public IActionResult Test()
    {
        // ✅ _guidService1 та _guidService2 — це ОДИН інстанс (в межах request)
        return Ok(new
        {
            service1 = _guidService1.GetInstanceId(),
            service2 = _guidService2.GetInstanceId()
        });
        // Output: {"service1": "abc-123", "service2": "abc-123"}
    }
}

services.AddSingleton<IGuidService, GuidService>();

// Єдиний інстанс для всього додатку
public class RequestController : ControllerBase
{
    private readonly IGuidService _guidService;

    public RequestController(IGuidService guidService)
    {
        _guidService = guidService;
    }

    [HttpGet("test")]
    public IActionResult Test()
    {
        return Ok(new { instanceId = _guidService.GetInstanceId() });
        // Завжди повертає той самий GUID незалежно від кількості запитів!
    }
}

// ASP.NET Core автоматично створює scope для кожного HTTP request
var builder = WebApplication.CreateBuilder(args);

builder.Services.AddScoped<IOrderService, OrderService>();
builder.Services.AddScoped<AppDbContext>(); // EF Core DbContext

var app = builder.Build();

app.MapGet("/order/{id}", async (int id, IOrderService orderService) =>
{
    // orderService та AppDbContext всередині неї — одні і ті ж для цього request
    var order = await orderService.GetOrderAsync(id);
    return Results.Ok(order);
}); // Scope завершується тут, всі Scoped сервіси Dispose

app.Run();

var builder = Host.CreateApplicationBuilder(args);

builder.Services.AddScoped<IDataProcessor, DataProcessor>();
builder.Services.AddScoped<AppDbContext>();

var host = builder.Build();

// Manual scope creation
using (var scope = host.Services.CreateScope())
{
    var serviceProvider = scope.ServiceProvider;

    var processor = serviceProvider.GetRequiredService<IDataProcessor>();
    await processor.ProcessAsync();

    // Scope завершується тут — всі Scoped сервіси Dispose
}

// Новий scope
using (var scope = host.Services.CreateScope())
{
    var processor = scope.ServiceProvider.GetRequiredService<IDataProcessor>();
    await processor.ProcessAsync();
    // Новий інстанс IDataProcessor та AppDbContext!
}

// ❌ ANTI-PATTERN: Singleton captures Scoped
services.AddSingleton<CacheService>(); // Довгий lifetime
services.AddScoped<AppDbContext>();    // Короткий lifetime

public class CacheService
{
    private readonly AppDbContext _dbContext;

    // ❌ DbContext (Scoped) injection into Singleton
    public CacheService(AppDbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public async Task<User> GetUserAsync(int id)
    {
        // ❌ Використовуємо той самий DbContext для всіх requests!
        return await _dbContext.Users.FindAsync(id);
    }
}

// ✅ Обидва Scoped
services.AddScoped<CacheService>();
services.AddScoped<AppDbContext>();

services.AddSingleton<CacheService>();
services.AddScoped<AppDbContext>();

public class CacheService
{
    private readonly IServiceScopeFactory _scopeFactory;

    // ✅ Inject IServiceScopeFactory замість DbContext
    public CacheService(IServiceScopeFactory scopeFactory)
    {
        _scopeFactory = scopeFactory;
    }

    public async Task<User> GetUserAsync(int id)
    {
        // ✅ Створюємо новий scope кожного разу
        using var scope = _scopeFactory.CreateScope();
        var dbContext = scope.ServiceProvider.GetRequiredService<AppDbContext>();

        return await dbContext.Users.FindAsync(id);
    }
}

// Включення перевірки в Development
builder.Host.UseDefaultServiceProvider(options =>
{
    options.ValidateScopes = true; // Кидає exception при Captive Dependency
    options.ValidateOnBuild = true;
});

// ❌ ANTI-PATTERN: Service Locator
public class OrderService
{
    private readonly IServiceProvider _serviceProvider;

    public OrderService(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }

    public async Task ProcessOrderAsync(Order order)
    {
        // ❌ Витягуємо залежності вручну
        var emailService = _serviceProvider.GetRequiredService<IEmailService>();
        var paymentProcessor = _serviceProvider.GetRequiredService<IPaymentProcessor>();

        await paymentProcessor.ChargeAsync(order.Total);
        await emailService.SendConfirmationAsync(order.CustomerEmail);
    }
}

// ✅ Explicit dependencies
public class OrderService
{
    private readonly IEmailService _emailService;
    private readonly IPaymentProcessor _paymentProcessor;

    public OrderService(
        IEmailService emailService,
        IPaymentProcessor paymentProcessor)
    {
        _emailService = emailService;
        _paymentProcessor = paymentProcessor;
    }

    public async Task ProcessOrderAsync(Order order)
    {
        await _paymentProcessor.ChargeAsync(order.Total);
        await _emailService.SendConfirmationAsync(order.CustomerEmail);
    }
}

// ❌ ANTI-PATTERN: Circular dependency
public class OrderService
{
    private readonly IInventoryService _inventoryService;

    public OrderService(IInventoryService inventoryService)
    {
        _inventoryService = inventoryService;
    }
}

public class InventoryService : IInventoryService
{
    private readonly OrderService _orderService;

    // ❌ InventoryService залежить від OrderService, який залежить від IInventoryService
    public InventoryService(OrderService orderService)
    {
        _orderService = orderService;
    }
}

// Runtime error:
// System.InvalidOperationException: A circular dependency was detected

// ✅ Введіть проміжний сервіс
public interface IOrderValidator
{
    bool ValidateStock(int productId, int quantity);
}

public class OrderService
{
    private readonly IOrderValidator _validator;

    public OrderService(IOrderValidator validator)
    {
        _validator = validator;
    }
}

public class InventoryService : IInventoryService
{
    private readonly IOrderValidator _validator;

    public InventoryService(IOrderValidator validator)
    {
        _validator = validator;
    }
}

// ✅ Використання Lazy<T> для отримання залежності лише коли потрібно
public class OrderService
{
    private readonly Lazy<IInventoryService> _inventoryService;

    public OrderService(Lazy<IInventoryService> inventoryService)
    {
        _inventoryService = inventoryService;
    }

    public void ProcessOrder()
    {
        // Сервіс створюється тут, а не в конструкторі
        var inventory = _inventoryService.Value;
    }
}

var builder = WebApplication.CreateBuilder(args);

// builder.Configuration автоматично завантажує (в порядку пріоритету):
// 1. appsettings.json
// 2. appsettings.{Environment}.json
// 3. User Secrets (лише в Development)
// 4. Environment Variables
// 5. Command Line Arguments

var config = builder.Configuration;

// Простий доступ до значень
var connectionString = config["ConnectionStrings:DefaultConnection"];
var logLevel = config["Logging:LogLevel:Default"];

// Hierarchical access
var smtpHost = config["EmailSettings:Smtp:Host"];

{
    "ConnectionStrings": {
        "DefaultConnection": "Server=localhost;Database=MyApp;Trusted_Connection=True;"
    },
    "Logging": {
        "LogLevel": {
            "Default": "Information",
            "Microsoft.AspNetCore": "Warning"
        }
    },
    "EmailSettings": {
        "Smtp": {
            "Host": "smtp.gmail.com",
            "Port": 587,
            "EnableSsl": true
        },
        "From": "noreply@myapp.com"
    },
    "FeatureFlags": {
        "EnableNewCheckout": false,
        "MaxOrderItems": 100
    }
}

// appsettings.Development.json
{
  "ConnectionStrings": {
    "DefaultConnection": "Server=localhost;Database=MyApp_Dev;"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Debug" // Більш детальне логування в Dev
    }
  },
  "EmailSettings": {
    "Smtp": {
      "Host": "localhost", // Використовуємо локальний SMTP для тестів
      "Port": 25
    }
  }
}

// appsettings.Production.json
{
  "ConnectionStrings": {
    "DefaultConnection": "${DATABASE_CONNECTION_STRING}" // Підставляється з Environment Variable
  },
  "Logging": {
    "LogLevel": {
      "Default": "Warning" // Мінімум логів в prod
    }
  }
}

# CLI команда для ініціалізації
dotnet user-secrets init

# Додавання секрету
dotnet user-secrets set "EmailSettings:Smtp:Password" "my-secret-password"
dotnet user-secrets set "PaymentGateway:ApiKey" "sk_test_123456"

# Перегляд всіх секретів
dotnet user-secrets list

// secrets.json
{
    "EmailSettings:Smtp:Password": "my-secret-password",
    "PaymentGateway:ApiKey": "sk_test_123456"
}

var builder = WebApplication.CreateBuilder(args);

// User Secrets автоматично завантажуються в Development
var config = builder.Configuration;

var smtpPassword = config["EmailSettings:Smtp:Password"]; // Читається з User Secrets
var apiKey = config["PaymentGateway:ApiKey"];

// Для production використовуйте Environment Variables або Azure Key Vault

# Hierarchical keys замінюють : на __ (подвійне підкреслення)
export ConnectionStrings__DefaultConnection="Server=prod-db;Database=MyApp;"
export EmailSettings__Smtp__Password="prod-password"
export Logging__LogLevel__Default="Warning"

# Простіший синтаксис (для non-hierarchical)
export ASPNETCORE_ENVIRONMENT="Production"
export ASPNETCORE_URLS="http://+:5000"

var builder = WebApplication.CreateBuilder(args);

// Читання Environment Variables
var environment = builder.Environment.EnvironmentName; // "Development", "Staging", "Production"

// З IConfiguration (автоматично завантажено)
var connectionString = builder.Configuration["ConnectionStrings:DefaultConnection"];
// Якщо є Environment Variable, вона переозначить appsettings.json

# docker-compose.yml
version: '3.8'
services:
    api:
        image: myapp:latest
        environment:
            - ASPNETCORE_ENVIRONMENT=Production
            - ConnectionStrings__DefaultConnection=Server=postgres;Database=myapp;
            - EmailSettings__Smtp__Host=smtp.sendgrid.net
            - EmailSettings__Smtp__Password=${SMTP_PASSWORD} # З .env файлу

// ❌ Stringly-typed - легко зробити помилку
public class EmailService
{
    private readonly IConfiguration _configuration;

    public EmailService(IConfiguration configuration)
    {
        _configuration = configuration;
    }

    public async Task SendEmailAsync(string to, string subject, string body)
    {
        var host = _configuration["EmailSetings:Smtp:Host"]; // ❌ Typo: "Setings"
        var port = int.Parse(_configuration["EmailSettings:Smtp:Port"]);
        var enableSsl = bool.Parse(_configuration["EmailSettings:Smtp:EnableSsl"]);

        // ... SMTP logic
    }
}

public class EmailSettings
{
    public const string SectionName = "EmailSettings";

    public SmtpSettings Smtp { get; set; } = null!;
    public string From { get; set; } = string.Empty;
}

public class SmtpSettings
{
    public string Host { get; set; } = string.Empty;
    public int Port { get; set; }
    public bool EnableSsl { get; set; }
    public string? Username { get; set; }
    public string? Password { get; set; }
}

var builder = WebApplication.CreateBuilder(args);

// Bind configuration section to POCO
builder.Services.Configure<EmailSettings>(
    builder.Configuration.GetSection(EmailSettings.SectionName));

var app = builder.Build();

public class EmailService
{
    private readonly EmailSettings _settings;

    // ✅ Strongly-typed, compile-time safe
    public EmailService(IOptions<EmailSettings> options)
    {
        _settings = options.Value;
    }

    public async Task SendEmailAsync(string to, string subject, string body)
    {
        var host = _settings.Smtp.Host; // IntelliSense працює!
        var port = _settings.Smtp.Port;

        using var client = new SmtpClient(host, port)
        {
            EnableSsl = _settings.Smtp.EnableSsl,
            Credentials = new NetworkCredential(_settings.Smtp.Username, _settings.Smtp.Password)
        };

        // ... send email
    }
}

services.Configure<FeatureFlags>(
    builder.Configuration.GetSection("FeatureFlags"));

// IOptionsSnapshot перечитує конфігурацію кожен request
public class CheckoutController : ControllerBase
{
    private readonly FeatureFlags _featureFlags;

    public CheckoutController(IOptionsSnapshot<FeatureFlags> options)
    {
        _featureFlags = options.Value; // Свіже значення для цього request
    }

    [HttpPost]
    public IActionResult ProcessCheckout()
    {
        if (_featureFlags.EnableNewCheckout)
        {
            return ProcessNewCheckout();
        }

        return ProcessLegacyCheckout();
    }
}

services.Configure<CacheSettings>(
    builder.Configuration.GetSection("CacheSettings"));

public class CacheService
{
    private readonly IOptionsMonitor<CacheSettings> _optionsMonitor;

    public CacheService(IOptionsMonitor<CacheSettings> optionsMonitor)
    {
        _optionsMonitor = optionsMonitor;

        // Реагуємо на зміни конфігурації
        _optionsMonitor.OnChange(settings =>
        {
            Console.WriteLine($"Cache TTL changed to: {settings.DefaultTtlMinutes}");
            ReconfigureCache(settings);
        });
    }

    public string GetValue(string key)
    {
        // Завжди актуальні налаштування
        var settings = _optionsMonitor.CurrentValue;
        return _cache.Get(key, settings.DefaultTtlMinutes);
    }
}

public class EmailSettings
{
    public SmtpSettings Smtp { get; set; } = null!;
    public string From { get; set; } = string.Empty;
}

// Validation через Data Annotations
using System.ComponentModel.DataAnnotations;

public class SmtpSettings
{
    [Required]
    [RegularExpression(@"^[\w\.-]+$")]
    public string Host { get; set; } = string.Empty;

    [Range(1, 65535)]
    public int Port { get; set; }

    public bool EnableSsl { get; set; }
}

// Реєстрація з validation
builder.Services.AddOptions<EmailSettings>()
    .Bind(builder.Configuration.GetSection(EmailSettings.SectionName))
    .ValidateDataAnnotations() // Автоматична валідація через Data Annotations
    .ValidateOnStart(); // Валідація при старті додатку

builder.Services.AddOptions<EmailSettings>()
    .Bind(builder.Configuration.GetSection(EmailSettings.SectionName))
    .Validate(settings =>
    {
        // Custom validation logic
        if (settings.Smtp.EnableSsl && settings.Smtp.Port == 25)
        {
            return false; // Port 25 не підтримує SSL
        }

        if (string.IsNullOrEmpty(settings.Smtp.Password) && settings.Smtp.EnableSsl)
        {
            return false; // SSL потребує password
        }

        return true;
    }, "Invalid SMTP configuration")
    .ValidateOnStart();

public class OrderService
{
    private readonly ILogger<OrderService> _logger;

    public OrderService(ILogger<OrderService> logger)
    {
        _logger = logger;
    }

    public async Task<Order> CreateOrderAsync(CreateOrderRequest request)
    {
        _logger.LogInformation("Creating order for user {UserId}", request.UserId);

        try
        {
            var order = new Order { UserId = request.UserId, Total = request.Total };
            await _repository.AddAsync(order);

            _logger.LogInformation("Order {OrderId} created successfully", order.Id);
            return order;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Failed to create order for user {UserId}", request.UserId);
            throw;
        }
    }
}

_logger.LogTrace("Entering method ProcessOrder");
_logger.LogDebug("Cache miss for key {CacheKey}", key);
_logger.LogInformation("User {UserId} logged in", userId);
_logger.LogWarning("Retry attempt {Attempt} for order {OrderId}", attempt, orderId);
_logger.LogError(exception, "Payment failed for order {OrderId}", orderId);
_logger.LogCritical(exception, "Database connection lost!");

// ❌ String interpolation - втрачається структура
_logger.LogInformation($"User {userId} placed order {orderId} for ${total}");

// ✅ Structured logging - зберігає properties
_logger.LogInformation(
    "User {UserId} placed order {OrderId} for {Total:C}",
    userId,
    orderId,
    total);

{
    "@t": "2024-12-12T10:30:00.123Z",
    "@mt": "User {UserId} placed order {OrderId} for {Total}",
    "@l": "Information",
    "UserId": 12345,
    "OrderId": "ORD-98765",
    "Total": 149.99
}

dotnet add package Serilog.AspNetCore
dotnet add package Serilog.Sinks.Console
dotnet add package Serilog.Sinks.File
dotnet add package Serilog.Sinks.Seq  # Optional: для централізованого логування

using Serilog;

var builder = WebApplication.CreateBuilder(args);

// Замінюємо стандартний logger на Serilog
builder.Host.UseSerilog((context, services, configuration) => configuration
    .ReadFrom.Configuration(context.Configuration)
    .ReadFrom.Services(services)
    .Enrich.FromLogContext()
    .WriteTo.Console()
    .WriteTo.File(
        path: "logs/log-.txt",
        rollingInterval: RollingInterval.Day,
        retainedFileCountLimit: 30));

var app = builder.Build();

// Логування HTTP requests
app.UseSerilogRequestLogging();

app.Run();

{
    "Serilog": {
        "Using": ["Serilog.Sinks.Console", "Serilog.Sinks.File"],
        "MinimumLevel": {
            "Default": "Information",
            "Override": {
                "Microsoft": "Warning",
                "Microsoft.Hosting.Lifetime": "Information",
                "Microsoft.EntityFrameworkCore": "Warning"
            }
        },
        "WriteTo": [
            { "Name": "Console" },
            {
                "Name": "File",
                "Args": {
                    "path": "logs/log-.txt",
                    "rollingInterval": "Day",
                    "retainedFileCountLimit": 30,
                    "outputTemplate": "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] {Message:lj}{NewLine}{Exception}"
                }
            }
        ],
        "Enrich": ["FromLogContext", "WithMachineName", "WithThreadId"]
    }
}

builder.Host.UseSerilog((context, services, configuration) => configuration
    .ReadFrom.Configuration(context.Configuration)
    .Enrich.WithProperty("Application", "MyECommerceApp")
    .Enrich.WithProperty("Environment", context.HostingEnvironment.EnvironmentName)
    .Enrich.FromLogContext()
    .Enrich.WithMachineName()
    .Enrich.WithThreadId()
    .Enrich.WithCorrelationId() // Потребує додатковий пакет
    .WriteTo.Console()
    .WriteTo.Seq("http://localhost:5341")); // Централізоване логування

public class OrderController : ControllerBase
{
    private readonly IOrderService _orderService;

    [HttpPost]
    public async Task<IActionResult> CreateOrder(CreateOrderRequest request)
    {
        // Додаємо UserId до всіх логів у цьому scope
        using (LogContext.PushProperty("UserId", request.UserId))
        using (LogContext.PushProperty("CorrelationId", HttpContext.TraceIdentifier))
        {
            _logger.LogInformation("Processing order creation");

            var order = await _orderService.CreateOrderAsync(request);
            // Всі логи всередині OrderService матимуть UserId та CorrelationId!

            return Ok(order);
        }
    }
}

// ❌ Повільно: створюється FormattedLogValues, boxing для параметрів
_logger.LogInformation("Processing order {OrderId} for user {UserId}", orderId, userId);

public partial class OrderService
{
    private readonly ILogger<OrderService> _logger;

    public OrderService(ILogger<OrderService> logger)
    {
        _logger = logger;
    }

    // ✅ Compile-time generated, zero allocations
    [LoggerMessage(
        EventId = 1000,
        Level = LogLevel.Information,
        Message = "Processing order {OrderId} for user {UserId}")]
    private partial void LogProcessingOrder(Guid orderId, int userId);

    [LoggerMessage(
        EventId = 1001,
        Level = LogLevel.Error,
        Message = "Failed to process order {OrderId}")]
    private partial void LogOrderFailed(Guid orderId, Exception exception);

    [LoggerMessage(
        EventId = 1002,
        Level = LogLevel.Warning,
        Message = "Retry attempt {Attempt} for order {OrderId}")]
    private partial void LogRetryAttempt(int attempt, Guid orderId);

    public async Task ProcessOrderAsync(Guid orderId, int userId)
    {
        LogProcessingOrder(orderId, userId);

        try
        {
            // Business logic
        }
        catch (Exception ex)
        {
            LogOrderFailed(orderId, ex);
            throw;
        }
    }
}

private void LogProcessingOrder(Guid orderId, int userId)
{
    if (_logger.IsEnabled(LogLevel.Information))
    {
        _logger.Log(
            LogLevel.Information,
            new EventId(1000),
            new LogValues(orderId, userId),
            null,
            (state, ex) => $"Processing order {state.OrderId} for user {state.UserId}");
    }
}

dotnet add package Polly
dotnet add package Microsoft.Extensions.Http.Polly

using Polly;
using Polly.Retry;

// Створення Retry pipeline
var retryPipeline = new ResiliencePipelineBuilder()
    .AddRetry(new RetryStrategyOptions
    {
        ShouldHandle = new PredicateBuilder()
            .Handle<HttpRequestException>()
            .Handle<TimeoutException>(),
        MaxRetryAttempts = 3,
        Delay = TimeSpan.FromSeconds(1),
        BackoffType = DelayBackoffType.Exponential, // 1s, 2s, 4s
        OnRetry = args =>
        {
            Console.WriteLine($"Retry {args.AttemptNumber} after {args.RetryDelay}");
            return ValueTask.CompletedTask;
        }
    })
    .Build();

// Використання
var result = await retryPipeline.ExecuteAsync(async ct =>
{
    return await httpClient.GetStringAsync("https://api.example.com/data", ct);
}, cancellationToken);

builder.Services.AddHttpClient("external-api", client =>
{
    client.BaseAddress = new Uri("https://api.example.com");
    client.Timeout = TimeSpan.FromSeconds(10);
})
.AddResilienceHandler("retry-policy", builder =>
{
    builder.AddRetry(new RetryStrategyOptions
    {
        MaxRetryAttempts = 3,
        Delay = TimeSpan.FromSeconds(1),
        BackoffType = DelayBackoffType.Exponential,
        ShouldHandle = new PredicateBuilder<HttpResponseMessage>()
            .Handle<HttpRequestException>()
            .HandleResult(response =>
                response.StatusCode == System.Net.HttpStatusCode.TooManyRequests ||
                (int)response.StatusCode >= 500)
    });
});

// Використання
public class ExternalApiService
{
    private readonly HttpClient _httpClient;

    public ExternalApiService(IHttpClientFactory httpClientFactory)
    {
        _httpClient = httpClientFactory.CreateClient("external-api");
    }

    public async Task<string> GetDataAsync()
    {
        // Retry автоматично застосовується!
        return await _httpClient.GetStringAsync("/data");
    }
}

builder.Services.AddHttpClient("payment-gateway")
    .AddResilienceHandler("circuit-breaker", builder =>
    {
        builder.AddCircuitBreaker(new CircuitBreakerStrategyOptions
        {
            FailureRatio = 0.5,          // 50% помилок
            SamplingDuration = TimeSpan.FromSeconds(10), // За 10 секунд
            MinimumThroughput = 5,       // Мінімум 5 запитів
            BreakDuration = TimeSpan.FromSeconds(30),    // Відкрити на 30 сек

            ShouldHandle = new PredicateBuilder<HttpResponseMessage>()
                .Handle<HttpRequestException>()
                .HandleResult(r => (int)r.StatusCode >= 500),

            OnOpened = args =>
            {
                Console.WriteLine($"Circuit breaker opened at {DateTime.Now}");
                return ValueTask.CompletedTask;
            },
            OnClosed = args =>
            {
                Console.WriteLine($"Circuit breaker closed at {DateTime.Now}");
                return ValueTask.CompletedTask;
            },
            OnHalfOpened = args =>
            {
                Console.WriteLine("Circuit breaker half-opened, testing...");
                return ValueTask.CompletedTask;
            }
        });
    });

builder.Services.AddHttpClient("slow-service")
    .AddResilienceHandler("timeout", builder =>
    {
        builder.AddTimeout(new TimeoutStrategyOptions
        {
            Timeout = TimeSpan.FromSeconds(5),
            OnTimeout = args =>
            {
                Console.WriteLine($"Timeout after {args.Timeout} for attempt {args.AttemptNumber}");
                return ValueTask.CompletedTask;
            }
        });
    });

builder.Services.AddHttpClient("resilient-client")
    .AddResilienceHandler("resilience-pipeline", builder =>
    {
        // 1. Outer timeout - загальний ліміт для всіх спроб
        builder.AddTimeout(TimeSpan.FromSeconds(30));

        // 2. Retry з exponential backoff
        builder.AddRetry(new RetryStrategyOptions
        {
            MaxRetryAttempts = 3,
            Delay = TimeSpan.FromSeconds(1),
            BackoffType = DelayBackoffType.Exponential,
            ShouldHandle = new PredicateBuilder<HttpResponseMessage>()
                .Handle<HttpRequestException>()
                .Handle<TimeoutRejectedException>() // Retry при timeout
                .HandleResult(r => (int)r.StatusCode >= 500)
        });

        // 3. Circuit Breaker для fail-fast
        builder.AddCircuitBreaker(new CircuitBreakerStrategyOptions
        {
            FailureRatio = 0.5,
            SamplingDuration = TimeSpan.FromSeconds(10),
            MinimumThroughput = 3,
            BreakDuration = TimeSpan.FromSeconds(30)
        });

        // 4. Inner timeout - per attempt
        builder.AddTimeout(TimeSpan.FromSeconds(5));
    });

Request → Outer Timeout (30s) → Retry → Circuit Breaker → Inner Timeout (5s) → HTTP Call

public interface IHostedService
{
    Task StartAsync(CancellationToken cancellationToken);
    Task StopAsync(CancellationToken cancellationToken);
}

public abstract class BackgroundService : IHostedService
{
    protected abstract Task ExecuteAsync(CancellationToken stoppingToken);

    public virtual Task StartAsync(CancellationToken cancellationToken)
    {
        // Запускає ExecuteAsync у фоновому Task
    }

    public virtual Task StopAsync(CancellationToken cancellationToken)
    {
        // Чекає завершення ExecuteAsync з graceful shutdown
    }
}

public class EmailQueueProcessor : BackgroundService
{
    private readonly ILogger<EmailQueueProcessor> _logger;
    private readonly IServiceScopeFactory _scopeFactory;

    public EmailQueueProcessor(
        ILogger<EmailQueueProcessor> logger,
        IServiceScopeFactory scopeFactory)
    {
        _logger = logger;
        _scopeFactory = scopeFactory;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("Email Queue Processor started");

        while (!stoppingToken.IsCancellationRequested)
        {
            try
            {
                // Створюємо scope для Scoped dependencies
                using var scope = _scopeFactory.CreateScope();
                var emailService = scope.ServiceProvider.GetRequiredService<IEmailService>();

                await emailService.ProcessQueueAsync(stoppingToken);

                // Чекаємо перед наступною ітерацією
                await Task.Delay(TimeSpan.FromSeconds(30), stoppingToken);
            }
            catch (OperationCanceledException)
            {
                // Graceful shutdown
                _logger.LogInformation("Email Queue Processor stopping");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error processing email queue");
                // Продовжуємо роботу навіть при помилці
                await Task.Delay(TimeSpan.FromMinutes(1), stoppingToken);
            }
        }

        _logger.LogInformation("Email Queue Processor stopped");
    }
}

// Реєстрація
builder.Services.AddHostedService<EmailQueueProcessor>();

public class DataSyncService : BackgroundService
{
    private readonly ILogger<DataSyncService> _logger;
    private readonly IServiceScopeFactory _scopeFactory;
    private readonly TimeSpan _period = TimeSpan.FromMinutes(5);

    public DataSyncService(
        ILogger<DataSyncService> logger,
        IServiceScopeFactory scopeFactory)
    {
        _logger = logger;
        _scopeFactory = scopeFactory;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        using var timer = new PeriodicTimer(_period);

        while (!stoppingToken.IsCancellationRequested &&
               await timer.WaitForNextTickAsync(stoppingToken))
        {
            try
            {
                _logger.LogInformation("Starting data sync at {Time}", DateTime.UtcNow);

                using var scope = _scopeFactory.CreateScope();
                var syncService = scope.ServiceProvider.GetRequiredService<ISyncService>();

                await syncService.SyncDataAsync(stoppingToken);

                _logger.LogInformation("Data sync completed successfully");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Data sync failed");
            }
        }
    }
}

public class OrderProcessorService : BackgroundService
{
    private readonly ILogger<OrderProcessorService> _logger;

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("Order Processor started");

        // Реєструємо callback для graceful shutdown
        stoppingToken.Register(() =>
            _logger.LogInformation("Graceful shutdown initiated"));

        while (!stoppingToken.IsCancellationRequested)
        {
            try
            {
                await ProcessNextOrderAsync(stoppingToken);
            }
            catch (OperationCanceledException)
            {
                // Нормальне завершення
                break;
            }
        }

        _logger.LogInformation("Order Processor stopped gracefully");
    }

    public override async Task StopAsync(CancellationToken cancellationToken)
    {
        _logger.LogInformation("Stop requested, finishing current work...");

        // Базовий StopAsync чекає завершення ExecuteAsync
        await base.StopAsync(cancellationToken);

        _logger.LogInformation("All work completed, service stopped");
    }
}

builder.Host.ConfigureServices(services =>
{
    services.Configure<HostOptions>(options =>
    {
        options.ShutdownTimeout = TimeSpan.FromSeconds(30); // Максимальний час на graceful shutdown
    });
});

// Program.cs
using Serilog;

var builder = Host.CreateApplicationBuilder(args);

// Serilog
builder.Host.UseSerilog((context, services, configuration) => configuration
    .ReadFrom.Configuration(context.Configuration)
    .Enrich.FromLogContext()
    .WriteTo.Console()
    .WriteTo.File("logs/order-processor-.txt", rollingInterval: RollingInterval.Day));

// Configuration Options
builder.Services.Configure<OrderProcessorSettings>(
    builder.Configuration.GetSection("OrderProcessor"));
builder.Services.Configure<PaymentGatewaySettings>(
    builder.Configuration.GetSection("PaymentGateway"));

// DI Services
builder.Services.AddDbContext<AppDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));

builder.Services.AddScoped<IOrderRepository, OrderRepository>();
builder.Services.AddScoped<IInventoryService, InventoryService>();
builder.Services.AddScoped<IPaymentService, PaymentService>();
builder.Services.AddScoped<INotificationService, NotificationService>();

// HTTP Clients з Resilience
builder.Services.AddHttpClient<IPaymentService, PaymentService>()
    .AddResilienceHandler("payment-resilience", resilienceBuilder =>
    {
        resilienceBuilder
            .AddTimeout(TimeSpan.FromSeconds(30))
            .AddRetry(new RetryStrategyOptions
            {
                MaxRetryAttempts = 3,
                Delay = TimeSpan.FromSeconds(1),
                BackoffType = DelayBackoffType.Exponential
            })
            .AddCircuitBreaker(new CircuitBreakerStrategyOptions
            {
                FailureRatio = 0.5,
                SamplingDuration = TimeSpan.FromSeconds(10),
                MinimumThroughput = 3,
                BreakDuration = TimeSpan.FromSeconds(30)
            });
    });

// Background Service
builder.Services.AddHostedService<OrderProcessorWorker>();

var host = builder.Build();
await host.RunAsync();

// OrderProcessorWorker.cs
public class OrderProcessorWorker : BackgroundService
{
    private readonly ILogger<OrderProcessorWorker> _logger;
    private readonly IServiceScopeFactory _scopeFactory;
    private readonly IOptions<OrderProcessorSettings> _settings;

    public OrderProcessorWorker(
        ILogger<OrderProcessorWorker> logger,
        IServiceScopeFactory scopeFactory,
        IOptions<OrderProcessorSettings> settings)
    {
        _logger = logger;
        _scopeFactory = scopeFactory;
        _settings = settings;
    }

    [LoggerMessage(
        EventId = 1000,
        Level = LogLevel.Information,
        Message = "Processing order batch of {Count} orders")]
    private partial void LogProcessingBatch(int count);

    [LoggerMessage(
        EventId = 1001,
        Level = LogLevel.Information,
        Message = "Order {OrderId} processed successfully in {ElapsedMs}ms")]
    private partial void LogOrderProcessed(Guid orderId, long elapsedMs);

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("Order Processor started");

        using var timer = new PeriodicTimer(TimeSpan.FromSeconds(_settings.Value.PoolingIntervalSeconds));

        while (!stoppingToken.IsCancellationRequested &&
               await timer.WaitForNextTickAsync(stoppingToken))
        {
            try
            {
                await ProcessPendingOrdersAsync(stoppingToken);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Failed to process orders batch");
            }
        }

        _logger.LogInformation("Order Processor stopped");
    }

    private async Task ProcessPendingOrdersAsync(CancellationToken cancellationToken)
    {
        using var scope = _scopeFactory.CreateScope();
        var orderRepository = scope.ServiceProvider.GetRequiredService<IOrderRepository>();
        var inventoryService = scope.ServiceProvider.GetRequiredService<IInventoryService>();
        var paymentService = scope.ServiceProvider.GetRequiredService<IPaymentService>();
        var notificationService = scope.ServiceProvider.GetRequiredService<INotificationService>();

        var pendingOrders = await orderRepository.GetPendingOrdersAsync(
            _settings.Value.BatchSize,
            cancellationToken);

        if (pendingOrders.Count == 0)
            return;

        LogProcessingBatch(pendingOrders.Count);

        foreach (var order in pendingOrders)
        {
            var stopwatch = Stopwatch.StartNew();

            using (LogContext.PushProperty("OrderId", order.Id))
            using (LogContext.PushProperty("UserId", order.UserId))
            {
                try
                {
                    // 1. Reserve Inventory
                    await inventoryService.ReserveAsync(order, cancellationToken);

                    // 2. Process Payment (with resilience)
                    await paymentService.ChargeAsync(order, cancellationToken);

                    // 3. Update Order Status
                    order.Status = OrderStatus.Completed;
                    await orderRepository.UpdateAsync(order, cancellationToken);

                    // 4. Send Notification
                    await notificationService.SendOrderConfirmationAsync(order, cancellationToken);

                    stopwatch.Stop();
                    LogOrderProcessed(order.Id, stopwatch.ElapsedMilliseconds);
                }
                catch (Exception ex)
                {
                    _logger.LogError(ex, "Failed to process order {OrderId}", order.Id);

                    order.Status = OrderStatus.Failed;
                    order.FailureReason = ex.Message;
                    await orderRepository.UpdateAsync(order, cancellationToken);
                }
            }
        }
    }
}