异常拦截器（ExceptionInterceptor）

 

1.异常拦截器（ExceptionInterceptor）：

 

实现了 Castle 的 IInterceptor 接口

在 Intercept 方法中通过 try-catch 块捕获目标方法执行过程中的异常

可以针对不同类型的异常进行特定处理

包含异常日志记录功能，记录发生异常的方法、参数等信息

 

using Castle.DynamicProxy;
using System;

/// <summary>
/// 异常处理拦截器
/// </summary>
public class ExceptionInterceptor : IInterceptor
{
    public void Intercept(IInvocation invocation)
    {
        try
        {
            // 执行目标方法
            invocation.Proceed();
        }
        catch (ArgumentNullException ex)
        {
            // 处理特定类型的异常
            Console.WriteLine($"参数为空异常: {ex.Message}");
            // 可以根据需要重新抛出异常或设置返回值
            // throw;
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine($"操作无效异常: {ex.Message}");
        }
        catch (Exception ex)
        {
            // 处理通用异常
            Console.WriteLine($"发生未处理异常: {ex.Message}");
            // 记录异常详细信息
            LogException(ex, invocation);
        }
    }

    /// <summary>
    /// 记录异常详细信息
    /// </summary>
    private void LogException(Exception ex, IInvocation invocation)
    {
        string message = $"方法: {invocation.Method.Name}\n" +
                         $"参数: {string.Join(", ", invocation.Arguments)}\n" +
                         $"异常: {ex}\n";
        
        // 实际应用中可以写入日志文件或日志系统
        Console.WriteLine($"异常日志:\n{message}");
    }
}

 

 

2.服务代理工厂（ServiceProxyFactory）：

 

使用 ProxyGenerator 创建代理对象

将拦截器应用到目标对象上

提供简洁的接口用于创建带有拦截功能的服务实例

using Castle.DynamicProxy;
using System;

/// <summary>
/// 服务代理工厂，用于创建带有拦截器的服务实例
/// </summary>
public static class ServiceProxyFactory
{
    private static readonly ProxyGenerator _proxyGenerator = new ProxyGenerator();
    
    /// <summary>
    /// 创建带有异常拦截器的服务实例
    /// </summary>
    public static T Create<T>(T target) where T : class
    {
        if (target == null)
            throw new ArgumentNullException(nameof(target));
            
        // 创建拦截器
        var interceptor = new ExceptionInterceptor();
        
        // 生成代理对象
        return _proxyGenerator.CreateInterfaceProxyWithTarget(
            typeof(T), 
            target, 
            interceptor) as T;
    }
}

 

3.使用方式：

 

定义业务接口和实现类

通过代理工厂创建代理对象

调用代理对象的方法，异常会被自动拦截处理

using System;

// 定义服务接口
public interface IOrderService
{
    void CreateOrder(int orderId, string customerName);
    decimal CalculateTotal(decimal price, int quantity);
}

// 实现服务
public class OrderService : IOrderService
{
    public void CreateOrder(int orderId, string customerName)
    {
        if (orderId <= 0)
            throw new ArgumentException("订单ID必须大于0", nameof(orderId));
            
        if (string.IsNullOrEmpty(customerName))
            throw new ArgumentNullException(nameof(customerName), "客户名称不能为空");
            
        Console.WriteLine($"订单 {orderId} 创建成功，客户: {customerName}");
    }
    
    public decimal CalculateTotal(decimal price, int quantity)
    {
        if (price < 0)
            throw new InvalidOperationException("价格不能为负数");
            
        if (quantity <= 0)
            throw new ArgumentOutOfRangeException(nameof(quantity), "数量必须大于0");
            
        return price * quantity;
    }
}

// 使用示例
class Program
{
    static void Main(string[] args)
    {
        // 创建原始服务实例
        IOrderService originalService = new OrderService();
        
        // 创建带有异常拦截的代理服务
        IOrderService proxyService = ServiceProxyFactory.Create(originalService);
        
        try
        {
            // 测试正常情况
            proxyService.CreateOrder(1001, "张三");
            
            // 测试异常情况
            proxyService.CreateOrder(-1, null);
            proxyService.CalculateTotal(-100, 5);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Main方法捕获到异常: {ex.Message}");
        }
    }
}