跨领域能力迁移

var builder = WebApplication.CreateBuilder(args);

// 注册服务
builder.Services.AddControllers();
builder.Services.AddScoped<IUserService, UserService>();
builder.Services.AddDbContext<AppDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("Default")));

var app = builder.Build();

// 配置中间件管道
app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();

app.Run();

[ApiController]
[Route("api/[controller]")]
public class UsersController : ControllerBase
{
    [HttpGet]
    public async Task<ActionResult<IEnumerable<UserDto>>> GetAll() { ... }

    [HttpGet("{id}")]
    public async Task<ActionResult<UserDto>> GetById(int id) { ... }

    [HttpPost]
    public async Task<ActionResult<UserDto>> Create([FromBody] CreateUserDto dto) { ... }

    [HttpPut("{id}")]
    public async Task<ActionResult> Update(int id, [FromBody] UpdateUserDto dto) { ... }

    [HttpDelete("{id}")]
    public async Task<ActionResult> Delete(int id) { ... }
}

public class RequestLoggingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<RequestLoggingMiddleware> _logger;

    public RequestLoggingMiddleware(RequestDelegate next, ILogger<RequestLoggingMiddleware> logger)
    {
        _next = next;
        _logger = logger;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        _logger.LogInformation($"Request: {context.Request.Method} {context.Request.Path}");
        await _next(context);
        _logger.LogInformation($"Response: {context.Response.StatusCode}");
    }
}

// 注册方式
app.UseMiddleware<RequestLoggingMiddleware>();

// 服务注册
builder.Services.AddTransient<IEmailService, EmailService>();
builder.Services.AddScoped<IUserService, UserService>();
builder.Services.AddSingleton<ICacheService, MemoryCacheService>();

// 构造函数注入（推荐）
public class UserController : ControllerBase
{
    private readonly IUserService _userService;
    
    public UserController(IUserService userService)
    {
        _userService = userService;
    }
}

public class AppSettings
{
    public string SiteName { get; set; }
    public int MaxUploadSize { get; set; }
}

builder.Services.Configure<AppSettings>(builder.Configuration.GetSection("AppSettings"));

public class HomeController : ControllerBase
{
    private readonly AppSettings _settings;
    
    public HomeController(IOptions<AppSettings> options)
    {
        _settings = options.Value;
    }
}

public class GlobalExceptionFilter : IExceptionFilter
{
    private readonly ILogger<GlobalExceptionFilter> _logger;

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

    public void OnException(ExceptionContext context)
    {
        _logger.LogError(context.Exception, "Unhandled exception");
        
        var response = new { code = 500, message = "Internal Server Error" };
        context.Result = new JsonResult(response)
        {
            StatusCode = StatusCodes.Status500InternalServerError
        };
    }
}

builder.Services.AddControllers(options =>
{
    options.Filters.Add<GlobalExceptionFilter>();
});

[Table("users")]
public class User
{
    [Key]
    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
    public int Id { get; set; }

    [Column("user_name")]
    [Required]
    [MaxLength(100)]
    public string UserName { get; set; }

    [Column("email")]
    [MaxLength(200)]
    public string Email { get; set; }

    [NotMapped]
    public string FullName => $"{UserName} ({Email})";

    [Timestamp]
    public byte[] RowVersion { get; set; }

    public ICollection<Order> Orders { get; set; }
}

public class AppDbContext : DbContext
{
    public DbSet<User> Users { get; set; }
    public DbSet<Order> Orders { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<User>()
            .HasIndex(u => u.Email)
            .IsUnique();
            
        modelBuilder.Entity<User>()
            .HasMany(u => u.Orders)
            .WithOne(o => o.User)
            .HasForeignKey(o => o.UserId);
    }
}

public class UserService
{
    private readonly AppDbContext _context;

    public UserService(AppDbContext context) => _context = context;

    public async Task<User?> GetByIdAsync(int id) =>
        await _context.Users.FindAsync(id);

    public async Task<List<User>> GetByNameAsync(string name) =>
        await _context.Users
            .Where(u => u.UserName.Contains(name))
            .OrderBy(u => u.UserName)
            .ToListAsync();

    public async Task<(List<User> Users, int Total)> GetPagedAsync(int page, int size)
    {
        var query = _context.Users.AsQueryable();
        var total = await query.CountAsync();
        var users = await query
            .OrderBy(u => u.Id)
            .Skip((page - 1) * size)
            .Take(size)
            .ToListAsync();
        return (users, total);
    }
}

public class UserRepository
{
    private readonly IDbConnection _db;

    public UserRepository(IConfiguration config)
    {
        _db = new SqlConnection(config.GetConnectionString("Default"));
    }

    public async Task<User?> GetByIdAsync(int id)
    {
        var sql = "SELECT * FROM users WHERE id = @Id";
        return await _db.QueryFirstOrDefaultAsync<User>(sql, new { Id = id });
    }

    public async Task<List<User>> GetByNameAsync(string name)
    {
        var sql = "SELECT * FROM users WHERE user_name LIKE @Name ORDER BY created_at DESC";
        return (await _db.QueryAsync<User>(sql, new { Name = $"%{name}%" })).ToList();
    }

    public async Task<int> InsertAsync(User user)
    {
        var sql = @"INSERT INTO users (user_name, email) VALUES (@UserName, @Email);
                    SELECT CAST(SCOPE_IDENTITY() as int)";
        return await _db.ExecuteScalarAsync<int>(sql, user);
    }
}

public async Task<List<User>> SearchAsync(UserSearchCriteria criteria)
{
    var sql = new StringBuilder("SELECT * FROM users WHERE 1=1");
    var parameters = new DynamicParameters();

    if (!string.IsNullOrEmpty(criteria.Name))
    {
        sql.Append(" AND user_name LIKE @Name");
        parameters.Add("Name", $"%{criteria.Name}%");
    }

    if (criteria.Status.HasValue)
    {
        sql.Append(" AND status = @Status");
        parameters.Add("Status", criteria.Status.Value);
    }

    return (await _db.QueryAsync<User>(sql.ToString(), parameters)).ToList();
}

public class UserServiceClient
{
    private readonly HttpClient _httpClient;
    private readonly AsyncPolicy<HttpResponseMessage> _retryPolicy;
    private readonly AsyncPolicy<HttpResponseMessage> _circuitBreakerPolicy;

    public UserServiceClient(HttpClient httpClient)
    {
        _httpClient = httpClient;
        
        // 重试策略：最多重试 3 次，指数退避
        _retryPolicy = Policy
            .Handle<HttpRequestException>()
            .OrResult<HttpResponseMessage>(r => !r.IsSuccessStatusCode)
            .WaitAndRetryAsync(3, retryAttempt => 
                TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)));
        
        // 熔断策略：5 次失败后熔断 30 秒
        _circuitBreakerPolicy = Policy
            .Handle<HttpRequestException>()
            .OrResult<HttpResponseMessage>(r => !r.IsSuccessStatusCode)
            .CircuitBreakerAsync(5, TimeSpan.FromSeconds(30));
    }

    public async Task<UserDto?> GetUserAsync(int id)
    {
        var wrappedPolicy = Policy.WrapAsync(_retryPolicy, _circuitBreakerPolicy);
        
        var response = await wrappedPolicy.ExecuteAsync(async () =>
            await _httpClient.GetAsync($"/api/users/{id}"));
        
        if (response.IsSuccessStatusCode)
        {
            var json = await response.Content.ReadAsStringAsync();
            return JsonSerializer.Deserialize<UserDto>(json);
        }
        return null;
    }
}

// 注册方式（推荐用 IHttpClientFactory）
builder.Services.AddHttpClient<IUserServiceClient, UserServiceClient>()
    .AddPolicyHandler(GetRetryPolicy())
    .AddPolicyHandler(GetCircuitBreakerPolicy());

// 发布事件
public class OrderService
{
    private readonly ICapPublisher _capPublisher;

    public OrderService(ICapPublisher capPublisher)
    {
        _capPublisher = capPublisher;
    }

    public async Task CreateOrderAsync(CreateOrderDto dto)
    {
        // 业务逻辑 + 发布事件（在同一事务中）
        using var transaction = _dbContext.Database.BeginTransaction(_capPublisher, autoCommit: false);
        
        var order = new Order { ... };
        _dbContext.Orders.Add(order);
        await _dbContext.SaveChangesAsync();
        
        await _capPublisher.PublishAsync("order.created", new OrderCreatedEvent
        {
            OrderId = order.Id,
            UserId = order.UserId,
            Amount = order.Amount
        });
        
        transaction.Commit();
    }
}

// 订阅事件
public class NotificationConsumer : ICapSubscribe
{
    [CapSubscribe("order.created")]
    public async Task HandleOrderCreated(OrderCreatedEvent message)
    {
        // 发送通知
        await _notificationService.SendAsync(message.UserId, $"Order {message.OrderId} created");
    }
}

// 简单重试
var retryPolicy = Policy
    .Handle<SqlException>(ex => ex.Number == 1205)
    .Retry(3);

await retryPolicy.ExecuteAsync(async () =>
{
    await _dbContext.SaveChangesAsync();
});

// 带等待时间的重试（指数退避）
var retryPolicy = Policy
    .Handle<HttpRequestException>()
    .WaitAndRetryAsync(
        retryCount: 3,
        sleepDurationProvider: retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)),
        onRetry: (exception, timeSpan, retryCount, context) =>
        {
            logger.LogWarning($"Retry {retryCount} after {timeSpan}: {exception.Message}");
        });

// 结合上下文的重试
var context = new Context { ["operation"] = "SaveOrder" };
await retryPolicy.ExecuteAsync(async (ctx) => {
    logger.LogInformation($"Executing {ctx["operation"]}");
    await SaveAsync();
}, context);

// 基础熔断
var circuitBreaker = Policy
    .Handle<Exception>()
    .CircuitBreaker(
        exceptionsAllowedBeforeBreaking: 5,    // 连续 5 次失败后熔断
        durationOfBreak: TimeSpan.FromSeconds(30), // 熔断 30 秒
        onBreak: (ex, duration) => 
            logger.LogError($"Circuit broken: {ex.Message}"),
        onReset: () => 
            logger.LogInformation("Circuit reset"),
        onHalfOpen: () => 
            logger.LogInformation("Circuit half-open")
    );

// 高级熔断（基于失败率）
var advancedCircuitBreaker = Policy
    .Handle<Exception>()
    .AdvancedCircuitBreaker(
        failureThreshold: 0.5,           // 失败率超过 50%
        samplingDuration: TimeSpan.FromSeconds(30),  // 统计窗口 30 秒
        minimumThroughput: 10,           // 最少 10 次请求
        durationOfBreak: TimeSpan.FromSeconds(60)
    );

// 使用
try
{
    await circuitBreaker.ExecuteAsync(async () => await CallExternalService());
}
catch (BrokenCircuitException)
{
    // 熔断时的降级逻辑
    await UseCachedDataAsync();
}

// 固定超时
var timeoutPolicy = Policy.TimeoutAsync(TimeSpan.FromSeconds(10));

// 乐观超时（取消正在执行的操作）
var optimisticTimeout = Policy.TimeoutAsync(
    TimeSpan.FromSeconds(5),
    TimeoutStrategy.Optimistic);

// 组合使用
var policyWrap = Policy.WrapAsync(retryPolicy, circuitBreaker, timeoutPolicy);

await policyWrap.ExecuteAsync(async () =>
{
    await _httpClient.GetAsync(url);
});

// 固定大小的舱壁（限制并发数）
var bulkhead = Policy.BulkheadAsync(
    maxParallelization: 10,     // 最多 10 个并发
    maxQueuingActions: 5,       // 队列中最多 5 个等待
    onBulkheadRejected: (context) =>
        logger.LogWarning("Bulkhead full, rejecting request"));

// 使用
try
{
    await bulkhead.ExecuteAsync(async () => await ProcessRequest());
}
catch (BulkheadRejectedException)
{
    // 舱壁满时的降级处理
    return "Service temporarily unavailable";
}

public static IAsyncPolicy<HttpResponseMessage> GetResiliencePolicy()
{
    // 1. 重试策略
    var retry = Policy<HttpResponseMessage>
        .Handle<HttpRequestException>()
        .OrResult(r => !r.IsSuccessStatusCode)
        .WaitAndRetryAsync(3, i => TimeSpan.FromSeconds(Math.Pow(2, i)));

    // 2. 熔断策略
    var circuitBreaker = Policy<HttpResponseMessage>
        .Handle<HttpRequestException>()
        .OrResult(r => !r.IsSuccessStatusCode)
        .CircuitBreakerAsync(5, TimeSpan.FromSeconds(30));

    // 3. 超时策略
    var timeout = Policy.TimeoutAsync<HttpResponseMessage>(TimeSpan.FromSeconds(10));

    // 4. 降级策略
    var fallback = Policy<HttpResponseMessage>
        .Handle<Exception>()
        .FallbackAsync(new HttpResponseMessage(HttpStatusCode.ServiceUnavailable)
        {
            Content = new StringContent("{\"message\":\"Service unavailable\"}")
        });

    // 组合顺序：Fallback -> Retry -> CircuitBreaker -> Timeout
    return Policy.WrapAsync(fallback, retry, circuitBreaker, timeout);
}

// ViewModel
public class UserViewModel : INotifyPropertyChanged
{
    private string _userName;
    public string UserName
    {
        get => _userName;
        set
        {
            _userName = value;
            OnPropertyChanged();
        }
    }

    private bool _isLoading;
    public bool IsLoading
    {
        get => _isLoading;
        set
        {
            _isLoading = value;
            OnPropertyChanged();
        }
    }

    public ICommand LoadCommand { get; }
    public ICommand SaveCommand { get; }

    public UserViewModel()
    {
        LoadCommand = new RelayCommand(Load, CanLoad);
        SaveCommand = new RelayCommand(Save, CanSave);
    }

    private async void Load()
    {
        IsLoading = true;
        try
        {
            var user = await _userService.GetByIdAsync(1);
            UserName = user.Name;
        }
        finally
        {
            IsLoading = false;
        }
    }

    private bool CanLoad() => !IsLoading;
    private bool CanSave() => !string.IsNullOrEmpty(UserName);

    public event PropertyChangedEventHandler PropertyChanged;
    protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

// .NET 线程安全单例
public sealed class Singleton
{
    private static readonly Lazy<Singleton> _instance = 
        new Lazy<Singleton>(() => new Singleton());
    
    public static Singleton Instance => _instance.Value;
    
    private Singleton() { }
}

// .NET 策略模式
public interface IDiscountStrategy
{
    decimal CalculateDiscount(decimal total);
}

public class PercentageDiscount : IDiscountStrategy
{
    private readonly decimal _percentage;
    public PercentageDiscount(decimal percentage) => _percentage = percentage;
    public decimal CalculateDiscount(decimal total) => total * _percentage / 100;
}

public class FixedDiscount : IDiscountStrategy
{
    private readonly decimal _amount;
    public FixedDiscount(decimal amount) => _amount = amount;
    public decimal CalculateDiscount(decimal total) => Math.Min(_amount, total);
}

public class OrderService
{
    private IDiscountStrategy _strategy;
    
    public void SetDiscountStrategy(IDiscountStrategy strategy) => _strategy = strategy;
    
    public decimal CalculateTotal(decimal total) => _strategy.CalculateDiscount(total);
}

// .NET MediatR 命令
public class CreateUserCommand : IRequest<int>
{
    public string Name { get; set; }
    public string Email { get; set; }
}

public class CreateUserHandler : IRequestHandler<CreateUserCommand, int>
{
    private readonly IUserRepository _repository;
    
    public CreateUserHandler(IUserRepository repository) => _repository = repository;
    
    public async Task<int> Handle(CreateUserCommand request, CancellationToken ct)
    {
        var user = new User(request.Name, request.Email);
        await _repository.AddAsync(user);
        return user.Id;
    }
}

// 控制器中使用
[HttpPost]
public async Task<IActionResult> Create(CreateUserCommand command)
{
    var id = await _mediator.Send(command);
    return Ok(id);
}

// .NET Redis 缓存
public class CachedUserService : IUserService
{
    private readonly IDistributedCache _cache;
    private readonly IUserRepository _repository;
    
    public CachedUserService(IDistributedCache cache, IUserRepository repository)
    {
        _cache = cache;
        _repository = repository;
    }
    
    public async Task<User?> GetByIdAsync(int id)
    {
        var key = $"user:{id}";
        var cached = await _cache.GetStringAsync(key);
        
        if (cached != null)
            return JsonSerializer.Deserialize<User>(cached);
        
        var user = await _repository.GetByIdAsync(id);
        if (user != null)
        {
            var options = new DistributedCacheEntryOptions()
                .SetAbsoluteExpiration(TimeSpan.FromMinutes(30))
                .SetSlidingExpiration(TimeSpan.FromMinutes(10));
            
            await _cache.SetStringAsync(key, JsonSerializer.Serialize(user), options);
        }
        
        return user;
    }
}

// .NET RedLock
public class OrderService
{
    private readonly IDistributedLock _lock;
    
    public async Task ProcessOrderAsync(int orderId)
    {
        var resource = $"order:{orderId}";
        
        using (var lockResult = await _lock.AcquireAsync(resource, TimeSpan.FromSeconds(30)))
        {
            if (lockResult.IsAcquired)
            {
                // 执行业务逻辑
                await ProcessAsync(orderId);
            }
            else
            {
                throw new InvalidOperationException("Could not acquire lock");
            }
        }
    }
}