.NET如何实现一个简单的AOP（面向切面编程）-C#.Net教程-PHP中文网

.NET如何实现一个简单的AOP（面向切面编程）

小老鼠

发布： 2025-11-02 11:22:02

原创

260人浏览过

.NET中实现AOP可通过RealProxy（.NET Framework）或Castle DynamicProxy（.NET Core+）创建代理拦截方法调用，结合特性与DI容器可实现声明式日志、异常处理等横切关注点。

.net如何实现一个简单的aop（面向切面编程）

.NET 中实现简单的 AOP（面向切面编程）可以通过多种方式完成，比如使用动态代理、特性（Attribute）、拦截机制或借助第三方库。下面介绍一种基于 RealProxy 和 透明代理 的轻量级实现方式，适用于 .NET Framework。在 .NET Core/.NET 5+ 中推荐使用 Microsoft.Extensions.DependencyInjection 配合拦截库如 Castle.DynamicProxy 来实现。

1. 使用 RealProxy 实现方法拦截（仅限 .NET Framework）

RealProxy 是 .NET Framework 提供的一个抽象类，可用于创建透明代理，从而拦截对目标对象的方法调用。

步骤：

继承 RealProxy，重写 Invoke 方法
在 Invoke 中添加前置/后置逻辑
返回代理对象

示例代码：

using System;
using System.Runtime.Remoting.Proxies;
using System.Runtime.Remoting.Messaging;

public class LoggingProxy : RealProxy
{
    private readonly object _target;

    public LoggingProxy(Type type, object target) : base(type)
    {
        _target = target;
    }

    public override IMessage Invoke(IMessage msg)
    {
        IMethodCallMessage methodCall = msg as IMethodCallMessage;
        string methodName = methodCall.MethodName;

        // 前置处理：记录方法开始
        Console.WriteLine($"开始执行方法: {methodName}");

        try
        {
            object[] args = methodCall.Args;
            object result = methodCall.MethodBase.Invoke(_target, args);

            // 后置处理：记录方法结束
            Console.WriteLine($"方法 {methodName} 执行完成");
            return new ReturnMessage(result, null, 0, null, methodCall);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"方法 {methodName} 执行出错: {ex.InnerException?.Message}");
            return new ReturnMessage(ex.InnerException, msg as IMethodCallMessage);
        }
    }
}

登录后复制

使用示例：

public interface IService
{
    void DoWork();
}

public class Service : IService
{
    public void DoWork()
    {
        Console.WriteLine("正在执行业务逻辑...");
        // 模拟工作
        System.Threading.Thread.Sleep(100);
    }
}

// 调用方式
class Program
{
    static void Main()
    {
        var service = new Service();
        var proxy = new LoggingProxy(typeof(IService), service);
        var proxyInstance = (IService)proxy.GetTransparentProxy();

        proxyInstance.DoWork(); // 输出：开始执行... 正在执行... 方法执行完成
    }
}

登录后复制

2. 使用 Castle DynamicProxy（推荐用于 .NET Core/.NET 5+）

Castle DynamicProxy 是一个广泛使用的库，支持在 .NET Core 中实现 AOP。

安装 NuGet 包：

Install-Package Castle.Core

登录后复制

定义拦截器：

多面鹅

面向求职者的AI面试平台

查看详情

using Castle.DynamicProxy;

public class LogInterceptor : IInterceptor
{
    public void Intercept(IInvocation invocation)
    {
        Console.WriteLine($"调用前: {invocation.Method.Name}");

        try
        {
            invocation.Proceed(); // 执行原方法
            Console.WriteLine($"调用后: {invocation.Method.Name}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"异常: {invocation.Method.Name} - {ex.Message}");
            throw;
        }
    }
}

登录后复制

生成代理对象：

var proxyGenerator = new ProxyGenerator();
var service = new Service();
var proxy = proxyGenerator.CreateClassProxyWithTarget(service, new LogInterceptor());

proxy.DoWork();

登录后复制

3. 使用特性 + DI 容器（进阶方案）

结合依赖注入和拦截器，可以实现更灵活的 AOP，例如通过自定义 Attribute 标记需要拦截的方法。

虽然原生 .NET 不直接支持方法拦截，但可以结合 Autofac 或 Scrutor 等库实现基于特性的 AOP。

例如，在 Autofac 中配合 DynamicProxy 可以做到：

builder.RegisterType<Service>()
       .As<IService>()
       .EnableInterfaceInterceptors()
       .InterceptedBy(typeof(LogInterceptor));

登录后复制

总结

简单 AOP 实现在不同 .NET 版本中有不同选择：

.NET Framework 可用 RealProxy 快速实现透明代理
.NET Core/.NET 5+ 推荐使用 Castle DynamicProxy 配合拦截器
生产环境建议结合 DI 容器和特性，实现声明式 AOP

核心思想是：不修改原始代码的前提下，通过代理机制“包裹”目标方法，插入横切逻辑（如日志、性能监控、权限校验等）。

基本上就这些，不复杂但容易忽略细节。

以上就是.NET如何实现一个简单的AOP（面向切面编程）的详细内容，更多请关注php中文网其它相关文章！

大家都在看：

.NET怎么将字节数组（byte[]）和字符串相互转换_字节数组字符串互转技巧 .NET如何连接MySQL数据库并执行CRUD操作_MySQL数据库CRUD操作教程 .NET怎么实现多线程编程中的线程同步_多线程同步实现方案 .NET如何使用log4net或Serilog记录日志_log4net Serilog日志记录教程 .NET如何使用Entity Framework Core进行读写分离_EF Core读写分离配置