场景：
最近推荐同事在项目中使用起了 MEF，用其构建一个插件式的多人开发框架，因为该框架不是让我去设计了，所以对于 MEF 和 IOC 等概念不是很了解的同事，便会出现各种问题。接入 AOP 便是其中的问题之一，看在大家都是一起工作的同事，能帮的我自然会尽量去帮，不过，过不了多久我就会离职了，所以，且行且珍惜吧。
主要内容：
IOC 和 AOP 的概念
对于 IOC 和 AOP，这应该又算是一个老生常谈的问题，相应的说明和资料比比皆是，所以，我在这里也不多做讲解，只是概括性的总结下。
- IOC：从英文意思来说，叫“控制反转”，即原来我们的各种操作只能依赖于抽象的具体实现，而通过 DI（依赖注入），我们的操作只依赖于抽象本身，具体实现是在运行时动态注入的。这样我们的依赖被倒置了，这就是 IOC，它不是组件和框架，它是设计模式上的东西。
- AOP：从英文意思来说，叫“面向切面编程”。在面向对象的编程里，正常情况下，我们代码的执行顺序都是纵向的，即由一个个类中的方法顺序执行。而切面，便是垂直于纵向的一面，即贯穿顺序执行中的每个单元。AOP 便是让我们从切面的角度来书写代码，而这些代码大多数都是贯穿于系统中很多类和方法中，比如日志记录、异常处理、权限控制等。AOP 和 IOC 类似，它也是设计层的东西，并不是一个实际的组件或框架。
扩展 MEF，使其支持 AOP
其实 IOC 和 AOP 真的是很好的朋友，以至于很多 IOC 的框架里原生就支持 AOP，因为 IOC 在运行时注入具体实现的时候，便是创建代理对象的最佳时机。当然，在 MEF 里，获取导出（Export）时，便是创建代理对象的契机。这里反复提及的代理对象，是目前 .NET 中实现 AOP 的一种手段。据我所知，在 .NET 中目前大体有以下两种 AOP 的实现方式：
动态代理：在运行时，动态的创建某个类或对象的代理，在代理中重写目标类（被创建成代理的类）的虚方法（可重写的方法），从而在调用代理对象的方法时，执行特定的切面代码。目前圈子里大多数实现都是使用 Emit 来动态构建一个代理类，也有使用 Dynamic 来构建的（注：这种方式并不是重写虚方法，有兴趣的同学可以查看NiceWk同学的文章）。动态代理的好处是实现起来简单，缺点便是要拦截（插入切面代码）的方法或属性必须申明为可重写的，如果你可以容忍，那么你可以选择这种方式。
使用动态代理构建的AOP框架：Castle Dynamic Proxy ，Unity，LOOM.NET 等
IL 编织：这种实现方式并不是在运行时，而是在程序集编译时或生成完毕后，在目标方法中，织入切面代码对应的 IL。目前这种实现方式，大多数是对编译器的扩展，或者是在生成完毕后加入后续的一个处理过程。IL 编织可以将 AOP 运行时的性能损耗降到最小，并且目标类中不需要定义虚方法，缺点是实现起来比较复杂，调试起来也不方便。
使用IL编织的AOP框架：Postsharp（收费），Eos，LinFu.AOP 等
如果是使用 IL 编织的 AOP 框架，那么对于 MEF 而言，是不需要做任何扩展操作即可使用的，原因很简单，MEF 最后发现的导出，必定是已经完成 IL 编织的类的实例。而动态代理不同，动态代理必须要有一个创建代理的过程。这里所说的扩展 MEF，便是让 MEF 将这个过程自动化的去执行，以便我们获取到的导出便已是我们想要的代理。
对于代理，它有两种方式，一种是类的代理，一种是对象的代理，它和适配器模式、装饰者模式很相识（可笑的是最近一次面试中，技术官问我适配器模式中“类适配”和“对象适配”的区别时，我尽然没答上来，果然技术不用则退，脑袋也也一样，各位同学一起铭记啊）。所谓类代理，便是在创建时，直接创建的便是目标类的代理类，代理类中不会包含目标类的实例；对象代理，便是使用了装饰者模式，代理类中包含目标类的实例，代理类只是做了一层装饰。以下是这两种代理的简要代码：
// 目标类
public class TargetClass
{
public virtual void Method() { }
} // 类代理
public class ClassProxy : TargetClass
{
public override void Method()
{
// ...
base.Method();
// ...
}
} // 对象代理
public class ObjectProxy : TargetClass
{
private TargetClass _targetObj;
public ObjectProxy(TargetClass targetObj)
{
_targetObj = targetObj;
} public override void Method()
{
// ...
_targetObj.Method();
// ...
}
}
创建上面代理的代码如下，各位同学应该很容易看出它们的区别：
var clsProxy = new ClassProxy();
var targetObj = new TargetClass();
var objProxy = new ObjectProxy(targetObj);
理解这两种代理的不同是很重要的，这关系到我们选择何种 AOP 实现方式，对于 MEF 的扩展，我还是推荐使用对象代理的方式，原因也很简单，因为我们可以直接在 MEF 获取导出后，对导出进行一个处理，这样实现起来比较简单，如果使用类代理的话，我们需要深入到 MEF 对象创建，这可能比较麻烦。如何对导出进行一个后处理呢？这相当简单，我们只要继承至CompositionContainer，重写它的 GetExportsCore，现实我们自己的 Container 即可：
public class AOPCompositionContainer : CompositionContainer
{
#region ctor
public AOPCompositionContainer()
: base() { }
public AOPCompositionContainer(params ExportProvider[] providers)
: base(providers) { } public AOPCompositionContainer(ComposablePartCatalog catalog, params ExportProvider[] providers)
: base(catalog, providers) { } public AOPCompositionContainer(ComposablePartCatalog catalog, bool isThreadSafe, params ExportProvider[] providers)
: base(catalog, isThreadSafe, providers) { } #endregion protected override IEnumerable<Export> GetExportsCore(ImportDefinition definition, AtomicComposition atomicComposition)
{
var exports = base.GetExportsCore(definition, atomicComposition);
return exports.Select(GetAopExportCore);
} protected virtual Export GetAopExportCore(Export export)
{
if (!export.Metadata.ContainsKey("AOPEnabled"))
return export; var aspectsEnabled = export.Metadata["AOPEnabled"]; if ((bool)aspectsEnabled == false)
return export; return new Export(export.Definition, () => Aop.ProxyGenerator.CreateProxy(this, export.Value));
}
}
代码相当的简单，我们在获取到导出后，对导出逐个的进行了一个后处理，我们判定导出的元数据中是否包含 AOPEnabled ，如果有，且该值为 true，则返回使用 ProxyGenerator 创建的代理构建的导出，否则直接返回原始获取到的导出。这里使用到了导出的元数据，不清楚的同学，可以看先前的博文记录，如此一来，如果我们想导出自动为代理的话，就必须在导出时指定 AOPEnabled 元数据，并且要设置为 true。还有其它的实现方式么？有！我们可以拿 export 的 Value 来做文章，通过 export 的 Value，我们可以反射获取到导出对象的类型，通过类型我们就可以反射获取到是否有做什么特殊的 Attribute 标记，可能说得不是很清晰，那么下面这段代码是另外一种选择：
protected virtual Export GetAopExportCore(Export export)
{
var aopEnabledAttr = export.Value.GetType().GetCustomAttributes(typeof(AopEnabledAttribute), true);
if (aopEnabledAttr == null || aopEnabledAttr.Length == 0) return export; return new Export(export.Definition, () => Aop.ProxyGenerator.CreateProxy(this, export.Value));
}
相比这两种实现，我推荐使用元数据实现的方式，原因很简单，因为少去了一次反射消耗，毕竟在当前代码块里，元数据是已经完成解析了的，不用也是浪费。为了方便后续的使用，我们自定义两种带元数据导出的 ExportAttribute：
AOPExportAttribute：
/// <summary>
/// 支持 AOP 的导出
/// </summary>
[MetadataAttribute]
[AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
public class AOPExportAttribute : ExportAttribute
{
#region ctor public AOPExportAttribute() : base() { this.AOPEnabled = true; } public AOPExportAttribute(string contractName) : base(contractName) { this.AOPEnabled = true; }
public AOPExportAttribute(Type contractType) : base(contractType) { this.AOPEnabled = true; }
public AOPExportAttribute(string contractName, Type contractType) : base(contractName, contractType) { this.AOPEnabled = true; } #endregion /// <summary>
/// 是否启用 AOP
/// </summary>
[DefaultValue(true)]
public bool AOPEnabled { get; set; } }
InheritedAOPExportAttribute：
/// <summary>
/// 支持 AOP 的导出，且子类也继承该设定
/// </summary>
[MetadataAttribute]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = false, Inherited = true)]
public class InheritedAOPExportAttribute : InheritedExportAttribute
{
#region ctor public InheritedAOPExportAttribute() : base() { this.AOPEnabled = true; }
public InheritedAOPExportAttribute(string contractName) : base(contractName) { this.AOPEnabled = true; }
public InheritedAOPExportAttribute(Type contractType) : base(contractType) { this.AOPEnabled = true; }
public InheritedAOPExportAttribute(string contractName, Type contractType) : base(contractName, contractType) { this.AOPEnabled = true; } #endregion /// <summary>
/// 是否启用 AOP
/// </summary>
[DefaultValue(true)]
public bool AOPEnabled { get; set; }
}
这两段实现都很简单，只是作为 ExportAttribute 、 InheritedExportAttribute 的 AOP 替代版本。
简单的 AOP 框架实现
在上面我们扩展 MEF 时，有使用到 ProxyGenerator 来创建代理，这便是我们 AOP 最核心的部分，你完全可以使用其它第三方AOP框架来实现这个 ProxyGenerator ，但这里我选择自己通过 Emit 来实现一个简单的 AOP 框架。主要是为了学习，也不想引入太多太复杂的框架，简单实用才是最好的，实现上有借鉴 Castle ，当然，我不可能比它做得更好。
首先我们仿照Caslte，定义如下一个拦截器的公共接口：
/// <summary>
/// 拦截器
/// </summary>
public interface IInterceptor
{
/// <summary>
/// 执行拦截方法
/// </summary>
/// <param name="invocation">拦截的一些上下文信息</param>
void Intercept(IInvocation invocation); /// <summary>
/// 拦截器的执行顺序
/// </summary>
int Order { get; } }
即，我们所有的切面代码，都是在 Intercept 这里执行， Intercept 会提供执行时的一些上下文信息，即 IInvocation ：
/// <summary>
/// 拦截时的一些信息
/// </summary>
public interface IInvocation
{
/// <summary>
/// 获取拦截方法的参数列表
/// </summary>
object[] Arguments { get; } /// <summary>
/// 获取拦截方法的泛型参数
/// </summary>
Type[] GenericArguments { get; } /// <summary>
/// 获取拦截方法的信息
/// </summary>
MethodInfo Method { get; } /// <summary>
/// 获取代理对象
/// </summary>
object Proxy { get; } /// <summary>
/// 被创建成代理的对象，即原始对象
/// </summary>
object Target { get; } /// <summary>
/// 获取或设定返回值
/// </summary>
object ReturnValue { get; set; } /// <summary>
/// 获取目标类型，即被拦截的类型（非代理类型）
/// </summary>
Type TargetType { get; } /// <summary>
/// 获取指定所以的参数值
/// </summary>
/// <param name="index">参数索引</param>
/// <returns>返回指定的参数值，或者抛出异常</returns>
/// <exception cref="IndexOutOfRangeException">IndexOutOfRangeException</exception>
object GetArgumentValue(int index); /// <summary>
/// 设定指定索引的参数值
/// </summary>
/// <param name="index">参数索引</param>
/// <param name="value">要设定的值</param>
/// <exception cref="IndexOutOfRangeException">IndexOutOfRangeException</exception>
void SetArgumentValue(int index, object value); /// <summary>
/// 执行下一个拦截器，如果没有拦截器了，则执行被拦截的方法
/// </summary>
void Proceed();
}
具体方法的作用，熟悉 Castle 的应该都很清楚，我这里做了些许简化，即便你不熟悉，我的注释也写得很清晰。需要特别注意的是 Proceed 这个方法，如果在某一个拦截器中未执行该方法，则目标方法就不会得到调用，如果该目标方法有返回值，而目前的 ReturnValue 为 null 的话，则会抛出异常。
有了这两个核心接口定以后，我们就应该考虑代理是如何来实现了，在我们使用 Emit 来构建代理的时候，我推荐的做法是先用 C# 代码手动写出这样一个代理，然后通过反编译工具（ILDasm、ILSpy 等）反编译成 MSIL 后，对照着用 Emit 来实现。那么我们先手动写一个代理：
目标类（Target Class）：
class Target
{
public virtual void Method(string a, bool b)
{
}
}
代理类（Proxy Class）：
class Proxy : Target
{
private Target _target;
private IInterceptor[] _interceptors; public Proxy(Target target, IInterceptor[] interceptors)
{
_target = target;
_interceptors = interceptors;
} public override void Method(string a, bool b)
{
object[] arguments = new object[] { a, b };
Type[] argumentTypes = new Type[] { a.GetType(), b.GetType() };
MethodInfo method = ReflectionHelper.GetMethod(_target.GetType(), "Method", argumentTypes, false); var invocation = new Invocation(_target, this, method, arguments, _interceptors); invocation.Proceed();
}
}
代理类大体就如上面，可以看出使用的是对象代理，但在实际的 Emit 中也有些不同，我们还需要注意返回值和泛型等问题。值得一提的是，我们为了方便 Emit，所以故意将很多代码写得很朴实，这样在反编译参照时才有价值。在这里，我们将方法的最终调用都放给 Invocation 的 Proceed 去处理了（如果放在代理里面，Emit 起来太复杂），Invocation 的实现如下：
public class Invocation : IInvocation
{
private object _target;
private object _proxy;
private MethodInfo _method; private List<object> _arguments; private Queue<Action<IInvocation>> _invokeQuery; public Invocation(object target, object proxy, MethodInfo method, object[] arguments, IInterceptor[] interceptors)
{
_target = target;
_proxy = proxy;
_method = method; _arguments = new List<object>(arguments); _invokeQuery = new Queue<Action<IInvocation>>();
foreach (var item in interceptors)
_invokeQuery.Enqueue(x => item.Intercept(x)); _invokeQuery.Enqueue(x => x.ReturnValue = Method.Invoke(Target, Arguments)); } public object[] Arguments
{
get { return _arguments.ToArray(); }
} public Type[] GenericArguments
{
get { return _method.GetGenericArguments(); }
} public MethodInfo Method
{
get { return _method; }
} public object Proxy
{
get { return _proxy; }
} public object Target
{
get { return _target; }
} public object ReturnValue { get; set; } public Type TargetType
{
get { return _target.GetType(); }
} public object GetArgumentValue(int index)
{
return _arguments[index];
} public void SetArgumentValue(int index, object value)
{
_arguments[index] = value;
} public void Proceed()
{
if (_invokeQuery.Count > 0)
_invokeQuery.Dequeue().Invoke(this);
} }
我们将所有 IInterceptor 中的 Intercept 方法包装成 Action<IInvocation> 按顺序存放到一个队列里面了，并将目标方法的调用放到了队列最后。在 Proceed 方法里，我们出队，并对方法进行了调用，所以，只要有一个拦截器未对 Proceed 进行调用，那么我们就无法执行到目标方法。针对这样的一个设计，我们的代理类就变得比较简单，这也方便我们使用 Emit 来构建，毕竟用 Emit 来构建复杂逻辑还是很繁琐的。
那么现在就来揭开 ProxyGenerator 这个静态类的神秘面纱吧，首先是 CreateProxy 方法：
/// <summary>
/// 创建对象的代理
/// </summary>
/// <param name="obj">要创建代理的对象</param>
/// <returns>创建完成的代理</returns>
public static object CreateProxy(AOPCompositionContainer container, object obj)
{
var attrs = obj.GetType().GetCustomAttributes(typeof(IInterceptor), true); if (attrs == null || attrs.Length == 0) return obj; var interceptors = attrs.Select(x => { container.ComposeParts(x); return (IInterceptor)x; })
.OrderBy(x => x.Order)
.ToArray(); return CreateProxy(obj, interceptors);
}
通过代码，我们很容易就看出来，IInterceptor 最终是以 CustomAttribute 的形式标记在需要拦截的类上的，并且我们对获取到的 IInterceptor 还做了一次 ComposeParts ，这样一来，我们可以在实现 IInterceptor 时使用 Import 来导入依赖。接下来，我们再看该方法的一个内部重载版本，即该方法最后 return 的那个调用：
private static object CreateProxy(object target, IInterceptor[] interceptors)
{
var targetType = target.GetType(); if (!_proxyTypeCache.ContainsKey(targetType))
_proxyTypeCache[targetType] = GenerateProxyType(targetType); return Activator.CreateInstance(_proxyTypeCache[targetType], target, interceptors);
}
_proxyTypeCache是一个简单 ConcurrentDictionary<Type, Type> 用来做代理类型的缓存，这样不必每次都去 Emit 一个代理类型，所以，核心的 Emit 部分都在 GenerateProxyType 这个方法里了：
/// <summary>
/// 根据目标类型，生成代理类型
/// </summary>
/// <param name="targetType"></param>
/// <returns></returns>
private static Type GenerateProxyType(Type targetType)
{
var assemblyName = new AssemblyName("System.ComponentModel.Composition.Aop.Proxies");
#if DEBUG
var assemblyDef = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.RunAndSave);
var moduleDef = assemblyDef.DefineDynamicModule(assemblyName.Name, "System.ComponentModel.Composition.Aop.Proxies.dll");
#else var assemblyDef = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
var moduleDef = assemblyDef.DefineDynamicModule(assemblyName.Name);
#endif // 继承至 targetType 的一个代理类型
var typeDef = moduleDef.DefineType(targetType.FullName + "__Proxy", TypeAttributes.Public, targetType); var context = new EmitContext(targetType, typeDef); EmitProxyTypeCustomeAttributes(context);
EmitProxyTypeFields(context);
EmitProxyTypeConstructor(context); var targetMethods = targetType.GetMethods(); foreach (var method in targetMethods)
{
if (method.IsFinal) continue;
if (!method.IsVirtual && !method.IsAbstract) continue;
if (method.Name == "ToString") continue;
if (method.Name == "GetHashCode") continue;
if (method.Name == "Equals") continue; EmitProxyTypeMethod(context, method);
} var result = typeDef.CreateType();
#if DEBUG
assemblyDef.Save("System.ComponentModel.Composition.Aop.Proxies.dll");
#endif
return result;
}
对于 Emit 或则 MSIL 不熟悉的同学，推荐去看这一篇博文，上面的方法里，我们加了一个预编译指令，这是为了方便调试，在 Debug 模式下会把 Emit 生成的程序集保存到文件，这样可以使用反编译工具查看是否构建的是自己所期望的。上面代码里，在构建代理的时候，主要是这样几个步骤：
- 创建代理类型
- 设定代理类型的 CustomAttribute
- 构建代理类型的成员字段
- 构建代理类型的构造函数
- 构建代理方法
值得一提的是，在 Emit 的过程中，为了方便参数和构建结果的传递，我们还是简单的定义了一个 EmitContext 类：
class EmitContext
{
public EmitContext(Type baseType, TypeBuilder typeBuilder)
{
this.BaseType = baseType;
this.TypeBuilder = typeBuilder;
} public Type BaseType { get; protected set; } public TypeBuilder TypeBuilder { get; protected set; } private readonly Dictionary<string, FieldBuilder> _fields = new Dictionary<string, FieldBuilder>(); public Dictionary<string, FieldBuilder> FieldBuilders { get { return _fields; } } }
设定代理类型的 CustomAttribute：
private static void EmitProxyTypeCustomeAttributes(EmitContext context)
{
var constructorInfo = typeof(System.ComponentModel.Composition.PartNotDiscoverableAttribute)
.GetConstructor(Type.EmptyTypes); var customAttributeBuilder = new CustomAttributeBuilder(constructorInfo, new object[] { }); // 设置 PartNotDiscoverableAttribute， 使得代理不会被 MEF 找到
context.TypeBuilder.SetCustomAttribute(customAttributeBuilder); }
构建代理类型的成员字段：
private static void EmitProxyTypeFields(EmitContext context)
{
context.FieldBuilders["__obj"] = context.TypeBuilder.DefineField("__obj", typeof(object), FieldAttributes.Private);
context.FieldBuilders["__interceptors"] = context.TypeBuilder.DefineField("__interceptors", typeof(IInterceptor[]), FieldAttributes.Private);
}
我们将构建好的字段，存进了 EmitContext ，因为后面我们赋值和取值时会用到。
构建代理类型的构造函数：
private static void EmitProxyTypeConstructor(EmitContext context)
{
var ctorDef = context.TypeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard,
new Type[] { context.BaseType, typeof(IInterceptor[]) }); var il = ctorDef.GetILGenerator(); il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Call, context.BaseType.GetConstructor(Type.EmptyTypes));
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Stfld, context.FieldBuilders["__obj"]);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_2);
il.Emit(OpCodes.Stfld, context.FieldBuilders["__interceptors"]); il.Emit(OpCodes.Ret);
}
在构造函数里，我们对成员字段进行了赋值操作，即把构造函数的参数，赋值给了相应的成员变量。
构建代理方法：
private static readonly Type VoidType = Type.GetType("System.Void");
// Emit 拦截的方法，必须为 virtual 或 abstract
private static void EmitProxyTypeMethod(EmitContext context, MethodInfo method)
{
var parameterInfos = method.GetParameters();
var parameterTypes = parameterInfos.Select(p => p.ParameterType).ToArray();
var parameterLength = parameterTypes.Length;
var hasResult = method.ReturnType != VoidType;
var methodBuilder = context.TypeBuilder.DefineMethod(method.Name,
MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.Virtual,
method.ReturnType, parameterTypes);
if (method.IsGenericMethod)
{
// 简单支持泛型，未配置泛型约束
methodBuilder.DefineGenericParameters(method.GetGenericArguments().Select(x => x.Name).ToArray());
}
var il = methodBuilder.GetILGenerator();
il.DeclareLocal(typeof(object[])); // arguments
il.DeclareLocal(typeof(Type[])); // argumentTypes
il.DeclareLocal(typeof(MethodInfo)); // method
il.DeclareLocal(typeof(Invocation)); // invocation
if (method.IsGenericMethod) // 定义泛型参数的实际类型
{
il.DeclareLocal(typeof(Type[])); // genericTypes
var genericArguments = methodBuilder.GetGenericArguments();
il.Emit(OpCodes.Ldc_I4, genericArguments.Length);
il.Emit(OpCodes.Newarr, typeof(Type));
il.Emit(OpCodes.Stloc_S, 4);
for (int i = 0; i < genericArguments.Length; i++)
{
il.Emit(OpCodes.Ldloc_S, 4);
il.Emit(OpCodes.Ldc_I4, i);
il.Emit(OpCodes.Ldtoken, genericArguments[i]);
il.Emit(OpCodes.Call, typeof(Type).GetMethod("GetTypeFromHandle", new Type[] { typeof(RuntimeTypeHandle) }));
il.Emit(OpCodes.Stelem_Ref);
}
}
// arguments = new object[parameterLength]
il.Emit(OpCodes.Ldc_I4, parameterLength);
il.Emit(OpCodes.Newarr, typeof(object));
il.Emit(OpCodes.Stloc_0);
//argumentTypes = new Type[parameterLength]
il.Emit(OpCodes.Ldc_I4, parameterLength);
il.Emit(OpCodes.Newarr, typeof(Type));
il.Emit(OpCodes.Stloc_1);
for (int i = 0; i < parameterLength; i++)
{
// arguments[i] = arg[i]
il.Emit(OpCodes.Ldloc_0);
il.Emit(OpCodes.Ldc_I4, i);
il.Emit(OpCodes.Ldarg, i + 1); // arg[0] == this
if (parameterTypes[i].IsValueType || parameterTypes[i].IsGenericParameter)
il.Emit(OpCodes.Box, parameterTypes[i]);
il.Emit(OpCodes.Stelem_Ref);
// argumentTypes[i] = arg[i].GetType()
il.Emit(OpCodes.Ldloc_1);
il.Emit(OpCodes.Ldc_I4, i);
il.Emit(OpCodes.Ldarg, i + 1); // arg[0] == this
if (parameterTypes[i].IsValueType || parameterTypes[i].IsGenericParameter)
il.Emit(OpCodes.Box, parameterTypes[i]);
il.Emit(OpCodes.Callvirt, typeof(object).GetMethod("GetType"));
il.Emit(OpCodes.Stelem_Ref);
}
// method = ReflectionHelper.GetMethod(this.__obj.GetType(), "TestMethod", array2, true);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, context.FieldBuilders["__obj"]);
il.Emit(OpCodes.Callvirt, context.BaseType.GetMethod("GetType"));
il.Emit(OpCodes.Ldstr, method.Name);
il.Emit(OpCodes.Ldloc_1);
if (method.IsGenericMethod)
il.Emit(OpCodes.Ldc_I4_1);
else
il.Emit(OpCodes.Ldc_I4_0);
il.Emit(OpCodes.Call, typeof(ReflectionHelper).GetMethod("GetMethod"));
if (method.IsGenericMethod)
{
il.Emit(OpCodes.Ldloc_S, 4);
il.Emit(OpCodes.Callvirt, typeof(MethodInfo).GetMethod("MakeGenericMethod"));
}
il.Emit(OpCodes.Stloc_2);
// invocation = new Invocation(_obj, this, method, arguments, _interceptors)
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, context.FieldBuilders["__obj"]);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldloc_2);
il.Emit(OpCodes.Ldloc_0);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, context.FieldBuilders["__interceptors"]);
il.Emit(OpCodes.Newobj, typeof(Invocation).GetConstructor(new Type[] { typeof(object), typeof(object), typeof(MethodInfo), typeof(object[]), typeof(IInterceptor[]) }));
il.Emit(OpCodes.Stloc_3);
// invocation.Proceed()
il.Emit(OpCodes.Ldloc_3);
il.Emit(OpCodes.Callvirt, typeof(Invocation).GetMethod("Proceed"));
// 返回值
if (hasResult)
{
il.Emit(OpCodes.Ldloc_3);
il.Emit(OpCodes.Callvirt, typeof(Invocation).GetMethod("get_ReturnValue"));
if (method.ReturnType.IsValueType || method.ReturnType.IsGenericParameter)
il.Emit(OpCodes.Unbox_Any, method.ReturnType);
}
il.Emit(OpCodes.Ret);
}
代理方法的构建是整个 AOP 的核心，也是相对复杂的地方，在 GenerateProxyType 方法里，我们对目标类的方法进行了一个过滤，找出了符合要求的方法再进行的 Emit 。这里需要注意的有几个地方：
泛型定义：
if (method.IsGenericMethod)
{
// 简单支持泛型，未配置泛型约束
methodBuilder.DefineGenericParameters(method.GetGenericArguments().Select(x => x.Name).ToArray());
}
获取泛型实际传入类型：
if (method.IsGenericMethod) // 定义泛型参数的实际类型
{
il.DeclareLocal(typeof(Type[])); // genericTypes var genericArguments = methodBuilder.GetGenericArguments(); il.Emit(OpCodes.Ldc_I4, genericArguments.Length);
il.Emit(OpCodes.Newarr, typeof(Type));
il.Emit(OpCodes.Stloc_S, 4); for (int i = 0; i < genericArguments.Length; i++)
{
il.Emit(OpCodes.Ldloc_S, 4);
il.Emit(OpCodes.Ldc_I4, i);
il.Emit(OpCodes.Ldtoken, genericArguments[i]);
il.Emit(OpCodes.Call, typeof(Type).GetMethod("GetTypeFromHandle", new Type[] { typeof(RuntimeTypeHandle) }));
il.Emit(OpCodes.Stelem_Ref);
}
}
泛型方法，返回的 MethodInfo 是经过 MakeGenericMethod 处理的（这样 Invocation 才可以正常调用）：
if (method.IsGenericMethod)
{
il.Emit(OpCodes.Ldloc_S, 4);
il.Emit(OpCodes.Callvirt, typeof(MethodInfo).GetMethod("MakeGenericMethod"));
}
返回值处理：
if (hasResult)
{
il.Emit(OpCodes.Ldloc_3);
il.Emit(OpCodes.Callvirt, typeof(Invocation).GetMethod("get_ReturnValue"));
if (method.ReturnType.IsValueType || method.ReturnType.IsGenericParameter)
il.Emit(OpCodes.Unbox_Any, method.ReturnType);
}
可以看出针对返回值的处理，值类型和泛型都会有个拆箱的过程。
为了方便后续的使用，我们定义一个基本的拦截器 Attribute ：
[AttributeUsage(AttributeTargets.Class, Inherited = true, AllowMultiple = true)]
public class InterceptorAttribute : Attribute, IInterceptor
{
/// <summary>
/// 拦截器类型
/// </summary>
public Type Type { get; set; } private IInterceptor _interceptor; public InterceptorAttribute() { }
public InterceptorAttribute(Type interceptorType)
{
this.Type = interceptorType;
} public virtual void Intercept(IInvocation invocation)
{
if (this.Type != null)
{
if (_interceptor == null)
_interceptor = Activator.CreateInstance(this.Type) as IInterceptor; _interceptor.Intercept(invocation);
}
} /// <summary>
/// 拦截器的执行顺序
/// </summary>
public virtual int Order { get; set; } }
这样一来，我们可以如下使用这个结合了 MEF 和 AOP 的微型框架了：
[Interceptor(typeof(MockInterceptor))]
public class MockTarget
{
public virtual string GetString(int a, bool b, string c)
{
return c;
} public virtual T Get<T>(T a)
{
return a;
} } public class MockInterceptor : IInterceptor
{
public void Intercept(IInvocation invocation)
{
if (invocation.Method.Name == "GetString")
invocation.ReturnValue = "Intercepted";
else
invocation.Proceed(); } public int Order
{
get { return 0; }
}
}
但我还是推荐你继承 InterceptorAttribute，重写 Intercept 方法来使用，因为这样我们可以使用 Import 特性，而上诉代码中的 MockInterceptor 里是无法使用的。具体的使用，我们看接下来的一节。
综合 AOP 示例分析
上面的文字里，我们讲了那么一大堆，又花费了些气力构建出了这样一个微型框架，框架并不强大，比如对泛型的支持并不完善，性能也不是最优，可我们应该要有的就是探索和不怕折腾的精神。在我们这个圈子里，没有所谓的天才，只有永远的苦才，越能吃苦的，得到和学会的才会越多。接下来，我便用这个框架，来实现一个非常简单的示例，示例项目的结构如下图：
这是一个控制台应用程序，Aspects 中存放的是所有切面代码，Models 存放的是模型， Repositories 存放的是仓储，Services 则是服务的存放路径。
AppContext 是一个全局的上下文信息，用来存放和应用程序生命周期相同的信息，这里存放的是用户名和用户所属角色：
/// <summary>
/// 当前整个应用的上下文
/// </summary>
sealed class AppContext
{
private static readonly AppContext _current = new AppContext();
public static AppContext Current { get { return _current; } } /// <summary>
/// 执行该应用的用户，登录用户
/// </summary>
public string User { get; set; } /// <summary>
/// 角色
/// </summary>
public string Role { get; set; } }
ServiceLocator 则是使用我们自定义的 Container 实现的一个服务定位器，用来获取服务的具体实现：
// 一个简单的 ServiceLocator
static class ServiceLocator
{
private static readonly AOPCompositionContainer _container;
static ServiceLocator()
{
var catalog = new AssemblyCatalog(typeof(ServiceLocator).Assembly);
_container = new AOPCompositionContainer(catalog);
} public static TService GetService<TService>()
{
return _container.GetExportedValue<TService>();
} public static IEnumerable<TService> GetServices<TService>()
{
return _container.GetExportedValues<TService>();
}
}
可以看出，我们只在当前的程序集里发现导出，这也是因为只是作为示例的原因。接下来，我们定义系统中可以使用的服务：
ILogService：
public interface ILogService
{
void Log(string log);
}
IAccountService：
public interface IAccountService
{
bool CreateUser(string username, string password); bool ExistsUser(string username); }
这些都是简单到不需要任何解释的东西，我就一笔带过了。
然后是定义模型：
public class User
{
public Guid Id { get; set; } public string Name { get; set; } public string Password { get; set; }
}
仓储 IUserRepository ：
public interface IUserRepository
{
bool Add(string username, string password); bool Exists(Func<User, bool> predicate);
}
再来看一下目前我们项目的整体结构：
现在我们先实现 Service :
LogServiceImpl：
[Export(typeof(ILogService))]
public class LogServiceImpl : ILogService
{
public void Log(string log)
{
var currentColor = Console.ForegroundColor;
Console.ForegroundColor = ConsoleColor.Green; Console.WriteLine("Log:");
Console.WriteLine(log);
Console.WriteLine(); Console.ForegroundColor = currentColor;
}
}
只是在控制台输入信息。
AccountServiceImpl：
[AOPExport(typeof(IAccountService))]
public class AccountServiceImpl : IAccountService
{
[Import]
protected IUserRepository UserRepository { get; set; } public virtual bool CreateUser(string username, string password)
{
if (string.IsNullOrWhiteSpace(username) || string.IsNullOrWhiteSpace(password))
throw new Exception("用户名或密码不可为空！"); if (ExistsUser(username))
throw new Exception("用户名已存在！"); return UserRepository.Add(username, password);
} public virtual bool ExistsUser(string username)
{
if (string.IsNullOrWhiteSpace(username))
throw new Exception("要检测的用户名不可为空！"); return UserRepository.Exists(x => x.Name == username);
}
}
注意：这里我们使用的是 AOPExport，方法定义为 virtual ，并且导入了 IUserRepository，在具体的方法里直接抛出了异常。
我们再实现仓储：
[AOPExport(typeof(IUserRepository))]
public class UserRepositoryImpl : IUserRepository
{ public virtual bool Add(string username, string password)
{
// ...
return true;
} public virtual bool Exists(Func<Models.User, bool> predicate)
{
var user = new Models.User()
{
Id = Guid.NewGuid(),
Name = "Sun.M",
Password = "123789"
}; return predicate.Invoke(user);
}
}
同样，我们使用了 AOPExport，方法也是定义成了 virtual，这些都是为了后面我们能够插入切面代码。现在我们的主要代码都已经写得差不多了，回顾下这些代码，其实很简单，我们定义了两个 Service，并在其中的一个 Service 中导入了一个 Repository ，依赖关系就是这么简单。那么我们来看看使用部分代码的定义吧：
class Program
{
static void Main(string[] args)
{
AppContext.Current.User = "Sun.M";
AppContext.Current.Role = "Admin"; var accoutService = ServiceLocator.GetService<Services.IAccountService>(); var createResult = accoutService.CreateUser("Sun.M", "1343434");
Console.WriteLine(createResult); // throw exception : 名称已存在 AppContext.Current.Role = "Other";
createResult = accoutService.CreateUser("M.K", "1343434");
Console.WriteLine(createResult); // throw exception : 没有权限 AppContext.Current.Role = "Admin";
createResult = accoutService.CreateUser("M.K", "1343434");
Console.WriteLine(createResult); // 添加成功 Console.ReadKey(); }
}
现在运行程序，会收到异常，并且程序无法继续执行。下面，我们就来使用 AOP 来处理几个非常常见的问题：异常、日志和权限。
异常处理：
[AttributeUsage(AttributeTargets.Class, Inherited = true, AllowMultiple = false)]
public class ExceptionInterceptorAttribute : InterceptorAttribute
{
public override void Intercept(IInvocation invocation)
{
try
{
invocation.Proceed();
}
catch (System.Exception ex)
{
var currentColor = Console.ForegroundColor;
Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine("Error:");
Console.WriteLine(ex.InnerException.Message);
Console.WriteLine(); Console.ForegroundColor = currentColor; if (invocation.Method.ReturnType != Type.GetType("System.Void"))
invocation.ReturnValue = CreateTypeDefaultValue(invocation.Method.ReturnType);
}
} private object CreateTypeDefaultValue(Type type)
{
if (type.IsValueType)
return Activator.CreateInstance(type); return null;
} }
注意这里对于返回值的处理，其实我们可以把这个返回默认值的功能，由 Invocation 自己去实现，这里就不作修改了，有兴趣的同学自己动手实践下吧。
日志处理：
[AttributeUsage(AttributeTargets.Class, Inherited = true, AllowMultiple = false)]
public class LogInterceptorAttribute : InterceptorAttribute
{
[Import]
protected ILogService LogService { get; set; } public override void Intercept(IInvocation invocation)
{
LogService.Log(string.Format("Method:{0} User:{1}", invocation.Method.Name, AppContext.Current.User)); invocation.Proceed(); if (invocation.ReturnValue != null)
LogService.Log(string.Format("Method:{0} ReturnValue:{1}", invocation.Method.Name, invocation.ReturnValue)); }
}
对于日志的处理，就比较简单了，但这里使用了 Import 特性，这是一个非常实用的功能。这里，我们记录下了方法调用的一些信息。
权限处理：
SecurityInterceptorAttribute：
[AttributeUsage(AttributeTargets.Class, Inherited = true, AllowMultiple = false)]
public class SecurityInterceptorAttribute : InterceptorAttribute
{
public override void Intercept(IInvocation invocation)
{ var securityAttrs = invocation.Method.GetCustomAttributes(typeof(SecurityAttribute), true);
if (securityAttrs == null || securityAttrs.Length == 0)
{
invocation.Proceed(); return;
} var requiredRoles = securityAttrs.Select(x => ((SecurityAttribute)x).Role); if (requiredRoles.Any(x => x == AppContext.Current.Role) == false)
{
throw new System.Exception(string.Format("对{0}的访问没有权限", invocation.Method.Name));
} invocation.Proceed(); } }
SecurityAttribute：
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, AllowMultiple = true)]
public class SecurityAttribute : Attribute
{
public SecurityAttribute(string role)
{
this.Role = role;
} public string Role { get; private set; }
}
对于权限的处理，我们多定义出了一个 Attribute ，用来标识那些方法是需要权限判定的，并且指定了判定条件，即 Role 。
现在我们定义好了这么些个拦截器（切面代码），具体使用也非常简单，我们在需要的地方标记上去即可：
AccountServiceImpl：
[LogInterceptor(Order = 0)]
[ExceptionInterceptor(Order = 1)]
[AOPExport(typeof(IAccountService))]
public class AccountServiceImpl : IAccountService
UserRepositoryImpl：
[SecurityInterceptor]
[AOPExport(typeof(IUserRepository))]
public class UserRepositoryImpl : IUserRepository
{ [Security("Admin")]
public virtual bool Add(string username, string password)
{
// ...
如此一来，我们的拦截器已经能正常工作了。上述代码中，定义了 UserRepositoryImpl 中的 Add 方法只能被 Role 为 Admin 的用户调用。这里需要注意的是拦截器的 Order ，对于异常拦截器而言，最好是越先执行越安全，而权限则最好放在所有拦截器执行完后再执行，具体原因不说大家也都明白。
最后我们看一下执行结果：
时候也不早了，这一篇就到这里吧！附上项目源码下载地址：请点击下载（访问密码：4728）