如何在.NET MAUI应用中实现拦截器/面向切面编程？

由于.NET MAUI内置的依赖注入容器确实不原生支持拦截器，你可以通过以下几种方案实现面向切面编程的错误处理和响应处理：

方案1：使用第三方DI容器替代内置DI #

可以替换MAUI的内置DI为支持拦截的容器，比如Autofac或DryIoc，它们都原生支持AOP拦截能力：

示例：Autofac实现拦截 #

1. 安装NuGet包：Autofac、Autofac.Extras.DynamicProxy
2. 在MauiProgram.cs中替换内置DI容器：

using Autofac;
using Autofac.Extras.DynamicProxy;

public static class MauiProgram
{
    public static MauiApp CreateMauiApp()
    {
        var builder = MauiApp.CreateBuilder();
        builder
            .UseMauiApp<App>()
            .ConfigureFonts(fonts =>
            {
                fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
            });

        // 初始化Autofac容器构建器
        var containerBuilder = new ContainerBuilder();

        // 注册需要拦截的服务，启用接口拦截并指定拦截器
        containerBuilder.RegisterType<YourBusinessService>()
            .As<IYourBusinessService>()
            .EnableInterfaceInterceptors()
            .InterceptedBy(typeof(ErrorHandlingInterceptor));

        // 注册拦截器实例
        containerBuilder.RegisterType<ErrorHandlingInterceptor>();

        // 将Autofac集成到MAUI的依赖注入体系中
        builder.Services.AddAutofac();
        builder.Host.UseServiceProviderFactory(new AutofacServiceProviderFactory(containerBuilder));

        return builder.Build();
    }
}

3. 定义错误处理拦截器：

using Castle.DynamicProxy;

public class ErrorHandlingInterceptor : IInterceptor
{
    public void Intercept(IInvocation invocation)
    {
        try
        {
            // 执行原始方法逻辑
            invocation.Proceed();
            
            // 处理特定响应逻辑
            var response = invocation.ReturnValue;
            if (response is ApiResponse apiResponse && !apiResponse.IsSuccess)
            {
                // 自定义响应处理，比如弹窗提示、日志记录
                Application.Current.MainPage?.DisplayAlert("提示", apiResponse.Message, "确定");
            }
        }
        catch (Exception ex)
        {
            // 全局错误捕获与处理
            Console.WriteLine($"方法[{invocation.Method.Name}]执行出错：{ex.Message}");
            // 根据业务需求选择重新抛出或返回默认值
            throw;
        }
    }
}

方案2：手动实现装饰器模式（无需第三方容器） #

如果不想替换DI容器，可以用装饰器模式手动封装服务，实现轻量级的AOP效果：

1. 定义业务服务接口：

public interface IDataService
{
    Task<ApiResponse> FetchRemoteDataAsync();
}

2. 实现原始业务服务：

public class DataService : IDataService
{
    public async Task<ApiResponse> FetchRemoteDataAsync()
    {
        // 原始业务逻辑：调用API获取数据
        return await HttpClient.GetFromJsonAsync<ApiResponse>("/api/data");
    }
}

3. 实现装饰器类，封装错误和响应处理逻辑：

public class DataServiceDecorator : IDataService
{
    private readonly IDataService _innerService;

    public DataServiceDecorator(IDataService innerService)
    {
        _innerService = innerService ?? throw new ArgumentNullException(nameof(innerService));
    }

    public async Task<ApiResponse> FetchRemoteDataAsync()
    {
        try
        {
            var response = await _innerService.FetchRemoteDataAsync();
            // 处理失败响应
            if (!response.IsSuccess)
            {
                HandleFailedResponse(response);
            }
            return response;
        }
        catch (HttpRequestException ex)
        {
            // 捕获网络错误并处理
            HandleNetworkError(ex);
            throw;
        }
    }

    private void HandleFailedResponse(ApiResponse response)
    {
        Application.Current.MainPage?.DisplayAlert("请求失败", response.Message, "确认");
    }

    private void HandleNetworkError(Exception ex)
    {
        Console.WriteLine($"网络请求异常：{ex.Message}");
        // 可添加错误上报、日志记录等逻辑
    }
}

4. 在MAUI DI中注册装饰器：

// 先注册原始服务
builder.Services.AddScoped<IDataService, DataService>();
// 用装饰器包装原始服务
builder.Services.Decorate<IDataService, DataServiceDecorator>();

注：.Decorate方法依赖Microsoft.Extensions.DependencyInjection.Abstractions，MAUI项目默认已包含该包，若缺失可手动安装。

方案3：使用.NET原生DispatchProxy创建动态代理 #

利用.NET原生的DispatchProxy类创建动态代理，无需引入第三方库：

1. 创建代理基类：

public class ServiceProxy<T> : DispatchProxy
{
    private T _target;
    private Action<InvocationContext> _interceptorLogic;

    public static T Create(T target, Action<InvocationContext> interceptorLogic)
    {
        var proxy = Create<T, ServiceProxy<T>>();
        ((ServiceProxy<T>)proxy).SetTarget(target);
        ((ServiceProxy<T>)proxy).SetInterceptor(interceptorLogic);
        return proxy;
    }

    private void SetTarget(T target) => _target = target ?? throw new ArgumentNullException(nameof(target));
    private void SetInterceptor(Action<InvocationContext> interceptorLogic) => _interceptorLogic = interceptorLogic ?? throw new ArgumentNullException(nameof(interceptorLogic));

    protected override object Invoke(MethodInfo targetMethod, object[] args)
    {
        var context = new InvocationContext(targetMethod, _target, args);
        _interceptorLogic(context);
        return context.ReturnValue;
    }

    // 封装调用上下文
    public class InvocationContext
    {
        public MethodInfo Method { get; }
        public object Target { get; }
        public object[] Arguments { get; }
        public object ReturnValue { get; set; }

        public InvocationContext(MethodInfo method, object target, object[] arguments)
        {
            Method = method;
            Target = target;
            Arguments = arguments;
        }

        // 执行原始方法
        public void Proceed()
        {
            ReturnValue = Method.Invoke(Target, Arguments);
        }
    }
}

2. 在DI中注册带代理的服务：

builder.Services.AddScoped<IDataService>(sp =>
{
    var originalService = new DataService();
    return ServiceProxy<IDataService>.Create(originalService, context =>
    {
        try
        {
            context.Proceed();
            // 处理响应
            if (context.ReturnValue is ApiResponse response && !response.IsSuccess)
            {
                Application.Current.MainPage?.DisplayAlert("提示", response.Message, "确定");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"方法[{context.Method.Name}]执行出错：{ex.Message}");
            throw;
        }
    });
});

方案选择建议 #

• 若需复杂AOP场景（多拦截器、规则匹配等），优先选方案1（Autofac/DryIoc），功能最完善；
• 若仅需简单的错误/响应处理，且不想引入第三方依赖，**方案2（装饰器）**更轻量易维护；
• 方案3适合依赖原生.NET生态的场景，无需额外NuGet包，但实现相对繁琐。

内容的提问来源于stack exchange，提问作者balintn