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

核心提示： 为了提高框架的运行效率，系统也构造一个简单的缓存系统，轻量级AOP框架-移植python的装饰器(Decorator)到C#(编码篇)(4)，将缓存一些元数据，详细情况可以参考完整源文件，该Class中完成了Decorator的核心实现，下面给出该方法的实现，最后考虑最麻烦的TypeFactor

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

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

001　public　static　Type　CreateType(Type　rawType)　{
002　　　　　var　typeBuilder　=　builder.CreateTypeBuilder(rawType);
003　　　　　MetaCacheItem　metaCacheItem　=　MetaCache.Get(rawType);
004　　　　　MethodInfo　getTypeMethodInfo　=　rawType.GetMethod("GetType");
005　　　　　foreach　(var　item　in　metaCacheItem.Methods)　{
006　　　　　　　　　if　(item.Method.IsVirtual　&&　item.Filters　!=　null　&&　item.Filters.Length　>　0)　{
007　　　　　　　　　　　　　var　cg　=　builder.CreateMethodCodeGenerator(typeBuilder,　item.Method);
008　　　　　　　　　　　　　var　parameters　=　item.Method.GetParameters();
009　　　　　　　　　　　　　var　cmpLabel　=　cg.DefineLabel();
010　　　　　　　　　　　　　var　loopLabel　=　cg.DefineLabel();
011　　　　　　　　　　　　　//Type　type;
012　　　　　　　　　　　　　var　typeLocal　=　cg.DeclareLocal(typeType);
013　　　　　　　　　　　　　//MethodInfo　thisMethodInfo;
014　　　　　　　　　　　　　var　thisMethodInfoLocal　=　cg.DeclareLocal(methodInfoType);
015　　　　　　　　　　　　　//Type[]　typeParameters;
016　　　　　　　　　　　　　var　typeParametersLocal　=　cg.DeclareLocal(typeArrayType);
017　　　　　　　　　　　　　//MetaCacheItem　metaCacheItem;
018　　　　　　　　　　　　　var　metaCacheItemLocal　=　cg.DeclareLocal(metaCacheItemType);
019　　　　　　　　　　　　　//MetaMethodInfo　metaMethodInfo;
020　　　　　　　　　　　　　var　metaMethodInfoLocal　=　cg.DeclareLocal(metaMethodInfoType);
021　　　　　　　　　　　　　//Func<object,　object[],　object>　fun;
022　　　　　　　　　　　　　var　funLocal　=　cg.DeclareLocal(genericInvokerType);
023　　　　　　　　　　　　　//object[]　parameters;
024　　　　　　　　　　　　　var　parametersLocal　=　cg.DeclareLocal(objectArrayType);
025　　　　　　　　　　　　　//IDecoratorFilter[]　filters;
026　　　　　　　　　　　　　var　filtersLocal　=　cg.DeclareLocal(iDecoratorFilterArrayType);
027　　　　　　　　　　　　　//IDecoratorFilter　item;
028　　　　　　　　　　　　　var　itemLocal　=　cg.DeclareLocal(iDecoratorFilterType);
029　　　　　　　　　　　　　//int　num;
030　　　　　　　　　　　　　var　numLocal　=　cg.DeclareLocal(int32Type);
031　　　　　　　　　　　　　//type　=　this.GetType();
032　　　　　　　　　　　　　//cg.Ldarg(0);
033　　　　　　　　　　　　　//cg.Call(getTypeMethodInfo);
034　　　　　　　　　　　　　cg.Ldtoken(rawType);
035　　　　　　　　　　　　　cg.Call(getTypeFromHandleMethodInfo);
036　　　　　　　　　　　　　cg.Stloc(typeLocal);
037　　　　　　　　　　　　　//typeParameters　=　new　Type[]　{　xxx　};
038　　　　　　　　　　　　　cg.NewArray(typeType,　parameters.Length);
039　　　　　　　　　　　　　cg.Stloc(typeParametersLocal);
040　　　　　　　　　　　　　for　(int　i　=　0;　i　<　parameters.Length;　i++)　{
041　　　　　　　　　　　　　　　　　cg.Ldloc(typeParametersLocal);
042　　　　　　　　　　　　　　　　　cg.Ldc(i);
043　　　　　　　　　　　　　　　　　cg.Ldtoken(parameters[i].ParameterType);
044　　　　　　　　　　　　　　　　　cg.Call(getTypeFromHandleMethodInfo);
045　　　　　　　　　　　　　　　　　//cg.Ldarg(i　+　1);
046　　　　　　　　　　　　　　　　　//cg.Call(getTypeMethodInfo);
047　　　　　　　　　　　　　　　　　cg.Stelem(typeType);
048　　　　　　　　　　　　　}
049　　　　　　　　　　　　　//thisMethodInfo　=　type.GetMethod("xxx",　typeParameters);
050　　　　　　　　　　　　　cg.Ldloc(typeLocal);
051　　　　　　　　　　　　　cg.Ldstr(item.Method.Name);
052　　　　　　　　　　　　　cg.Ldloc(typeParametersLocal);
053　　　　　　　　　　　　　cg.Call(getMethodMethodInfo);
054　　　　　　　　　　　　　cg.Stloc(thisMethodInfoLocal);
055　　　　　　　　　　　　　//metaCacheItem　=　MetaCache.Get(type);
056　　　　　　　　　　　　　cg.Ldloc(typeLocal);
057　　　　　　　　　　　　　cg.Call(metaCacheGetMethodInfo);
058　　　　　　　　　　　　　cg.Stloc(metaCacheItemLocal);
059　　　　　　　　　　　　　//metaMethodInfo　=　TypeFactory.FindMetaMethodInfo(metaCacheItem.Methods,　thisMethod);
060　　　　　　　　　　　　　cg.Ldloc(metaCacheItemLocal);
061　　　　　　　　　　　　　cg.Call(metaCacheItemMethodsGetMethodInfo);
062　　　　　　　　　　　　　cg.Ldloc(thisMethodInfoLocal);
063　　　　　　　　　　　　　cg.Call(findMetaMethodInfoMethodInfo);
064　　　　　　　　　　　　　cg.Stloc(metaMethodInfoLocal);
065　　　　　　　　　　　　　//fun　=　TypeFactory.CreateGenericInvoker(metaMethodInfo.Method);
066　　　　　　　　　　　　　cg.Ldloc(metaMethodInfoLocal);
067　　　　　　　　　　　　　cg.Call(metaMethodInfoMethodGetMethodInfo);
068　　　　　　　　　　　　　cg.Call(createGenericInvokerMethodInfo);
069　　　　　　　　　　　　　cg.Stloc(funLocal);
070　　　　　　　　　　　　　//parameters　=　new　object[]　{　xxx　};
071　　　　　　　　　　　　　cg.NewArray(objectType,　parameters.Length);
072　　　　　　　　　　　　　cg.Stloc(parametersLocal);
073　　　　　　　　　　　　　for　(int　i　=　0;　i　<　parameters.Length;　i++)　{
074　　　　　　　　　　　　　　　　　cg.Ldloc(parametersLocal);
075　　　　　　　　　　　　　　　　　cg.Ldc(i);
076　　　　　　　　　　　　　　　　　cg.Ldarg(i　+　1);
077　　　　　　　　　　　　　　　　　if　(parameters[i].ParameterType.IsValueType)　{
078　　　　　　　　　　　　　　　　　　　　　cg.Box(parameters[i].ParameterType);
079　　　　　　　　　　　　　　　　　}
080　　　　　　　　　　　　　　　　　cg.Stelem(typeType);
081　　　　　　　　　　　　　}
082　　　　　　　　　　　　　cg.Ldloc(metaMethodInfoLocal);
083　　　　　　　　　　　　　cg.Call(metaMethodInfoFiltersGetMethodInfo);
084　　　　　　　　　　　　　cg.Stloc(filtersLocal);
085　　　　　　　　　　　　　//开始循环
086　　　　　　　　　　　　　cg.Ldc(0);
087　　　　　　　　　　　　　cg.Stloc(numLocal);
088　　　　　　　　　　　　　cg.Br(cmpLabel);
089　　　　　　　　　　　　　cg.MarkLabel(loopLabel);
090　　　　　　　　　　　　　cg.Ldloc(filtersLocal);
091　　　　　　　　　　　　　cg.Ldloc(numLocal);
092　　　　　　　　　　　　　cg.Ldelem(iDecoratorFilterType);
093　　　　　　　　　　　　　cg.Stloc(itemLocal);
094　　　　　　　　　　　　　//loop
095　　　　　　　　　　　　　//item.Execute(new　DecoratorContext(fun,　this,　parameters));
096　　　　　　　　　　　　　cg.Ldloc(itemLocal);
097　　　　　　　　　　　　　cg.Ldloc(funLocal);
098　　　　　　　　　　　　　cg.Ldarg(0);
099　　　　　　　　　　　　　cg.Ldloc(parametersLocal);
100　　　　　　　　　　　　　cg.New(decoratorContextConstructorInfo);
101　　　　　　　　　　　　　cg.Call(iDecoratorFilterExecuteMethodInfo);
102　　　　　　　　　　　　　cg.Stloc(funLocal);
103　　　　　　　　　　　　　//endloop
104　　　　　　　　　　　　　cg.Ldloc(numLocal);
105　　　　　　　　　　　　　cg.Ldc(1);
106　　　　　　　　　　　　　cg.Add();
107　　　　　　　　　　　　　cg.Stloc(numLocal);
108　　　　　　　　　　　　　cg.MarkLabel(cmpLabel);
109　　　　　　　　　　　　　cg.Ldloc(numLocal);
110　　　　　　　　　　　　　cg.Ldloc(filtersLocal);
111　　　　　　　　　　　　　cg.Ldlen();
112　　　　　　　　　　　　　cg.Blt(loopLabel);
113　　　　　　　　　　　　　//return　(string)fun(this,　parameters)
114　　　　　　　　　　　　　cg.Ldloc(funLocal);
115　　　　　　　　　　　　　cg.Ldarg(0);
116　　　　　　　　　　　　　cg.Ldloc(parametersLocal);
117　　　　　　　　　　　　　cg.Call(genericInvokeInvokerMethodInfo);
118　　　　　　　　　　　　　if　(item.Method.ReturnType　!=　voidType　&&　item.Method.ReturnType　!=　objectType)　{
119　　　　　　　　　　　　　　　　　cg.ConvertValue(objectType,　item.Method.ReturnType);
120　　　　　　　　　　　　　}　else　if　(item.Method.ReturnType　==　voidType)　{
121　　　　　　　　　　　　　　　　　cg.Pop();
122　　　　　　　　　　　　　}
123　　　　　　　　　　　　　cg.Ret();
124　　　　　　　　　}
125　　　　　}
126　　　　　return　typeBuilder.CreateType();
127　}