Зависимости. Часть 2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
// Program.cs — это и есть Composition Root
var builder = WebApplication.CreateBuilder(args);

// --- Инфраструктура ---
builder.Services.AddDbContext<AppDbContext>(opt =>
    opt.UseNpgsql(builder.Configuration.GetConnectionString("Default")));

builder.Services.AddStackExchangeRedisCache(opt =>
    opt.Configuration = builder.Configuration["Redis:Connection"]);

// --- Репозитории ---
builder.Services.AddScoped<IOrderRepository, EfOrderRepository>();
builder.Services.AddScoped<IProductRepository, EfProductRepository>();

// Декораторы через Scrutor (кеширование прозрачно)
builder.Services.Decorate<IProductRepository, CachedProductRepository>();

// --- Бизнес-логика ---
builder.Services.AddScoped<IOrderService, OrderService>();
builder.Services.AddScoped<IInventoryService, InventoryService>();
builder.Services.AddMediatR(cfg => cfg.RegisterServicesFromAssembly(typeof(Program).Assembly));

// --- Pipeline behaviors (AOP через MediatR) ---
builder.Services.AddTransient(typeof(IPipelineBehavior<,>), typeof(ValidationBehavior<,>));
builder.Services.AddTransient(typeof(IPipelineBehavior<,>), typeof(LoggingBehavior<,>));
builder.Services.AddTransient(typeof(IPipelineBehavior<,>), typeof(CachingBehavior<,>));

// --- Внешние сервисы ---
builder.Services.AddHttpClient<IShippingClient, FedExShippingClient>(client =>
    client.BaseAddress = new Uri(builder.Configuration["FedEx:BaseUrl"]!));

// --- Современные зависимости ---
builder.Services.AddScoped<IAIAssistant, OpenAIAssistant>();
builder.Services.AddFeatureManagement();

var app = builder.Build();
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
// Модуль для инфраструктуры
public class InfrastructureModule : Module
{
    protected override void Load(ContainerBuilder builder)
    {
        builder.RegisterType<EfOrderRepository>()
            .As<IOrderRepository>()
            .InstancePerLifetimeScope();

        builder.RegisterType<EfProductRepository>()
            .As<IProductRepository>()
            .InstancePerLifetimeScope()
            .EnableInterfaceInterceptors()        // перехват!
            .InterceptedBy(typeof(CacheInterceptor));

        builder.RegisterType<CacheInterceptor>().AsSelf();
    }
}

// Модуль для бизнес-логики
public class ApplicationModule : Module
{
    protected override void Load(ContainerBuilder builder)
    {
        builder.RegisterAssemblyTypes(ThisAssembly)
            .Where(t => t.Name.EndsWith("Service"))
            .AsImplementedInterfaces()
            .InstancePerLifetimeScope();
    }
}

// Program.cs
builder.Host.UseServiceProviderFactory(new AutofacServiceProviderFactory());
builder.Host.ConfigureContainer<ContainerBuilder>(container =>
{
    container.RegisterModule<InfrastructureModule>();
    container.RegisterModule<ApplicationModule>();
});
 

1
2
3
4
5
6
7
8
9
10
11
12
13
 
// Register (один раз при старте)
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddScoped<IOrderService, OrderService>();
builder.Services.AddScoped<IUnitOfWork, EfUnitOfWork>();
var app = builder.Build();

// Resolve (на каждый HTTP-запрос — автоматически фреймворком)
app.MapPost("/orders", async (CreateOrderCommand cmd, IOrderService svc) =>
    await svc.CreateAsync(cmd));

// Release — ASP.NET Core делает это автоматически в конце scope (запроса)
// Все IDisposable в Scoped и Transient будут освобождены
app.Run();
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
// ❌ Service Locator — антипаттерн
public class OrderService
{
    public async Task ProcessAsync(int orderId)
    {
        // Прямое обращение к контейнеру изнутри бизнес-логики
        var repo = ServiceLocator.Current.GetInstance<IOrderRepository>();
        var order = await repo.GetByIdAsync(orderId);
    }
}

// ✅ Правильно — зависимости передаются снаружи
public class OrderService
{
    private readonly IOrderRepository _repo;

    public OrderService(IOrderRepository repo) => _repo = repo;

    public async Task ProcessAsync(int orderId)
    {
        var order = await _repo.GetByIdAsync(orderId);
    }
}
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
// Определяем interceptor
public class LoggingInterceptor : IInterceptor
{
    private readonly ILogger _logger;

    public LoggingInterceptor(ILogger logger) => _logger = logger;

    public void Intercept(IInvocation invocation)
    {
        _logger.LogInformation("Вызов: {Method}({Args})",
            invocation.Method.Name,
            string.Join(", ", invocation.Arguments));

        var sw = Stopwatch.StartNew();
        try
        {
            invocation.Proceed();   // вызов реального метода
            _logger.LogInformation("Завершён: {Method} [{Elapsed}ms]",
                invocation.Method.Name, sw.ElapsedMilliseconds);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка в {Method}", invocation.Method.Name);
            throw;
        }
    }
}

// Регистрация с перехватом
var container = new WindsorContainer();
container.Register(
    Component.For<LoggingInterceptor>(),
    Component.For<IOrderService>()
        .ImplementedBy<OrderService>()
        .Interceptors<LoggingInterceptor>()
);

// Использование — прозрачное, без изменений в коде
var service = container.Resolve<IOrderService>();
service.CreateOrder(cmd);  // ← вызов автоматически логируется
 

1
2
3
4
5
6
7
8
 
// В Autofac перехват реализуется через интеграцию с Castle DynamicProxy
builder.RegisterType<OrderService>()
    .As<IOrderService>()
    .EnableInterfaceInterceptors()
    .InterceptedBy(typeof(LoggingInterceptor), typeof(CacheInterceptor));

builder.Register(c => new LoggingInterceptor(c.Resolve<ILogger<LoggingInterceptor>>()));
builder.Register(c => new CacheInterceptor(c.Resolve<IMemoryCache>()));
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
public class LoggingProxy<T> : DispatchProxy where T : class
{
    private T _decorated = null!;
    private ILogger _logger = null!;

    protected override object? Invoke(MethodInfo? targetMethod, object?[]? args)
    {
        _logger.LogInformation("→ {Method}", targetMethod?.Name);
        var result = targetMethod?.Invoke(_decorated, args);
        _logger.LogInformation("← {Method}", targetMethod?.Name);
        return result;
    }

    public static T Create(T decorated, ILogger logger)
    {
        var proxy = Create<T, LoggingProxy<T>>() as LoggingProxy<T>;
        proxy!._decorated = decorated;
        proxy!._logger = logger;
        return (proxy as T)!;
    }
}

// Использование
services.AddScoped<IOrderService>(sp =>
    LoggingProxy<IOrderService>.Create(
        sp.GetRequiredService<OrderService>(),
        sp.GetRequiredService<ILogger<OrderService>>()
    ));
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
// Определяем аспект
[Serializable]
public class LoggingAspect : OnMethodBoundaryAspect
{
    public override void OnEntry(MethodExecutionArgs args)
    {
        Console.WriteLine($"→ Вход: {args.Method.Name}");
        args.MethodExecutionTag = Stopwatch.StartNew();
    }

    public override void OnExit(MethodExecutionArgs args)
    {
        var sw = (Stopwatch)args.MethodExecutionTag;
        Console.WriteLine($"← Выход: {args.Method.Name} [{sw.ElapsedMilliseconds}ms]");
    }

    public override void OnException(MethodExecutionArgs args)
    {
        Console.WriteLine($"✗ Ошибка: {args.Method.Name} — {args.Exception.Message}");
        args.FlowBehavior = FlowBehavior.Continue;  // подавить исключение
    }
}

// Применяем к методу
public class OrderService
{
    [LoggingAspect]
    public Order CreateOrder(CreateOrderCommand cmd)
    {
        // чистый бизнес-код, без единой строки логирования
        return new Order(cmd.CustomerId, cmd.Items);
    }
}
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
// OnExceptionAspect — специализированный аспект для исключений
[Serializable]
public class RetryAspect : OnExceptionAspect
{
    public int Attempts { get; set; } = 3;

    public override void OnException(MethodExecutionArgs args)
    {
        if (args.Exception is TransientException && --Attempts > 0)
        {
            Thread.Sleep(200);
            args.FlowBehavior = FlowBehavior.Retry;
        }
    }
}

public class ExternalApiClient
{
    [RetryAspect(Attempts = 5)]
    public async Task<ApiResponse> CallAsync(string endpoint)
    {
        // сеть может упасть — аспект обработает повторные попытки
        return await _httpClient.GetFromJsonAsync<ApiResponse>(endpoint);
    }
}
 

1
2
3
4
5
6
7
8
 
// AssemblyInfo.cs — аспект применяется ко всем public-методам в сборке
[assembly: LoggingAspect(
    AttributeTargetTypes = "MyApp.Services.*",
    AttributeTargetMemberAttributes = MulticastAttributes.Public)]

[assembly: RetryAspect(
    AttributeTargetTypes = "MyApp.Infrastructure.Clients.*",
    Attempts = 3)]
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
// Аспект логирования на Metalama
public class LogAttribute : OverrideMethodAspect
{
    public override dynamic? OverrideMethod()
    {
        var methodName = meta.Target.Method.Name;
        Console.WriteLine($"→ {methodName}({string.Join(", ", meta.Target.Parameters.Values)})");

        try
        {
            var result = meta.Proceed();
            Console.WriteLine($"← {methodName} = {result}");
            return result;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"✗ {methodName}: {ex.Message}");
            throw;
        }
    }
}

// Применяется так же, как атрибут
public class OrderService
{
    [Log]
    public Order CreateOrder(CreateOrderCommand cmd) => new Order(cmd);
}
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
// 1. Интерфейс и реализация
public interface IProductService
{
    Task<ProductDto> GetProductAsync(int id);
    Task<IReadOnlyList<ProductDto>> SearchAsync(string query);
}

public class ProductService : IProductService
{
    private readonly IProductRepository _repo;
    private readonly IAIAssistant _ai;

    public ProductService(IProductRepository repo, IAIAssistant ai)
    {
        _repo = repo;
        _ai = ai;
    }

    public async Task<ProductDto> GetProductAsync(int id)
    {
        var product = await _repo.GetByIdAsync(id)
            ?? throw new NotFoundException($"Product {id} not found");
        return product.ToDto();
    }

    public async Task<IReadOnlyList<ProductDto>> SearchAsync(string query)
    {
        // AI-enhanced search
        var enrichedQuery = await _ai.CompleteAsync(
            $"Expand search query with synonyms: {query}");
        return (await _repo.SearchAsync(enrichedQuery))
            .Select(p => p.ToDto())
            .ToList();
    }
}

// 2. Декоратор кеширования (AOP через Scrutor)
public class CachedProductService : IProductService
{
    private readonly IProductService _inner;
    private readonly IMemoryCache _cache;
    private static readonly TimeSpan _ttl = TimeSpan.FromMinutes(5);

    public CachedProductService(IProductService inner, IMemoryCache cache)
    {
        _inner = inner;
        _cache = cache;
    }

    public Task<ProductDto> GetProductAsync(int id)
        => _cache.GetOrCreateAsync($"product:{id}",
            entry => { entry.AbsoluteExpirationRelativeToNow = _ttl;
                       return _inner.GetProductAsync(id); });

    public Task<IReadOnlyList<ProductDto>> SearchAsync(string query)
        => _inner.SearchAsync(query); // поиск не кешируем
}

// 3. Composition Root
builder.Services.AddMemoryCache();
builder.Services.AddScoped<IProductService, ProductService>();
builder.Services.Decorate<IProductService, CachedProductService>();

// 4. MediatR Behavior для валидации (AOP для команд)
public class GetProductQuery : IRequest<ProductDto>
{
    public int ProductId { get; init; }
}

public class GetProductQueryHandler : IRequestHandler<GetProductQuery, ProductDto>
{
    private readonly IProductService _service;
    public GetProductQueryHandler(IProductService service) => _service = service;

    public Task<ProductDto> Handle(GetProductQuery request, CancellationToken ct)
        => _service.GetProductAsync(request.ProductId);
}

// 5. Endpoint — получает уже кешированный и логируемый результат
app.MapGet("/products/{id}", async (int id, IMediator mediator) =>
    await mediator.Send(new GetProductQuery { ProductId = id }));