轻量级AOP框架-移植python的装饰器(Decorator)到C#(编码篇)

一. 前言

在《轻量级AOP框架-移植python的装饰器(Decorator)到C#(思考篇)》中，文章分析了Python中Decorator的原理以及C#移植的可行性，在本篇中，文章将继续探讨如何将这个想法实实在在的表现出来，因此本篇的目标是：一个初级但是可用的Decorator实现。

如果您对本文的基本思路存在疑惑，请先阅读思考篇。

二. 实现分析

上篇中，我们考虑实现一个Wrapper类来做到模仿Python的函数替换功能，然而，在实际使用中，如果靠人工书写，很显然是一个不切实际的想法，因此，框架的关键在于对被装饰方法的处理，当前，我们一般使用动态代理或者静态织入的方式进行该操作，然而，无论是哪种方法，关键点都在于对现有代码的“动态修改”（动态代理的修改在于运行时，静态织入的修改在于编译时）。

在本篇中，我们考虑一个动态代理的实现，具体的运作方式如下：

运行时采用框架中的工厂生成代理对象，即：调用框架中的工厂方法，传入欲生成对象类型。因此对象创建方式将发生改变：默认情况下，我们可能采用var testClass = new TestClass();的方式生成对象，在使用代理的情况下，必须强制使用var testClass = xxx.CreateInstanse<TestClass>();的方式生成对象。

框架工厂类获取到对象类型之后，检查对象是否为可继承对象，如果不是，则无法生成代理类，否则，进行下一步。

调用动态类生产引擎，生成TestClassWrapper类,并从TestClass继承。

采用一定的方式，重写TestClass中欲进行处理的方法，以满足上一篇中预设的结果

生成TestClassWrapper类实例并返回

三. 编码难点

在了解了具体的运作方式之后，我们可以分别考虑各个步骤的实现难点，第一和第二都不难，使用基本的反射即可实现，主要的问题在于3-5步，下面我们分别对这几步的实现进行编码难点分析。

对于第三步的类继承，很显然，这首先要具备一个条件，那就是原始类是可继承的，否则，也无从谈起TestClassWrapper的生成，如果满足条件，那么可以使用反射创建动态类。同时，在c#中，我们需要创建一个动态程序集来容纳这些动态类。

对于第四步，系统需要重写欲处理的方法，要达到这个目标，我们只能请出我们的终极大神MSIL了，在C#中，可以使用Emit的方式进行IL嵌入编程，虽然麻烦了点，但这总算也能高效的解决问题。

对于第五步，一般来说，可以调用Activator.CreateInstance方法来创建对象，然而，在本人的另一篇博客《探究.net对象的创建,质疑《再谈Activator.CreateInstance(Type type)方法创建对象和Expression Tree创建对象性能的比较》中，我们可以了解到Activator.CreateInstance并不是最高效的做法，因此，框架将考虑使用更高效的方式，如Emit或者ExpressionTree的方式生成委托并构造对象。

四. 具体编码

在编码前，为了方便快速的构造框架，个人将一些成熟的代码放入框架中，以提高效率，这部分代码主要有：FastReflection，可以通过Emit快速构造方法调用委托，CodeGenerator，Nbear框架中的一个IL编程帮助类，通过它可以让我们简化不少IL操作。

现在万事俱备，我们开始一步步的创造框架吧，首先定义DecoratorFilter接口，以方便扩展Attribute，同时，为了方便，我们也定义一个DecoratorContexe来取代上篇中的直接传入Wrapper方法的委托对象，DecoratorFilter接口定义如下：

public interface IDecoratorFilter {
Func<object, object[], object> Execute(DecoratorContext context);
}
其中的DecoratorContext类包含了欲封装方法的基本属性，其定义如下：
public sealed class DecoratorContext {
/// <summary>
/// 该方法通用调用委托
/// </summary>
public Func<object, object[], object> Invoker { get; private set; }

/// <summary>
/// this对象
/// </summary>
public object Instanse { get; private set; }

/// <summary>
/// 方法参数列表
/// </summary>
public object[] Parameters { get; private set; }

public DecoratorContext(Func<object, object[], object> invoker, object instanse, object[] parameters) {
Invoker = invoker;
Instanse = instanse;
Parameters = parameters;
}
}

然后需要完成的是DynamicTypeBuilder类，该类负责动态程序集，动态类型，动态方法的创建，具体实现如下：

internal class DynamicTypeBuilder {
//为动态程序集生成名称
private readonly string assemblyName = Guid.NewGuid().ToString();
//程序集主模块
private readonly string mainModuleName = "Main";

public AssemblyBuilder AssemblyBuilder { get; private set; }

public ModuleBuilder MainModuleBuilder { get; private set; }

public DynamicTypeBuilder() {
AssemblyName an = new AssemblyName(assemblyName);
//构造一个可运行的动态程序集对象
AssemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(an, AssemblyBuilderAccess.Run);
//为该程序集构造主模块
MainModuleBuilder = AssemblyBuilder.DefineDynamicModule(mainModuleName);
}

/// <summary>
/// 从Type类派生一个新的代理类
/// </summary>
/// <param name="type">基类</param>
/// <returns></returns>
public TypeBuilder CreateTypeBuilder(Type type) {
TypeBuilder typeBuilder = MainModuleBuilder.DefineType(type.Name + "_" + Guid.NewGuid().ToString(),
TypeAttributes.Class | TypeAttributes.Public,
type);
return typeBuilder;
}

/// <summary>
/// 根据给定的方法对象和类型对象构造CodeGenerator
/// </summary>
/// <param name="typeBuilder"></param>
/// <param name="method"></param>
/// <returns></returns>
public CodeGenerator CreateMethodCodeGenerator(TypeBuilder typeBuilder, MethodInfo method) {
CodeGenerator cg = new CodeGenerator(typeBuilder,
method.Name,
MethodAttributes.Virtual | MethodAttributes.Public | MethodAttributes.ReuseSlot | MethodAttributes.HideBySig,
CallingConventions.HasThis,
method.ReturnType,
method.GetParameters().Select(e => e.ParameterType).ToArray());
typeBuilder.DefineMethodOverride(cg.CurrentMethod, method);
return cg;
}
}

为了提高框架的运行效率，系统也构造一个简单的缓存系统，将缓存一些元数据，详细情况可以参考完整源文件。

最后考虑最麻烦的TypeFactory类，该类中，最重要的方法就是CreateType，它可以使说框架中最核心的部分了，通过该该方法，我们创建了一个新的Class，该Class中完成了Decorator的核心实现，下面给出该方法的实现，该类的完整实现也请参考源码。

public static Type CreateType(Type rawType) {
var typeBuilder = builder.CreateTypeBuilder(rawType);
MetaCacheItem metaCacheItem = MetaCache.Get(rawType);
MethodInfo getTypeMethodInfo = rawType.GetMethod("GetType");
foreach (var item in metaCacheItem.Methods) {
if (item.Method.IsVirtual && item.Filters != null && item.Filters.Length > 0) {
var cg = builder.CreateMethodCodeGenerator(typeBuilder, item.Method);
var parameters = item.Method.GetParameters();
var cmpLabel = cg.DefineLabel();
var loopLabel = cg.DefineLabel();
//Type type;
var typeLocal = cg.DeclareLocal(typeType);
//MethodInfo thisMethodInfo;
var thisMethodInfoLocal = cg.DeclareLocal(methodInfoType);
//Type[] typeParameters;
var typeParametersLocal = cg.DeclareLocal(typeArrayType);
//MetaCacheItem metaCacheItem;
var metaCacheItemLocal = cg.DeclareLocal(metaCacheItemType);
//MetaMethodInfo metaMethodInfo;
var metaMethodInfoLocal = cg.DeclareLocal(metaMethodInfoType);
//Func<object, object[], object> fun;
var funLocal = cg.DeclareLocal(genericInvokerType);
//object[] parameters;
var parametersLocal = cg.DeclareLocal(objectArrayType);
//IDecoratorFilter[] filters;
var filtersLocal = cg.DeclareLocal(iDecoratorFilterArrayType);
//IDecoratorFilter item;
var itemLocal = cg.DeclareLocal(iDecoratorFilterType);
//int num;
var numLocal = cg.DeclareLocal(int32Type);
//type = this.GetType();
//cg.Ldarg(0);
//cg.Call(getTypeMethodInfo);
cg.Ldtoken(rawType);
cg.Call(getTypeFromHandleMethodInfo);
cg.Stloc(typeLocal);
//typeParameters = new Type[] { xxx };
cg.NewArray(typeType, parameters.Length);
cg.Stloc(typeParametersLocal);
for (int i = 0; i < parameters.Length; i++) {
cg.Ldloc(typeParametersLocal);
cg.Ldc(i);
cg.Ldtoken(parameters[i].ParameterType);
cg.Call(getTypeFromHandleMethodInfo);
//cg.Ldarg(i + 1);
//cg.Call(getTypeMethodInfo);
cg.Stelem(typeType);
}
//thisMethodInfo = type.GetMethod("xxx", typeParameters);
cg.Ldloc(typeLocal);
cg.Ldstr(item.Method.Name);
cg.Ldloc(typeParametersLocal);
cg.Call(getMethodMethodInfo);
cg.Stloc(thisMethodInfoLocal);
//metaCacheItem = MetaCache.Get(type);
cg.Ldloc(typeLocal);
cg.Call(metaCacheGetMethodInfo);
cg.Stloc(metaCacheItemLocal);
//metaMethodInfo = TypeFactory.FindMetaMethodInfo(metaCacheItem.Methods, thisMethod);
cg.Ldloc(metaCacheItemLocal);
cg.Call(metaCacheItemMethodsGetMethodInfo);
cg.Ldloc(thisMethodInfoLocal);
cg.Call(findMetaMethodInfoMethodInfo);
cg.Stloc(metaMethodInfoLocal);
//fun = TypeFactory.CreateGenericInvoker(metaMethodInfo.Method);
cg.Ldloc(metaMethodInfoLocal);
cg.Call(metaMethodInfoMethodGetMethodInfo);
cg.Call(createGenericInvokerMethodInfo);
cg.Stloc(funLocal);
//parameters = new object[] { xxx };
cg.NewArray(objectType, parameters.Length);
cg.Stloc(parametersLocal);
for (int i = 0; i < parameters.Length; i++) {
cg.Ldloc(parametersLocal);
cg.Ldc(i);
cg.Ldarg(i + 1);
if (parameters[i].ParameterType.IsValueType) {
cg.Box(parameters[i].ParameterType);
}
cg.Stelem(typeType);
}
cg.Ldloc(metaMethodInfoLocal);
cg.Call(metaMethodInfoFiltersGetMethodInfo);
cg.Stloc(filtersLocal);
//开始循环
cg.Ldc(0);
cg.Stloc(numLocal);
cg.Br(cmpLabel);
cg.MarkLabel(loopLabel);
cg.Ldloc(filtersLocal);
cg.Ldloc(numLocal);
cg.Ldelem(iDecoratorFilterType);
cg.Stloc(itemLocal);
//loop
//item.Execute(new DecoratorContext(fun, this, parameters));
cg.Ldloc(itemLocal);
cg.Ldloc(funLocal);
cg.Ldarg(0);
cg.Ldloc(parametersLocal);
cg.New(decoratorContextConstructorInfo);
cg.Call(iDecoratorFilterExecuteMethodInfo);
cg.Stloc(funLocal);
//endloop
cg.Ldloc(numLocal);
cg.Ldc(1);
cg.Add();
cg.Stloc(numLocal);
cg.MarkLabel(cmpLabel);
cg.Ldloc(numLocal);
cg.Ldloc(filtersLocal);
cg.Ldlen();
cg.Blt(loopLabel);
//return (string)fun(this, parameters)
cg.Ldloc(funLocal);
cg.Ldarg(0);
cg.Ldloc(parametersLocal);
cg.Call(genericInvokeInvokerMethodInfo);
if (item.Method.ReturnType != voidType && item.Method.ReturnType != objectType) {
cg.ConvertValue(objectType, item.Method.ReturnType);
} else if (item.Method.ReturnType == voidType) {
cg.Pop();
}
cg.Ret();
}
}
return typeBuilder.CreateType();
}

将这部分IL翻译一下,如果我们定义了一个方法public virtual string Test(string p)，那么自动生成的方法大致会像下面一样。

public override string Test(string p) {
Type type = typeof(TestClass);
MethodInfo thisMethod = type.GetMethod("Test", new Type[] { typeof(string) });
MetaCacheItem metaCacheItem = MetaCache.Get(type);
MetaMethodInfo thisMetaMethod = metaCacheItem.Methods.FirstOrDefault(e => e.Method == thisMethod);
Func<object, object[], object> fun = TypeFactory.CreateGenericInvoker(thisMetaMethod.Method);
object[] parameters = new object[] { p };
foreach (var item in thisMetaMethod.Filters) {
DecoratorContext context = new DecoratorContext(fun, this, parameters);
fun = item.Execute(context);
}
return (string)fun(this, parameters);
}

五. 框架测试

首先测试功能，我们仍然以上篇中第一个Python代码为例，想办法达到一样的效果，准备的代码如下：

/// <summary>
/// 和@logger功能一致的LoggerAttribute实现
/// </summary>
public class LoggerAttribute : Attribute, IDecoratorFilter {
public string Name { get; private set; }

public LoggerAttribute(string name) {
Name = name;
}

#region IDecoratorFilter Members

public Func<object, object[], object> Execute(DecoratorContext context) {
return (instanse, parameters) => {
Console.WriteLine("User is {0}.", Name);
Console.WriteLine("Start Logging.");
var result = context.Invoker(instanse, parameters);
Console.WriteLine("End Logging.");
return result;
};
}

#endregion
}

/// <summary>
/// 和@debuger功能一致的DebuggerAttribute实现
/// </summary>
public class DebuggerAttribute : Attribute, IDecoratorFilter {
public string Name { get; private set; }

public DebuggerAttribute(string name) {
Name = name;
}

#region IDecoratorFilter Members

public Func<object, object[], object> Execute(DecoratorContext context) {
return (instanse, parameters) => {
Console.WriteLine("Debug {0}", Name);
Console.WriteLine("Start Debug.");
var result = context.Invoker(instanse, parameters);
Console.WriteLine("End Debug.");
return result;
};
}

#endregion
}

public class TestClass {
[Logger("Leven")]
[Debugger("test")]
public virtual string Test() {
Console.WriteLine("Method TestClass::Test() called.");
return "I am Result.";
}
}

测试代码很简单：

var instanse = TypeFactory.CreateInstanse<TestClass>();
Console.WriteLine(instanse.Test());

运行结果如下图所示：





执行得到和Python代码完全一致的结果，至此，框架的功能实现完毕。

接下来用CodeTimer对框架的性能做个简单的测试,分别对比无代理方法,动态代理方法,手动继承方法的执行效率进行测试,测试代码如下:

var instanse = TypeFactory.CreateInstanse<TestClass>();
TestClass rawInstanse = new TestClass();
TestClassStatic staticInstanse = new TestClassStatic();

//first call
rawInstanse.Test2();
instanse.Test2();
staticInstanse.Test2();

CodeTimer.Initialize();
int num = 10000;
CodeTimer.Time("Raw Type", num, () => {
rawInstanse.Test2();
});
CodeTimer.Time("Proxy Type", num, () => {
instanse.Test2();
});
CodeTimer.Time("Static Type", num, () => {
staticInstanse.Test2();
});

看到结果很是让人始料不及,代理方法和手写方法执行速度一致倒是在预料之中,毕竟IL是完全一样的,但是有Decorator和无Decorator的效率差距实在无法让人接受，很显然，我们代理方法的实现效率上无法过关，因此，本框架虽然功能上已经达到要求，但是性能上还有很大的优化空间。

六. 本篇小结

在本篇中，我们完成了框架的基本设计，让框架成功的实现了我们的功能目标，但是，通过测试表明，框架的性能还远不能达到我们的要求，因此，在下一篇中（暂定名：优化篇），我们将详细分析框架的性能瓶颈并进行优化，使得本框架达到简单高效的结果。

最后提供目前框架的全部源码下载(引用其他源码的版权归原作者所有)