.NET中实现AOP可通过RealProxy（.NET Framework）或Castle DynamicProxy（.NET Core+）创建代理拦截方法调用，结合特性与DI容器可实现声明式日志、异常处理等横切关注点。
.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
定义拦截器：
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
核心思想是：不修改原始代码的前提下，通过代理机制“包裹”目标方法，插入横切逻辑（如日志、性能监控、权限校验等）。
基本上就这些，不复杂但容易忽略细节。
