.NET Core 中的异常处理

概述：异常处理是软件开发的一个关键方面，可确保应用程序健壮且无错误。在 .NET Core 中，Microsoft 提供了一个用于管理异常的复杂框架，允许开发人员编写更可靠、可维护和用户友好的应用程序。本文深入探讨了 .NET Core 中的高级异常处理技术，并通过实际示例和 C# 代码片段进行了说明，以阐明复杂的概念。了解 .NET Core 🧠 中的异常在深入研究高级概念之前，让我们先澄清一下什么是例外。异常是程序执行中断时发生的运行时错误。.NET Core 具有异常类的综合层次结构，所有异常类都派生自基类。System.Exception问题陈述：沉默的杀手 — 未处理的异常想象一下，您的

异常处理是软件开发的一个关键方面，可确保应用程序健壮且无错误。在 .NET Core 中，Microsoft 提供了一个用于管理异常的复杂框架，允许开发人员编写更可靠、可维护和用户友好的应用程序。本文深入探讨了 .NET Core 中的高级异常处理技术，并通过实际示例和 C# 代码片段进行了说明，以阐明复杂的概念。

了解 .NET Core 🧠 中的异常

在深入研究高级概念之前，让我们先澄清一下什么是例外。异常是程序执行中断时发生的运行时错误。.NET Core 具有异常类的综合层次结构，所有异常类都派生自基类。System.Exception

问题陈述：沉默的杀手 — 未处理的异常

想象一下，您的应用程序与外部 API 交互以获取用户数据。如果 API 已关闭，您的应用程序可能会在没有适当的异常处理的情况下崩溃，从而导致糟糕的用户体验。

解决方案：Try-Catch 块

异常处理的最基本形式是块。以下是处理该方案的方法：try-catch

try  
{  
    var userData = FetchUserDataFromApi(); // Method that calls the API  
}  
catch (HttpRequestException ex)  
{  
    LogError(ex); // Log the error for debugging  
    ShowFriendlyErrorToUser(); // Show a user-friendly message  
}

高级异常处理技术 🔍

1. 异常过滤器

.NET Core 引入了异常筛选器，允许在捕获块中指定条件。.NET Core introduced exception filters that allows you to specify a condition within a catch block.

用例：仅记录特定异常

假设您只想记录由特定条件导致的异常，例如超出 API 速率限制。

try  
{  
    var data = FetchData();  
}  
catch (ApiException ex) when (ex.StatusCode == 429)  
{  
    LogError(ex);  
}

2. 自定义例外

创建自定义异常可以阐明错误处理的意图，使代码更具可读性和可维护性。

问题：导致混淆的一般例外

当应用程序引发一般异常时，可能很难确定错误的原因。

解决方案：实现自定义异常

public class UserNotFoundException : Exception  
{  
    public UserNotFoundException(string userId)  
        : base($"User with ID {userId} was not found.")  
    {  
    }  
}  
  
// Usage  
if (user == null)  
{  
    throw new UserNotFoundException(userId);  
}

3. 集中式异常处理

在 Web 应用程序中，集中式异常处理允许您在单个位置管理错误，从而为错误日志记录和响应格式设置提供一致的方法。

用例：Web API 全局错误处理

在 ASP.NET Core 中，可以使用中间件进行全局异常处理。

public class ErrorHandlingMiddleware  
{  
    private readonly RequestDelegate _next;  
  
    public ErrorHandlingMiddleware(RequestDelegate next)  
    {  
        _next = next;  
    }  
  
    public async Task Invoke(HttpContext context)  
    {  
        try  
        {  
            await _next(context);  
        }  
        catch (Exception ex)  
        {  
            HandleException(context, ex);  
        }  
    }  
  
    private static void HandleException(HttpContext context, Exception ex)  
    {  
        // Log and respond to the error accordingly  
        context.Response.StatusCode = 500;  
        context.Response.ContentType = "application/json";  
        // Serialize and write the exception details to the response  
    }  
}  
  
// In Startup.cs  
public void Configure(IApplicationBuilder app)  
{  
    app.UseMiddleware<ErrorHandlingMiddleware>();  
}

4. 街区finally

该块用于在 try/catch 块之后执行代码，而不管是否引发了异常。finally

使用案例：确保释放资源

FileStream file = null;  
try  
{  
    file = File.Open("path/to/file", FileMode.Open);  
    // Work with the file  
}  
catch (IOException ex)  
{  
    LogError(ex);  
}  
finally  
{  
    file?. Close();  
}

5. 聚合异常

在处理任务和并行操作时，可能会引发多个异常。 用于将这些异常捆绑到单个异常中。AggregateException

示例：处理任务中的异常

try  
{  
    Task.WaitAll(task1, task2, task3);  
}  
catch (AggregateException ex)  
{  
    foreach (var innerEx in ex.InnerExceptions)  
    {  
        LogError(innerEx);  
    }  
}

6. 使用 vs. 重新抛出异常。throw;throw ex;

了解 和 之间的区别对于维护异常的原始堆栈跟踪至关重要。throw;throw ex;

用例：保留堆栈跟踪

捕获并重新引发异常时，using 会保留原始堆栈跟踪，而会重置它。throw;throw ex;

try  
{  
    // Some operation that might throw an exception  
}  
catch (Exception ex)  
{  
    // Perform some error logging or cleanup  
    throw; // Preserves the stack trace  
}

7. 条件捕获块的关键字when

该关键字允许根据运行时条件更精确地控制何时执行 catch 块。when

示例：基于异常数据的条件处理

try  
{  
    // Operation that might throw exceptions  
}  
catch (CustomException ex) when (ex.ErrorCode == 404)  
{  
    // Handle not found errors specifically  
}  
catch (Exception ex)  
{  
    // General error handling  
}

8. 利用ExceptionDispatchInfo

ExceptionDispatchInfo允许捕获异常并从另一个上下文中抛出异常，同时保留堆栈跟踪。

用例：异步异常处理

这在异步编程中特别有用，因为异步编程需要在不同的线程上重新引发异常。

ExceptionDispatchInfo capturedException = null;  
  
try  
{  
    // Async operation that might fail  
}  
catch (Exception ex)  
{  
    capturedException = ExceptionDispatchInfo.Capture(ex);  
}  
  
if (capturedException != null)  
{  
    capturedException.Throw(); // Rethrows with the original stack trace intact  
}

9. 利用异步错误处理Task.Exception

使用异步任务时，异常封装在任务本身中。访问该属性可以正常处理这些错误。Exception

示例：等待具有异常处理的任务

var task = Task.Run(() => { throw new CustomException("Error"); });  
  
try  
{  
    await task;  
}  
catch (CustomException ex)  
{  
    // Handle specific custom exceptions  
}

10. 创建健壮的日志记录机制

通过将全面的日志记录与异常处理策略集成，可以更深入地了解运行时行为和错误。

策略：全局异常处理程序中的集中日志记录

在 ASP.NET Core 应用程序中的全局异常处理程序或中间件等区域实现集中日志记录，可确保一致地记录所有未处理的异常。

public void Configure(IApplicationBuilder app, ILogger<Startup> logger)  
{  
    app.UseExceptionHandler(errorApp =>  
    {  
        errorApp.Run(async context =>  
        {  
            context.Response.StatusCode = 500; // Internal Server Error  
            var exceptionHandlerPathFeature = context.Features.Get\<IExceptionHandlerPathFeature>();  
            logger.LogError(exceptionHandlerPathFeature.Error, "Unhandled exception.");  
            // Respond with error details or a generic message  
        });  
    });  
}

11. 断路器模式

断路器模式对于防止系统重复尝试执行可能失败的操作至关重要。在处理可能暂时不可用的外部资源或服务时，它特别有用。

使用案例：防止系统过载

想象一下，一个依赖于第三方服务的应用程序。如果此服务出现故障，则持续尝试连接可能会在客户端重新联机时使客户端和服务过载。

public class CircuitBreaker  
{  
    private enum State { Open, HalfOpen, Closed }  
    private State state = State.Closed;  
    private int failureThreshold = 5;  
    private int failureCount = 0;  
    private DateTime lastAttempt = DateTime.MinValue;  
    private TimeSpan timeout = TimeSpan.FromMinutes(1);  
  
    public bool CanAttemptOperation()  
    {  
        switch (state)  
        {  
            case State.Closed:  
                return true;  
            case State.Open:  
                if ((DateTime.UtcNow - lastAttempt) > timeout)  
                {  
                    state = State.HalfOpen;  
                    return true;  
                }  
                return false;  
            case State.HalfOpen:  
                return false;  
            default:  
                throw new InvalidOperationException("Invalid state");  
        }  
    }  
  
    public void RecordFailure()  
    {  
        lastAttempt = DateTime.UtcNow;  
        failureCount++;  
        if (failureCount >= failureThreshold)  
        {  
            state = State.Open;  
        }  
    }  
  
    public void Reset()  
    {  
        state = State.Closed;  
        failureCount = 0;  
    }  
}

12. 错误监控和警报系统

实施全面的错误监控和警报系统使团队能够对不可预见的问题做出快速反应，从而最大限度地减少停机时间并提高用户满意度。

策略：与 Application Insights 集成

Microsoft 的 Application Insights 提供广泛的监视功能，包括自动异常跟踪、自定义错误日志记录和基于预定义条件的警报。

// Configure Application Insights in Startup.cs or Program.cs  
services.AddApplicationInsightsTelemetry();  
  
// Use TelemetryClient to log custom exceptions  
public void LogError(Exception exception)  
{  
    var telemetryClient = new TelemetryClient();  
    telemetryClient.TrackException(exception);  
}

13. 主动错误恢复

主动错误恢复包括预测潜在的故障点并实施自动从这些错误中恢复的策略。

示例：自动重试机制

对于可能由于暂时性条件而间歇性失败的操作，实现自动重试机制可以提高可靠性。

public async Task<T> ExecuteWithRetryAsync<T>(Func<Task<T>> operation, int maxAttempts = 3)  
{  
    int attempt = 0;  
    while (true)  
    {  
        try  
        {  
            return await operation();  
        }  
        catch (Exception ex) when (attempt < maxAttempts)  
        {  
            LogWarning($"Operation failed, attempt {attempt}. Retrying...");  
            attempt++;  
            await Task.Delay(TimeSpan.FromSeconds(2));  
        }  
    }  
}

14. 利用 Polly 制定高级弹性策略

Polly 是一个 .NET 库，提供复原能力和暂时性故障处理功能。它提供重试、断路器、超时、隔板隔离等策略。

Polly 集成示例：重试和断路器

// Define a policy that retries three times with a two-second delay between retries  
var retryPolicy = Policy  
    .Handle\<HttpRequestException>()  
    .WaitAndRetryAsync(3, retryAttempt => TimeSpan.FromSeconds(2));  
  
// Define a circuit breaker policy that breaks the circuit after 5 consecutive failures for one minute  
var circuitBreakerPolicy = Policy  
    .Handle\<HttpRequestException>()  
    .CircuitBreakerAsync(5, TimeSpan.FromMinutes(1));  
  
var policyWrap = Policy.WrapAsync(retryPolicy, circuitBreakerPolicy);  
  
await policyWrap.ExecuteAsync(async () =>   
{  
    // Code to execute that can potentially throw HttpRequestException  
});

15. 异常处理的依赖注入

利用依赖关系注入 （DI） 来管理异常处理策略可提供灵活性，并将错误处理逻辑与业务逻辑分离。这种方法允许更易于管理的代码，并能够为不同的环境（例如，开发与生产）交换处理策略。

示例：注入自定义错误处理程序

public interface IErrorHandler  
{  
    void Handle(Exception exception);  
}  
  
public class GlobalErrorHandler : IErrorHandler  
{  
    public void Handle(Exception exception)  
    {  
        // Log the exception, send notifications, etc.  
    }  
}  
  
// In Startup.cs  
services.AddSingleton<IErrorHandler, GlobalErrorHandler>();  
  
// In your application code  
public class MyService  
{  
    private readonly IErrorHandler _errorHandler;  
  
    public MyService(IErrorHandler errorHandler)  
    {  
        _errorHandler = errorHandler;  
    }  
  
    public void MyMethod()  
    {  
        try  
        {  
            // Potentially failing operation  
        }  
        catch (Exception ex)  
        {  
            _errorHandler.Handle(ex);  
            throw; // Rethrow if necessary  
        }  
    }  
}

16. 错误恢复事务

实施事务可确保操作成功完成或在发生错误时回滚，从而保持数据完整性。

使用案例：数据库操作

在执行多个相关的数据库操作时，将它们包装在事务中可确保如果一个操作失败，可以还原所有更改，以保持数据库处于一致状态。

using (var transaction = dbContext.Database.BeginTransaction())  
{  
    try  
    {  
        // Perform database operations here  
  
        dbContext.SaveChanges();  
        transaction.Commit();  
    }  
    catch (Exception)  
    {  
        transaction.Rollback();  
        throw;  
    }  
}

17. 异步异常处理

.NET Core 中的异步操作可能会导致异常，由于异步/等待模式的性质，这些异常的处理方式不同。了解如何正确处理异步代码中的异常对于保持应用程序响应能力和防止未观察到的任务异常至关重要。

最佳实践：异步/等待异常处理

public async Task MyAsyncMethod()  
{  
    try  
    {  
        await SomeAsyncOperation();  
    }  
    catch (Exception ex)  
    {  
        // Handle exception from asynchronous operation  
    }  
}

18. ASP.NET 核心应用程序中的全局异常处理

对于 Web 应用程序，配置全局异常处理程序允许集中错误管理，确保以统一的方式处理所有未处理的异常。

实现：用于全局异常处理的中间件

public class ExceptionHandlingMiddleware  
{  
    private readonly RequestDelegate _next;  
  
    public ExceptionHandlingMiddleware(RequestDelegate next)  
    {  
        _next = next;  
    }  
  
    public async Task Invoke(HttpContext httpContext, IErrorHandler errorHandler)  
    {  
        try  
        {  
            await _next(httpContext);  
        }  
        catch (Exception ex)  
        {  
            errorHandler.Handle(ex);  
            httpContext.Response.StatusCode = 500; // Internal Server Error  
            // Optionally, write a generic error message to the response  
        }  
    }  
}  
  
// In Startup.cs  
public void Configure(IApplicationBuilder app)  
{  
    app.UseMiddleware\<ExceptionHandlingMiddleware>();  
}

19. 快速故障系统设计

快速故障原则涉及将系统设计为在故障点立即报告，而无需尝试继续执行。此方法可以通过在尽可能靠近错误源的地方停止执行来简化错误检测和调试。

示例：验证前提条件

public void ProcessData(List<string> data)  
{  
    if (data == null) throw new ArgumentNullException(nameof(data));  
    if (data.Count == 0) throw new ArgumentException("Data cannot be empty", nameof(data));  
  
    // Proceed with processing  
}

20. 通过优雅的错误处理增强用户体验

在面向用户的应用程序中，如何传达错误会显著影响用户满意度。实现正常的错误处理涉及捕获异常并显示有意义的、用户友好的消息，而不是隐晦的错误代码或技术描述。

策略：用户友好的错误消息

try  
{  
    // Operation that may fail  
}  
catch (SpecificException ex)  
{  
    ShowUserFriendlyMessage("A specific error occurred. Please try again later.");  
}  
catch (Exception ex)  
{  
    ShowUserFriendlyMessage("An unexpected error occurred. We're working on fixing it.");  
}

21. 微服务架构中的错误处理

在微服务架构中，由于系统的分布式特性，处理错误变得更加复杂。采用标准化错误响应格式和实施集中式日志记录等策略对于保持服务之间的一致性和可追溯性至关重要。

策略：标准化错误响应格式

public class ErrorResponse  
{  
    public string Message { get; set; }  
    public string Detail { get; set; }  
    // Additional fields like StatusCode, ErrorCode, etc.  
  
    public static ObjectResult CreateHttpResponse(Exception exception)  
    {  
        var response = new ErrorResponse  
        {  
            Message = "An error occurred.",  
            Detail = exception.Message  
            // Set other properties as needed  
        };  
  
        return new ObjectResult(response) { StatusCode = 500 };  
    }  
}  
  
// In a controller or middleware  
catch (Exception ex)  
{  
    return ErrorResponse.CreateHttpResponse(ex);  
}

22. 可观测性和异常处理

通过详细的日志记录、指标和分布式跟踪来增强可观测性，可以更有效地监控和调试错误，尤其是在复杂或分布式系统中。

实现：与 OpenTelemetry 集成

// Configure OpenTelemetry in your application  
services.AddOpenTelemetryTracing(builder =>  
{  
    builder  
        .AddAspNetCoreInstrumentation()  
        .AddHttpClientInstrumentation()  
        .AddConsoleExporter();  
});  
  
// Use OpenTelemetry API for custom logging and tracing  
var span = tracer.StartSpan("MyOperation");  
try  
{  
    // Perform operation  
}  
catch (Exception ex)  
{  
    span.RecordException(ex);  
    throw;  
}  
finally  
{  
    span.End();  
}

23. 用于预测性错误处理的机器学习

利用机器学习模型来预测和抢先解决潜在错误可以显著提高应用程序的可靠性。这涉及分析历史错误数据，以识别模式并预测可能的故障点。

概念：预测性维护

// Example: Pseudocode for integrating a predictive model  
var prediction = errorPredictionModel.Predict(operationParameters);  
if (prediction.IsLikelyToFail)  
{  
    LogWarning("Operation predicted to fail. Preemptively taking corrective action.");  
    // Take preemptive action based on the prediction  
}

24. 异步事件驱动架构中的异常处理

在事件驱动的体系结构中，尤其是那些采用异步消息传递或事件溯源的体系结构中，管理异常需要仔细考虑消息重试策略、幂等性和死信处理，以确保系统弹性和一致性。

策略：无法处理消息的死信队列

// Configure a dead-letter queue for handling failed message processing  
var options = new ServiceBusProcessorOptions  
{  
    MaxConcurrentCalls = 1,  
    AutoCompleteMessages = false,  
    DeadLetterErrorDescription = "Failed to process message."  
};  
  
serviceBusProcessor.ProcessMessageAsync += async args =>  
{  
    try  
    {  
        // Process message  
        await args.CompleteMessageAsync(args.Message);  
    }  
    catch (Exception ex)  
    {  
        await args.DeadLetterMessageAsync(args.Message, "ProcessingError", ex.Message);  
    }  
};

25. 异常处理中的道德考量和用户隐私

在设计异常处理机制时，考虑道德影响至关重要，尤其是在用户隐私和数据安全方面。敏感信息应仔细管理，并从向用户公开或存储在外部的日志或错误消息中排除。

最佳做法：编辑敏感信息

public void LogError(Exception ex)  
{  
    var sanitizedMessage = SanitizeExceptionMessage(ex.Message);  
    // Log the sanitized message, ensuring sensitive information is not exposed  
}  
  
private string SanitizeExceptionMessage(string message)  
{  
    // Implement logic to remove or obfuscate sensitive information  
    return message;  
}

结论：面向未来的 .NET Core 异常处理

随着 .NET Core 的不断发展，异常处理的策略和最佳做法也在不断发展。通过采用这些先进技术并考虑更广泛的系统设计，开发人员可以创建不仅强大可靠，而且能够适应未来复杂性的应用程序。用于预测性错误处理的 AI 集成、遵守道德考虑以及可观测性工具的实施代表了现代软件开发实践的前沿。因此，异常处理不仅是技术上的必要条件，而且是影响 .NET Core 应用程序的整体质量、复原能力和用户信任度的战略组件。

如果你喜欢我的文章，请给我一个赞！谢谢