第17章-错误处理与最佳实践

第17章：错误处理与最佳实践

17.1 异常处理策略

17.1.1 统一异常处理

public class GeoServerExceptionHandler
{
    public static async Task<T> ExecuteWithRetryAsync<T>(
        Func<Task<T>> operation,
        int maxRetries = 3,
        int delayMs = 1000)
    {
        for (int i = 0; i < maxRetries; i++)
        {
            try
            {
                return await operation();
            }
            catch (GeoServerRequestException ex) when (IsRetriable(ex))
            {
                if (i == maxRetries - 1) throw;
                await Task.Delay(delayMs * (i + 1));
            }
        }
        throw new InvalidOperationException("Unreachable");
    }

    private static bool IsRetriable(GeoServerRequestException ex)
    {
        return ex.StatusCode >= 500 || ex.StatusCode == 429;
    }
}

17.2 性能优化最佳实践

17.2.1 连接池管理

public class GeoServerConnectionPool
{
    private static readonly SemaphoreSlim _semaphore = new(10, 10);

    public static async Task<T> ExecuteAsync<T>(Func<Task<T>> operation)
    {
        await _semaphore.WaitAsync();
        try
        {
            return await operation();
        }
        finally
        {
            _semaphore.Release();
        }
    }
}

17.2.2 批量操作优化

public class BatchOperationOptimizer
{
    public async Task<Dictionary<string, bool>> CreateMultipleLayersAsync(
        List<Layer> layers,
        int batchSize = 5)
    {
        var results = new Dictionary<string, bool>();
        
        for (int i = 0; i < layers.Count; i += batchSize)
        {
            var batch = layers.Skip(i).Take(batchSize);
            var tasks = batch.Select(async layer =>
            {
                try
                {
                    await _layerService.CreateLayerAsync(layer);
                    return (layer.Name, true);
                }
                catch
                {
                    return (layer.Name, false);
                }
            });

            var batchResults = await Task.WhenAll(tasks);
            foreach (var (name, success) in batchResults)
            {
                results[name] = success;
            }

            // 批次间延迟，避免服务器过载
            if (i + batchSize < layers.Count)
            {
                await Task.Delay(1000);
            }
        }

        return results;
    }
}

17.3 日志记录最佳实践

public class GeoServerLogger
{
    private readonly ILogger _logger;

    public async Task<T> LoggedOperationAsync<T>(
        string operationName,
        Func<Task<T>> operation)
    {
        var sw = Stopwatch.StartNew();
        _logger.LogInformation($"开始执行: {operationName}");

        try
        {
            var result = await operation();
            sw.Stop();
            _logger.LogInformation(
                $"完成: {operationName}, 耗时: {sw.ElapsedMilliseconds}ms");
            return result;
        }
        catch (Exception ex)
        {
            sw.Stop();
            _logger.LogError(ex,
                $"失败: {operationName}, 耗时: {sw.ElapsedMilliseconds}ms");
            throw;
        }
    }
}

17.4 配置管理最佳实践

public class ConfigurationManager
{
    public static GeoServerClientOptions LoadConfiguration()
    {
        // 从环境变量加载
        var options = new GeoServerClientOptions
        {
            BaseUrl = Environment.GetEnvironmentVariable("GEOSERVER_URL")
                     ?? "http://localhost:8080/geoserver",
            Username = Environment.GetEnvironmentVariable("GEOSERVER_USER")
                      ?? "admin",
            Password = Environment.GetEnvironmentVariable("GEOSERVER_PASSWORD")
                      ?? "geoserver",
            TimeoutSeconds = int.Parse(
                Environment.GetEnvironmentVariable("GEOSERVER_TIMEOUT") ?? "30")
        };

        // 验证配置
        ValidateConfiguration(options);

        return options;
    }

    private static void ValidateConfiguration(GeoServerClientOptions options)
    {
        if (string.IsNullOrEmpty(options.BaseUrl))
            throw new ArgumentException("BaseUrl is required");

            throw new ArgumentException("BaseUrl must be a valid URL");

        if (string.IsNullOrEmpty(options.Username))
            throw new ArgumentException("Username is required");
    }
}

17.5 安全最佳实践

17.5.1 凭据管理

// 不要在代码中硬编码凭据
// ❌ 错误做法
var options = new GeoServerClientOptions
{
    Username = "admin",
    Password = "geoserver" // 硬编码密码
};

// ✅ 正确做法
var options = new GeoServerClientOptions
{
    Username = Environment.GetEnvironmentVariable("GEOSERVER_USER"),
    Password = Environment.GetEnvironmentVariable("GEOSERVER_PASSWORD")
};

17.5.2 HTTPS 使用

// 生产环境始终使用 HTTPS
var options = new GeoServerClientOptions
{
    BaseUrl = "https://geoserver.example.com/geoserver", // 使用HTTPS
    Username = GetSecureUsername(),
    Password = GetSecurePassword()
};

17.6 监控和告警

public class MonitoringService
{
    public async Task MonitorSystemHealthAsync()
    {
        var checker = new SystemHealthChecker();
        var report = await checker.CheckHealthAsync();

        {
            await SendAlertAsync("GeoServer 离线");
        }

        if (report.MemoryUsagePercent > 90)
        {
            await SendAlertAsync($"内存使用率过高: {report.MemoryUsagePercent}%");
        }

        foreach (var error in report.Errors)
        {
            await SendAlertAsync($"系统错误: {error}");
        }
    }

    private async Task SendAlertAsync(string message)
    {
        // 发送告警通知（邮件、短信、企业微信等）
        _logger.LogCritical(message);
        // 实现具体的告警逻辑
    }
}

17.7 部署清单

17.7.1 生产部署检查

public class DeploymentChecklist
{
    public async Task<ChecklistResult> RunPreDeploymentChecksAsync()
    {
        var result = new ChecklistResult();

        // 1. 验证配置
        result.AddCheck("配置验证", ValidateConfiguration());

        // 2. 测试连接
        result.AddCheck("连接测试", await TestConnectionAsync());

        // 3. 验证权限
        result.AddCheck("权限验证", await ValidatePermissionsAsync());

        // 4. 检查资源
        result.AddCheck("资源检查", await CheckResourcesAsync());

        // 5. 验证缓存配置
        result.AddCheck("缓存配置", await ValidateCacheConfigAsync());

        return result;
    }
}

17.8 本章小结

本章学习了：

1. 异常处理和重试策略
2. 性能优化最佳实践
3. 日志记录和监控
4. 配置和安全管理
5. 部署前检查清单

下一章将通过综合实战案例展示如何将所学知识应用到实际项目中。

---

相关资源：

• .NET 最佳实践
• GeoServer 生产部署指南