深挖.NET 11：.NET Aspire 在云原生应用韧性架构构建的探索与实践

dotnet new aspire -n ResilientCloudApp
cd ResilientCloudApp

name: ResilientCloudApp
components:
  - name: UserService
    project:./src/UserService/UserService.csproj
    endpoints:
      - name: http
        targetPort: 5001
    healthChecks:
      - path: /health
        protocol: http
        timeout: 5s
        interval: 10s

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Diagnostics.HealthChecks;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using System.Net.Mime;

public class Startup
{
    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }

    public IConfiguration Configuration { get; }

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddHealthChecks();
        services.AddControllers();
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }

        app.UseRouting();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapHealthChecks("/health", new HealthCheckOptions
            {
                ResponseWriter = async (context, report) =>
                {
                    context.Response.ContentType = MediaTypeNames.Application.Json;
                    await context.Response.WriteAsync($"{{\"status\":\"{report.Status.ToString()}\"}}");
                }
            });
            endpoints.MapControllers();
        });
    }
}

public class InventoryService
{
    public void DeductInventory(int productId, int quantity)
    {
        // 实际的库存扣减逻辑
    }

    public void RestoreInventory(int productId, int quantity)
    {
        // 库存恢复逻辑
    }
}

public class OrderService
{
    public void CreateOrder(Order order)
    {
        // 订单创建逻辑
    }

    public void CancelOrder(int orderId)
    {
        // 订单取消逻辑
    }
}

public class PaymentService
{
    public void ProcessPayment(Payment payment)
    {
        // 支付处理逻辑
    }

    public void RefundPayment(int paymentId)
    {
        // 退款逻辑
    }
}

public class OrderSagaCoordinator
{
    private readonly OrderService _orderService;
    private readonly InventoryService _inventoryService;
    private readonly PaymentService _paymentService;

    public OrderSagaCoordinator(OrderService orderService, InventoryService inventoryService, PaymentService paymentService)
    {
        _orderService = orderService;
        _inventoryService = inventoryService;
        _paymentService = paymentService;
    }

    public async Task<bool> ProcessOrder(Order order)
    {
        try
        {
            _orderService.CreateOrder(order);
            _inventoryService.DeductInventory(order.ProductId, order.Quantity);
            _paymentService.ProcessPayment(order.Payment);
            return true;
        }
        catch (Exception ex)
        {
            // 发生异常，执行补偿操作
            _paymentService.RefundPayment(order.Payment.Id);
            _inventoryService.RestoreInventory(order.ProductId, order.Quantity);
            _orderService.CancelOrder(order.Id);
            return false;
        }
    }
}