Nbear讲解 之核心类CodeGenerator
以下是CodeGenerator类用的一些辅助类：
Cmp比较类型
1 /// <summary> 2 /// Cmp 3 /// </summary> 4 public enum Cmp 5 { 6 /// <summary> 7 /// LessThan 8 /// </summary> 9 LessThan, 10 /// <summary> 11 /// EqualTo 12 /// </summary> 13 EqualTo, 14 /// <summary> 15 /// LessThanOrEqualTo 16 /// </summary> 17 LessThanOrEqualTo, 18 /// <summary> 19 /// GreaterThan 20 /// </summary> 21 GreaterThan, 22 /// <summary> 23 /// NotEqualTo 24 /// </summary> 25 NotEqualTo, 26 /// <summary> 27 /// GreaterThanOrEqualTo 28 /// </summary> 29 GreaterThanOrEqualTo 30 }
ArgBuilder方法参数定义
1 /// <summary> 2 /// ArgBuilder 3 /// </summary> 4 public class ArgBuilder 5 { 6 /// <summary> 7 /// ArgType 8 /// </summary> 9 public Type ArgType; 10 /// <summary> 11 /// Index 12 /// </summary> 13 public int Index; 14 15 /// <summary> 16 /// ArgBuilder 17 /// </summary> 18 /// <param name="index"></param> 19 /// <param name="argType"></param> 20 public ArgBuilder(int index, Type argType) 21 { 22 this.Index = index; 23 this.ArgType = argType; 24 } 25 }
IfState[If语句之状态]
1 /// <summary> 2 /// IfState 3 /// </summary> 4 public class IfState 5 { 6 // Fields 7 private Label elseBegin; 8 private Label endIf; 9 10 /// <summary> 11 /// ElseBegin 12 /// </summary> 13 public Label ElseBegin 14 { 15 get 16 { 17 return this.elseBegin; 18 } 19 set 20 { 21 this.elseBegin = value; 22 } 23 } 24 25 /// <summary> 26 /// EndIf 27 /// </summary> 28 public Label EndIf 29 { 30 get 31 { 32 return this.endIf; 33 } 34 set 35 { 36 this.endIf = value; 37 } 38 } 39 }
SwitchState[Switch语句之状态]
1 /// <summary> 2 /// SwitchState 3 /// </summary> 4 public class SwitchState 5 { 6 private bool defaultDefined; 7 private Label defaultLabel; 8 private Label endOfSwitchLabel; 9 10 /// <summary> 11 /// SwitchState 12 /// </summary> 13 /// <param name="defaultLabel"></param> 14 /// <param name="endOfSwitchLabel"></param> 15 public SwitchState(Label defaultLabel, Label endOfSwitchLabel) 16 { 17 this.defaultLabel = defaultLabel; 18 this.endOfSwitchLabel = endOfSwitchLabel; 19 this.defaultDefined = false; 20 } 21 22 /// <summary> 23 /// DefaultDefined 24 /// </summary> 25 public bool DefaultDefined 26 { 27 get 28 { 29 return this.defaultDefined; 30 } 31 set 32 { 33 this.defaultDefined = value; 34 } 35 } 36 37 /// <summary> 38 /// DefaultLabel 39 /// </summary> 40 public Label DefaultLabel 41 { 42 get 43 { 44 return this.defaultLabel; 45 } 46 } 47 48 /// <summary> 49 /// EndOfSwitchLabel 50 /// </summary> 51 public Label EndOfSwitchLabel 52 { 53 get 54 { 55 return this.endOfSwitchLabel; 56 } 57 } 58 }
ForState[For语句之状态]
1 /// <summary> 2 /// ForState 3 /// </summary> 4 public class ForState 5 { 6 // Fields 7 private Label beginLabel; 8 private object end; 9 private Label endLabel; 10 private LocalBuilder indexVar; 11 private bool requiresEndLabel; 12 private Label testLabel; 13 14 /// <summary> 15 /// ForState 16 /// </summary> 17 /// <param name="indexVar"></param> 18 /// <param name="beginLabel"></param> 19 /// <param name="testLabel"></param> 20 /// <param name="end"></param> 21 public ForState(LocalBuilder indexVar, Label beginLabel, Label testLabel, object end) 22 { 23 this.indexVar = indexVar; 24 this.beginLabel = beginLabel; 25 this.testLabel = testLabel; 26 this.end = end; 27 } 28 29 /// <summary> 30 /// BeginLabel 31 /// </summary> 32 public Label BeginLabel 33 { 34 get 35 { 36 return this.beginLabel; 37 } 38 } 39 40 /// <summary> 41 /// End 42 /// </summary> 43 public object End 44 { 45 get 46 { 47 return this.end; 48 } 49 } 50 51 /// <summary> 52 /// EndLabel 53 /// </summary> 54 public Label EndLabel 55 { 56 get 57 { 58 return this.endLabel; 59 } 60 set 61 { 62 this.endLabel = value; 63 } 64 } 65 66 /// <summary> 67 /// Index 68 /// </summary> 69 public LocalBuilder Index 70 { 71 get 72 { 73 return this.indexVar; 74 } 75 } 76 77 /// <summary> 78 /// RequiresEndLabel 79 /// </summary> 80 public bool RequiresEndLabel 81 { 82 get 83 { 84 return this.requiresEndLabel; 85 } 86 set 87 { 88 this.requiresEndLabel = value; 89 } 90 } 91 92 /// <summary> 93 /// TestLabel 94 /// </summary> 95 public Label TestLabel 96 { 97 get 98 { 99 return this.testLabel; 100 } 101 } 102 }
介绍一下 ILGenerator ：
其主要功能是：将指定的指令放到指令流上，构建方法体所用。
用于为动态程序集中的方法和构造函数（由 MethodBuilder 和 ConstructorBuilder 类表示）以及为独立动态方法（由 DynamicMethod 类表示）生成方法体。
若要获取 ILGenerator，请使用 ConstructorBuilder.GetILGenerator、DynamicMethod.GetILGenerator 和 MethodBuilder.GetILGenerator 方法。
字段主要分：方法体的环境变量,常用工具方法的MethodInfo
字段定义
1 private ILGenerator ilGen; 2 private Module serializationModule = typeof(CodeGenerator).Module; 3 4 5 //构建方法体主要的环境变量 6 private Type delegateType; 7 private DynamicMethod dynamicMethod; //当前类是通过委托,构建动态方法时用到 8 private MethodBase methodOrConstructorBuilder; //当前类使用第3个构造方法时用到 9 private Stack blockStack; 10 private ArrayList argList; 11 private Hashtable localNames; 12 private LocalBuilder stringFormatArray; 13 private Label methodEndLabel; 14 15 //常用工具方法 16 private static MethodInfo getTypeFromHandle; 17 private static MethodInfo objectEquals; 18 private static MethodInfo objectToString; 19 private static MethodInfo stringConcat2; 20 private static MethodInfo stringConcat3; 21 private static MethodInfo stringFormat;
常量加载
1 /// <summary> 2 /// Ldc 通过Ldc指令加载布尔值到计算堆栈 true 为 1,false 为0 3 /// </summary> 4 /// <param name="boolVar"></param> 5 public void Ldc(bool boolVar) 6 { 7 if (boolVar) 8 { 9 this.ilGen.Emit(OpCodes.Ldc_I4_1); 10 } 11 else 12 { 13 this.ilGen.Emit(OpCodes.Ldc_I4_0); 14 } 15 } 16 17 18 19 /// <summary> 20 /// Ldc 加载整型数值到计算堆栈 21 /// <list type=""> 22 /// ldc.i4.m1 (ldc.i4.M1) -1 23 /// ldc.i4.0 0 24 /// ... 25 /// ldc.i4.8 8 26 /// Ldc_I4 普通整数 27 /// </list> 28 /// </summary> 29 /// <param name="intVar"></param> 30 public void Ldc(int intVar) 31 { 32 switch (intVar) 33 { 34 case -1: 35 this.ilGen.Emit(OpCodes.Ldc_I4_M1); 36 return; 37 38 case 0: 39 this.ilGen.Emit(OpCodes.Ldc_I4_0); 40 return; 41 42 case 1: 43 this.ilGen.Emit(OpCodes.Ldc_I4_1); 44 return; 45 46 case 2: 47 this.ilGen.Emit(OpCodes.Ldc_I4_2); 48 return; 49 50 case 3: 51 this.ilGen.Emit(OpCodes.Ldc_I4_3); 52 return; 53 54 case 4: 55 this.ilGen.Emit(OpCodes.Ldc_I4_4); 56 return; 57 58 case 5: 59 this.ilGen.Emit(OpCodes.Ldc_I4_5); 60 return; 61 62 case 6: 63 this.ilGen.Emit(OpCodes.Ldc_I4_6); 64 return; 65 66 case 7: 67 this.ilGen.Emit(OpCodes.Ldc_I4_7); 68 return; 69 70 case 8: 71 this.ilGen.Emit(OpCodes.Ldc_I4_8); 72 return; 73 } 74 this.ilGen.Emit(OpCodes.Ldc_I4, intVar); 75 } 76 77 /// <summary> 78 /// Ldc 加载长整数到计算堆栈 对应指令 ldc.i8 79 /// </summary> 80 /// <param name="l">The l.</param> 81 public void Ldc(long l) 82 { 83 this.ilGen.Emit(OpCodes.Ldc_I8, l); 84 } 85 86 /// <summary> 87 /// Ldc 加载单精度浮点数到计算堆栈 88 /// </summary> 89 /// <param name="f"></param> 90 public void Ldc(float f) 91 { 92 this.ilGen.Emit(OpCodes.Ldc_R4, f); 93 } 94 95 /// <summary> 96 /// Ldc 加载双精度浮点数到计算堆栈 对应指令：Ldc_R8 97 /// </summary> 98 /// <param name="d"></param> 99 public void Ldc(double d) 100 { 101 this.ilGen.Emit(OpCodes.Ldc_R8, d); 102 } 103 104 /// <summary> 105 /// Ldc 传入一个未知类型对象，根据其类型，自动调用适合的指令来将它加载到计算堆栈 106 /// </summary> 107 /// <param name="o"></param> 108 public void Ldc(object o) 109 { 110 Type enumType = o.GetType(); 111 if (o is Type)//类型变量 112 { 113 //相当于 typeof(o); 114 this.Ldtoken((Type)o); 115 this.Call(GetTypeFromHandle); 116 } 117 else if (enumType.IsEnum) 118 { 119 //Enum.GetUnderlyingType(enumType):返回指定的枚举的基础类型,即枚举定义类型 120 //枚举类型转为 数值类型 121 this.Ldc(((IConvertible)o).ToType(Enum.GetUnderlyingType(enumType), null)); 122 } 123 else 124 { 125 switch (Type.GetTypeCode(enumType)) 126 { 127 case TypeCode.Boolean: 128 this.Ldc((bool)o); 129 return; 130 131 case TypeCode.Char: 132 //throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR.GetString("CharIsInvalidPrimitive"))); 133 134 case TypeCode.SByte: 135 case TypeCode.Byte: 136 case TypeCode.Int16: 137 case TypeCode.UInt16: 138 this.Ldc(((IConvertible)o).ToInt32(CultureInfo.InvariantCulture)); 139 return; 140 141 case TypeCode.Int32: 142 this.Ldc((int)o); 143 return; 144 145 case TypeCode.UInt32: 146 this.Ldc((int)((uint)o)); 147 return; 148 149 case TypeCode.Int64: 150 this.Ldc((long)o); 151 return; 152 153 case TypeCode.UInt64: 154 this.Ldc((long)((ulong)o)); 155 return; 156 157 case TypeCode.Single: 158 this.Ldc((float)o); 159 return; 160 161 case TypeCode.Double: 162 this.Ldc((double)o); 163 return; 164 165 case TypeCode.String: 166 this.Ldstr((string)o); 167 return; 168 } 169 throw new Exception("UnknownConstantType"); 170 } 171 }
局部变量定义
1 /// <summary> 2 /// DeclareLocal 3 /// </summary> 4 /// <param name="type"></param> 5 /// <returns></returns> 6 public LocalBuilder DeclareLocal(Type type) 7 { 8 Check.Require(type, "type"); 9 10 return this.DeclareLocal(type, null, false); 11 } 12 13 /// <summary> 14 /// DeclareLocal 15 /// </summary> 16 /// <param name="type"></param> 17 /// <param name="name"></param> 18 /// <returns></returns> 19 public LocalBuilder DeclareLocal(Type type, string name) 20 { 21 Check.Require(type, "type"); 22 23 return this.DeclareLocal(type, name, false); 24 } 25 26 /// <summary> 27 /// DeclareLocal 28 /// </summary> 29 /// <param name="type"></param> 30 /// <param name="name"></param> 31 /// <param name="isPinned"></param> 32 /// <returns></returns> 33 public LocalBuilder DeclareLocal(Type type, string name, bool isPinned) 34 { 35 Check.Require(type, "type"); 36 37 LocalBuilder builder = this.ilGen.DeclareLocal(type, isPinned); 38 return builder; 39 } 40 41 /// <summary> 42 /// DeclareLocal 43 /// </summary> 44 /// <param name="type"></param> 45 /// <param name="name"></param> 46 /// <param name="initialValue"></param> 47 /// <returns></returns> 48 public LocalBuilder DeclareLocal(Type type, string name, object initialValue) 49 { 50 Check.Require(type, "type"); 51 52 LocalBuilder var = this.DeclareLocal(type, name); 53 this.Load(initialValue); 54 this.Store(var); 55 return var; 56 }
变量:局部变量,参数变量,常量,静态变量。 分类:值类型,引用类型(属性值,数组)
变量存储
1 /// <summary> 2 /// Set: 3 /// </summary> 4 /// <param name="local"></param> 5 /// <param name="value"></param> 6 public void Set(LocalBuilder local, object value) 7 { 8 Check.Require(local, "local"); 9 10 this.Load(value); 11 this.Store(local); 12 } 13 14 /// <summary> 15 /// Starg 16 /// </summary> 17 /// <param name="slot"></param> 18 public void Starg(int slot) 19 { 20 if (slot <= 0xff) 21 { 22 this.ilGen.Emit(OpCodes.Starg_S, slot); 23 } 24 else 25 { 26 this.ilGen.Emit(OpCodes.Starg, slot); 27 } 28 } 29 30 /// <summary> 31 /// Starg 32 /// </summary> 33 /// <param name="arg"></param> 34 public void Starg(ArgBuilder arg) 35 { 36 Check.Require(arg, "arg"); 37 38 this.Starg(arg.Index); 39 } 40 41 /// <summary> 9 42 /// Stelem 43 /// </summary> 44 /// <param name="arrayElementType"></param> 45 public void Stelem(Type arrayElementType) 46 { 47 Check.Require(arrayElementType, "arrayElementType"); 48 49 if (arrayElementType.IsEnum) 50 { 51 this.Stelem(Enum.GetUnderlyingType(arrayElementType)); 52 } 53 else 54 { 55 OpCode opcode = this.GetStelemOpCode(Type.GetTypeCode(arrayElementType)); 56 if (opcode.Equals(OpCodes.Nop)) 57 { 58 throw new Exception("ArrayTypeIsNotSupported"); 59 } 60 this.ilGen.Emit(opcode); 61 } 62 } 63 64 /// <summary> 65 /// Stloc: 从计算堆栈的顶部弹出当前值并将其存储到指定索引处的局部变量列表中。 66 /// </summary> 67 /// <param name="slot"></param> 68 public void Stloc(int slot) 69 { 70 switch (slot) 71 { 72 case 0: 73 this.ilGen.Emit(OpCodes.Stloc_0); 74 return; 75 76 case 1: 77 this.ilGen.Emit(OpCodes.Stloc_1); 78 return; 79 80 case 2: 81 this.ilGen.Emit(OpCodes.Stloc_2); 82 return; 83 84 case 3: 85 this.ilGen.Emit(OpCodes.Stloc_3); 86 return; 87 } 88 if (slot <= 0xff) 89 { 90 this.ilGen.Emit(OpCodes.Stloc_S, slot); 91 } 92 else 93 { 94 this.ilGen.Emit(OpCodes.Stloc, slot); 95 } 96 } 97 98 /// <summary> 99 /// Stloc:从计算堆栈的顶部弹出当前值并将其存储到指定索引处的局部变量列表中。 100 /// 提示：LocalBuilder对象包含局部变量的索引跟类型 101 /// </summary> 102 /// <param name="local"></param> 103 public void Stloc(LocalBuilder local) 104 { 105 Check.Require(local, "local"); 106 107 this.ilGen.Emit(OpCodes.Stloc, local); 108 } 109 110 /// <summary> 111 /// Stobj:将指定类型的值从计算堆栈复制到所提供的内存地址中。 112 /// Pre1: 将地址推送到堆栈上。 113 /// Pre2: 将 class 类型的值类型对象推送到堆栈上。 114 /// TODO: 从堆栈中弹出对象和地址；将值类型对象存储在该地址。 115 /// 参考: http://msdn.microsoft.com/zh-cn/library/system.reflection.emit.opcodes.stobj.aspx 116 /// </summary> 117 /// <param name="type"></param> 118 public void Stobj(Type type) 119 { 120 Check.Require(type, "type"); 121 122 this.ilGen.Emit(OpCodes.Stobj, type); 123 } 124 125 /// <summary> 126 /// Store:保存参数变量或局部变量 127 /// </summary> 128 /// <param name="var"></param> 129 public void Store(object var) 130 { 131 if (var is ArgBuilder) 132 { 133 this.Starg((ArgBuilder)var); 134 } 135 else 136 { 137 if (!(var is LocalBuilder)) 138 { 139 throw new Exception("CanOnlyStoreIntoArgOrLocGot0"); 140 } 141 this.Stloc((LocalBuilder)var); 142 } 143 } 144 145 /// <summary> 146 /// StoreArrayElement 147 /// </summary> 148 /// <param name="obj">数组对象</param> 149 /// <param name="arrayIndex">数组索引</param> 150 /// <param name="value">保存的值</param> 151 152 public void StoreArrayElement(object obj, object arrayIndex, object value) 153 { 154 Type variableType = this.GetVariableType(obj); 155 Type objType = (variableType == typeof(Array)) ? typeof(object) : variableType.GetElementType(); 156 this.Load(obj); 157 this.Load(arrayIndex); 158 159 if (IsStruct(objType)) 160 { 161 //Pre1:将对象引用 array 推送到堆栈上。 162 //Pre2:将索引值 index 推送到堆栈上。 163 //Do1:从堆栈中弹出 index 和 array；查找存储在array中的位置index 处的地址。 164 //Do2:将地址推送到堆栈上。 165 this.Ldelema(objType); 166 } 167 168 this.Load(value); 169 this.ConvertValue(this.GetVariableType(value), objType); 170 171 172 if (IsStruct(objType)) 173 { //Pre1: 将地址推送到堆栈上。 174 //Pre2: 将 class 类型的值类型对象推送到堆栈上。 175 //ToDo: 从堆栈中弹出对象和地址；将值类型对象存储在该地址。 176 this.Stobj(objType); 177 } 178 else 179 { 180 //Pre1: 将对数组 array 的对象引用推送到堆栈上。 181 //Pre2: 将array 中元素的有效索引推送到堆栈上。 182 //Pre3：将值推送到堆栈上。 183 //ToDo: 从堆栈中弹出值、索引和数组引用；将值放入给定索引处的数组元素中。 184 this.Stelem(objType); 185 } 186 } 187 188 /// <summary> 189 /// StoreMember 用新值替换在对象引用或指针的字段中存储的值 190 /// Pre:value压入栈中 191 /// </summary> 192 /// <param name="memberInfo"></param> 193 public void StoreMember(MemberInfo memberInfo) 194 { 195 Check.Require(memberInfo, "memberInfo"); 196 197 if (memberInfo.MemberType == MemberTypes.Field) 198 { 199 FieldInfo field = (FieldInfo)memberInfo; 200 if (field.IsStatic) 201 { 202 this.ilGen.Emit(OpCodes.Stsfld, field); 203 } 204 else 205 { 206 this.ilGen.Emit(OpCodes.Stfld, field); 207 } 208 } 209 else if (memberInfo.MemberType == MemberTypes.Property) 210 { 211 PropertyInfo info2 = memberInfo as PropertyInfo; 212 if (info2 != null) 213 { 214 MethodInfo methodInfo = info2.GetSetMethod(true); 215 if (methodInfo == null) 216 { 217 throw new Exception("NoSetMethodForProperty"); 218 } 219 this.Call(methodInfo); 220 } 221 } 222 else 223 { 224 if (memberInfo.MemberType != MemberTypes.Method) 225 { 226 throw new Exception("CannotLoadMemberType"); 227 } 228 this.Call((MethodInfo)memberInfo); 229 } 230 }
变量加载
1 /// <summary> 2 /// LdargAddress 加载参数地址。IL没有这个指令，它根据参数的类型分别调用不同的IL指令： 3 /// 当参数为值类型时，通过调用Ldarga指令，加载参数地址 4 /// 当参不为值类型时，直接调用Ldarg加载参数 5 /// 推测:maybe, 引用类型的变量本身代表的就是其地址,而值类型变量代表的是值本身,故值类型需要取址. 6 /// </summary> 7 /// <param name="argBuilder"></param> 8 public void LdargAddress(ArgBuilder argBuilder) 9 { 10 Check.Require(argBuilder, "argBuilder"); 11 12 if (argBuilder.ArgType.IsValueType) 13 { 14 this.Ldarga(argBuilder); 15 } 16 else 17 { 18 this.Ldarg(argBuilder); 19 } 20 } 21 22 23 /// <summary> 24 /// Ldelem 根据传入的数组类型，自动选择不同的指令，将位于数组指定索引处的元素加到计算堆栈 25 /// 这些指令包括： 26 /// ldelem.i1 加载int8 27 /// ldelem.u1 unsigned int8. 28 /// ldelem.i2 int16 29 /// ldelem.u2 unsigned int16 30 /// ldelem.i4 int32 31 /// ldelem.i8 int64 32 /// ldelem.i native int 33 /// ldelem.r4 float32 34 /// ldelem.r8 float64 35 /// ldelem.ref reference type 36 /// </summary> 37 /// <param name="arrayElementType"></param> 38 public void Ldelem(Type arrayElementType) 39 { 40 Check.Require(arrayElementType, "arrayElementType"); 41 42 if (arrayElementType.IsEnum) 43 { 44 this.Ldelem(Enum.GetUnderlyingType(arrayElementType)); 45 } 46 else 47 { 48 OpCode opcode = this.GetLdelemOpCode(Type.GetTypeCode(arrayElementType)); 49 if (opcode.Equals(OpCodes.Nop)) 50 { 51 throw new Exception("ArrayTypeIsNotSupported"); 52 } 53 this.ilGen.Emit(opcode); 54 } 55 } 56 57 /// <summary> 58 /// Ldelema 将位于指定数组索引的数组元素的地址作为 & 类型（托管指针）加载到计算堆栈的顶部。 59 /// </summary> 60 /// <param name="arrayElementType"></param> 61 public void Ldelema(Type arrayElementType) 62 { 63 Check.Require(arrayElementType, "arrayElementType"); 64 65 OpCode opcode = OpCodes.Ldelema; 66 this.ilGen.Emit(opcode, arrayElementType); 67 } 68 69 /// <summary> 70 /// Ldlen 将从零开始的、一维数组的元素的数目推送到计算堆栈上。 71 /// </summary> 72 public void Ldlen() 73 { 74 // Pre: 将对数组的对象引用推送到堆栈上。 75 // ToDo1:从堆栈中弹出数组引用，并计算长度。 76 // ToDo2:将长度推送到堆栈上。 77 this.ilGen.Emit(OpCodes.Ldlen); 78 // Pre: value 被推送到堆栈上。 79 // ToDo1: 从堆栈中弹出 value，然后尝试执行转换操作。 80 // ToDo2: 如果转换成功，则将结果值推送到堆栈上。 81 this.ilGen.Emit(OpCodes.Conv_I4); 82 } 83 84 /// <summary> 85 /// Ldloc 将指定索引处的局部变量加载到计算堆栈上。 86 /// </summary> 87 /// <param name="slot"></param> 88 public void Ldloc(int slot) 89 { 90 switch (slot) 91 { 92 case 0: 93 this.ilGen.Emit(OpCodes.Ldloc_0); 94 return; 95 96 case 1: 97 this.ilGen.Emit(OpCodes.Ldloc_1); 98 return; 99 100 case 2: 101 this.ilGen.Emit(OpCodes.Ldloc_2); 102 return; 103 104 case 3: 105 this.ilGen.Emit(OpCodes.Ldloc_3); 106 return; 107 } 108 if (slot <= 0xff) 109 { 110 this.ilGen.Emit(OpCodes.Ldloc_S, slot); 111 } 112 else 113 { 114 this.ilGen.Emit(OpCodes.Ldloc, slot); 115 } 116 } 117 118 /// <summary> 119 /// Ldloc 将指定索引处的局部变量加载到计算堆栈上 120 /// </summary> 121 /// <param name="localBuilder"></param> 122 public void Ldloc(LocalBuilder localBuilder) 123 { 124 this.ilGen.Emit(OpCodes.Ldloc, localBuilder); 125 } 126 127 /// <summary> 128 /// Ldloca 将位于特定索引处的局部变量的地址加载到计算堆栈上。 129 /// 提示：ldloca.s 指令为使用局部变量 0 到 255 提供有效的编码。 130 /// </summary> 131 /// <param name="slot"></param> 132 public void Ldloca(int slot) 133 { 134 if (slot <= 0xff) 135 { 136 this.ilGen.Emit(OpCodes.Ldloca_S, slot); 137 } 138 else 139 { 140 this.ilGen.Emit(OpCodes.Ldloca, slot); 141 } 142 } 143 144 /// <summary> 145 /// Ldloca 146 /// </summary> 147 /// <param name="localBuilder"></param> 148 public void Ldloca(LocalBuilder localBuilder) 149 { 150 Check.Require(localBuilder, "localBuilder"); 151 152 this.ilGen.Emit(OpCodes.Ldloca, localBuilder); 153 } 154 155 /// <summary> 156 /// LdlocAddress 不是IL指令。 157 /// 分别调用Ldloca和Ldloc将值/引用类型变量地址加载到计算堆栈 158 /// 当是为值类型时调用 Ldloca 159 /// 否则调用 Ldloc 160 /// </summary> 161 /// <param name="localBuilder"></param> 162 public void LdlocAddress(LocalBuilder localBuilder) 163 { 164 Check.Require(localBuilder, "localBuilder"); 165 166 if (localBuilder.LocalType.IsValueType) 167 { 168 this.Ldloca(localBuilder); 169 } 170 else 171 { 172 this.Ldloc(localBuilder); 173 } 174 } 175 176 /// <summary> 177 /// Ldobj 将地址指向的值类型(类型为type)对象复制到计算堆栈的顶部 178 /// </summary> 179 /// <param name="type"></param> 180 public void Ldobj(Type type) 181 { 182 Check.Require(type, "type"); 183 184 OpCode opcode = this.GetLdindOpCode(Type.GetTypeCode(type)); 185 if (!opcode.Equals(OpCodes.Nop)) 186 { 187 this.ilGen.Emit(opcode); 188 } 189 else 190 { 191 this.ilGen.Emit(OpCodes.Ldobj, type); 192 } 193 } 194 195 /// <summary> 196 /// Ldstr 197 /// 将一个字符串加载到 Stack 198 /// </summary> 199 /// <param name="strVar"></param> 200 public void Ldstr(string strVar) 201 { 202 this.ilGen.Emit(OpCodes.Ldstr, strVar); 203 } 204 205 /// <summary> 206 /// Ldtoken 将元数据标记(数据类型)转换为其运行时表示形式，并将其推送到计算堆栈上。 207 /// ldtoken 指令为指定的元数据标记推送 RuntimeHandle。 208 /// 其中: RuntimeHandle 可以是 fieldref/fielddef、methodref/methoddef 或 typeref/typedef。 209 /// 说白了:就是向栈内添加 某类型的 运行时类型 210 /// </summary> 211 /// <param name="t"></param> 212 public void Ldtoken(Type t) 213 { 214 Check.Require(t, "t"); 215 this.ilGen.Emit(OpCodes.Ldtoken, t); 216 } 217 218 /// <summary> 219 /// Load 220 /// </summary> 221 /// <param name="obj"></param> 222 public void Load(object obj) 223 { 224 if (obj == null) 225 { 226 this.ilGen.Emit(OpCodes.Ldnull); //将空对象引用推送到堆栈上 227 } 228 else if (obj is ArgBuilder) 229 { 230 this.Ldarg((ArgBuilder)obj); 231 } 232 else if (obj is LocalBuilder) 233 { 234 this.Ldloc((LocalBuilder)obj); 235 } 236 else 237 { 238 this.Ldc(obj); 239 } 240 } 241 242 /// <summary> 243 /// LoadAddress 244 /// </summary> 245 /// <param name="obj"></param> 246 public void LoadAddress(object obj) 247 { 248 if (obj is ArgBuilder) 249 { 250 this.LdargAddress((ArgBuilder)obj); 251 } 252 else if (obj is LocalBuilder) 253 { 254 this.LdlocAddress((LocalBuilder)obj); 255 } 256 else 257 { 258 this.Load(obj); 259 } 260 } 261 262 /// <summary> 263 /// LoadArrayElement 264 /// </summary> 265 /// <param name="obj"></param> 266 /// <param name="arrayIndex"></param> 267 public void LoadArrayElement(object obj, object arrayIndex) 268 { 269 Type objType = this.GetVariableType(obj).GetElementType(); 270 this.Load(obj); 271 this.Load(arrayIndex); 272 if (IsStruct(objType)) 273 { //Stuct类型:先加载地址,然后寻址加载 274 this.Ldelema(objType); 275 this.Ldobj(objType); 276 } 277 else 278 { 279 this.Ldelem(objType); 280 } 281 } 282 283 /// <summary> 284 /// LoadDefaultValue 285 /// </summary> 286 /// <param name="type"></param> 287 public void LoadDefaultValue(Type type) 288 { 289 Check.Require(type, "type"); 290 291 if (!type.IsValueType) 292 { 293 this.Load(null); 294 } 295 else 296 { 297 switch (Type.GetTypeCode(type)) 298 { 299 case TypeCode.Boolean: 300 this.Ldc(false); 301 return; 302 303 case TypeCode.Char: 304 case TypeCode.SByte: 305 case TypeCode.Byte: 306 case TypeCode.Int16: 307 case TypeCode.UInt16: 308 case TypeCode.Int32: 309 case TypeCode.UInt32: 310 this.Ldc(0); 311 return; 312 313 case TypeCode.Int64: 314 case TypeCode.UInt64: 315 this.Ldc((long)0); 316 return; 317 318 case TypeCode.Single: 319 this.Ldc((float)0f); 320 return; 321 322 case TypeCode.Double: 323 this.Ldc((double)0); 324 return; 325 } 326 //非原始类型,一般指结构体Struct 327 LocalBuilder builder = this.DeclareLocal(type, "zero"); 328 this.LoadAddress(builder); 329 this.InitObj(type); 330 this.Load(builder); 331 } 332 } 333 334 /// <summary> 335 /// LoadMember 336 /// Return:执行后的栈顶类型 337 /// </summary> 338 /// <param name="memberInfo"></param> 339 /// <returns></returns> 340 public Type LoadMember(MemberInfo memberInfo) 341 { 342 Check.Require(memberInfo, "memberInfo"); 343 344 Type stackTopType = null; 345 if (memberInfo.MemberType == MemberTypes.Field) 346 { 347 FieldInfo field = (FieldInfo)memberInfo; 348 stackTopType = field.FieldType; 349 if (field.IsStatic) 350 { 351 this.ilGen.Emit(OpCodes.Ldsfld, field); 352 } 353 else 354 { 355 this.ilGen.Emit(OpCodes.Ldfld, field); 356 } 357 } 358 else if (memberInfo.MemberType == MemberTypes.Property) 359 { 360 PropertyInfo info2 = memberInfo as PropertyInfo; 361 stackTopType = info2.PropertyType; 362 if (info2 != null) 363 { 364 MethodInfo methodInfo = info2.GetGetMethod(true); 365 if (methodInfo == null) 366 { 367 throw new Exception("NoGetMethodForProperty"); 368 } 369 this.Call(methodInfo); 370 } 371 } 372 else 373 { 374 if (memberInfo.MemberType != MemberTypes.Method) 375 { 376 throw new Exception("CannotLoadMemberType"); 377 } 378 MethodInfo info4 = (MethodInfo)memberInfo; 379 stackTopType = info4.ReturnType; 380 this.Call(info4); 381 } 382 return stackTopType; 383 } 384 385 /// <summary> 386 /// LoadParam:加载一个参数:加载对象,并转换为方法中参数的类型 387 /// </summary> 388 /// <param name="arg"></param> 389 /// <param name="oneBasedArgIndex"></param> 390 /// <param name="methodInfo"></param> 391 private void LoadParam(object arg, int oneBasedArgIndex, MethodBase methodInfo) 392 { 393 this.Load(arg); 394 if (arg != null) 395 { 396 this.ConvertValue(this.GetVariableType(arg), methodInfo.GetParameters()[oneBasedArgIndex - 1].ParameterType); 397 } 398 } 399 400 /// <summary> 401 /// LoadThis:加载对象,并转换为 402 /// </summary> 403 /// <param name="thisObj"></param> 404 /// <param name="methodInfo"></param> 405 private void LoadThis(object thisObj, MethodInfo methodInfo) 406 { 407 if ((thisObj != null) && !methodInfo.IsStatic) 408 { 409 this.LoadAddress(thisObj); 410 this.ConvertAddress(this.GetVariableType(thisObj), methodInfo.DeclaringType); 411 } 412 }
加载 [参数||参数地址]
1 /// <summary> 2 /// Ldarg 加载第solt参数到堆栈 3 /// 注意：实例方法都有一个隐含参数，也就是第0个参数是表示当前对象引用 也就是 this指针 4 /// </summary> 5 /// <param name="slot">The slot.</param> 6 public void Ldarg(int slot) 7 { 8 switch (slot) 9 { 10 case 0: 11 this.ilGen.Emit(OpCodes.Ldarg_0); 12 return; 13 14 case 1: 15 this.ilGen.Emit(OpCodes.Ldarg_1); 16 return; 17 18 case 2: 19 this.ilGen.Emit(OpCodes.Ldarg_2); 20 return; 21 22 case 3: 23 this.ilGen.Emit(OpCodes.Ldarg_3); 24 return; 25 } 26 if (slot <= 0xff) 27 { 28 //将参数（由指定的短格式索引引用）加载到计算堆栈上。 29 this.ilGen.Emit(OpCodes.Ldarg_S, slot); 30 } 31 else 32 { 33 this.ilGen.Emit(OpCodes.Ldarg, slot); 34 } 35 } 36 37 /// <summary> 38 /// Ldarg 调用Ldarg(int)的重载方式 39 /// </summary> 40 /// <param name="arg"></param> 41 public void Ldarg(ArgBuilder arg) 42 { 43 Check.Require(arg, "arg"); 44 45 this.Ldarg(arg.Index); 46 } 47 48 /// <summary> 49 /// Ldarga 将参数的地址加载到计算堆栈=>注意是加载地址 50 /// 自动判断是使用Ldarga_S,还是Ldarga 51 /// Ldarga_S 指令是用于slot值在 0 到 255的参数编号，效率更高的编码 52 /// </summary> 53 /// <param name="slot"></param> 54 public void Ldarga(int slot) 55 { 56 if (slot <= 0xff) 57 { 58 this.ilGen.Emit(OpCodes.Ldarga_S, slot); 59 } 60 else 61 { 62 this.ilGen.Emit(OpCodes.Ldarga, slot); 63 } 64 } 65 66 /// <summary> 67 /// Ldarga 调用 Ldarga(int) 重载 68 /// </summary> 69 /// <param name="argBuilder"></param> 70 public void Ldarga(ArgBuilder argBuilder) 71 { 72 Check.Require(argBuilder, "argBuilder"); 73 74 this.Ldarga(argBuilder.Index); 75 }
类型方面：
创建构建
1 /// <summary> 2 /// InitObj:初始化值类型 3 /// Pre1: 将要初始化的值类型的地址推送到堆栈上。 4 /// TODO: 从堆栈中弹出地址；将位于指定地址的值类型初始化为 typeTok 类型。 5 /// 提示: 与 Newobj 不同，initobj 不会调用构造函数方法。 Initobj 用于初始化值类型，而 newobj 用于分配和初始化对象。 6 /// </summary> 7 /// <param name="valueType"></param> 8 public void InitObj(Type valueType) 9 { 10 Check.Require(valueType, "valueType"); 11 12 this.ilGen.Emit(OpCodes.Initobj, valueType); 13 } 14 15 16 /// <summary> 17 /// New:初始化引用类型 18 /// </summary> 19 /// <param name="constructorInfo"></param> 20 public void New(ConstructorInfo constructorInfo) 21 { 22 Check.Require(constructorInfo, "constructorInfo"); 23 //Pre1:将从 arg1 到 argn 的参数按顺序推送到堆栈上。 24 //Do1:从堆栈中弹出从 argn 到 arg1 的参数并将它们传递到 ctor 以用于对象创建。 25 //Do2:将对新对象的引用推送到堆栈上。 26 this.ilGen.Emit(OpCodes.Newobj, constructorInfo); 27 } 28 29 /// <summary> 30 /// New:带一个参数的构建方法 31 /// </summary> 32 /// <param name="constructorInfo"></param> 33 /// <param name="param1"></param> 34 public void New(ConstructorInfo constructorInfo, object param1) 35 { 36 Check.Require(constructorInfo, "constructorInfo"); 37 38 this.LoadParam(param1, 1, constructorInfo); 39 this.New(constructorInfo); 40 } 41 42 /// <summary> 43 /// NewArray:构造数组 44 /// </summary> 45 /// <param name="elementType"></param> 46 /// <param name="len"></param> 47 public void NewArray(Type elementType, object len) 48 { 49 Check.Require(elementType, "elementType"); 50 51 this.Load(len); 52 this.ilGen.Emit(OpCodes.Newarr, elementType); 53 }
类型转换
1 /// <summary> 2 /// InternalConvert: 3 /// </summary> 4 /// <param name="source"></param> 5 /// <param name="target"></param> 6 /// <param name="isAddress"></param> 7 private void InternalConvert(Type source, Type target, bool isAddress) 8 { 9 if (target != source) 10 { 11 if (target.IsValueType) 12 { //都为值类型 13 if (source.IsValueType) 14 { 15 OpCode opcode = this.GetConvOpCode(Type.GetTypeCode(target)); 16 if (opcode.Equals(OpCodes.Nop)) 17 { 18 throw new Exception("NoConversionPossible"); 19 } 20 this.ilGen.Emit(opcode); 21 } 22 else 23 { 24 if (!source.IsAssignableFrom(target)) 25 { 26 throw new Exception("IsNotAssignableFrom"); 27 } 28 //source引用类型 变为target值类型 29 this.Unbox(target); 30 if (!isAddress) 31 { 32 this.Ldobj(target); 33 } 34 } 35 } 36 //target=source; source继承于target==>target,source都是引用类型 37 else if (target.IsAssignableFrom(source)) 38 { 39 if (source.IsValueType) 40 { //栈顶是source对象的地址 41 if (isAddress) 42 { 43 this.Ldobj(source); 44 } 45 this.Box(source); 46 } 47 } 48 //source=target;target继承于source 49 else if (source.IsAssignableFrom(target)) 50 { 51 this.Castclass(target); 52 } 53 else 54 { 55 if (!target.IsInterface && !source.IsInterface) 56 { 57 throw new Exception("IsNotAssignableFrom"); 58 } 59 this.Castclass(target); 60 } 61 } 62 } 63 64 /// <summary> 65 /// ConvertAddress 66 /// </summary> 67 /// <param name="source"></param> 68 /// <param name="target"></param> 69 public void ConvertAddress(Type source, Type target) 70 { 71 Check.Require(source, "source"); 72 Check.Require(target, "target"); 73 74 this.InternalConvert(source, target, true); 75 } 76 77 /// <summary> 78 /// ConvertValue 79 /// </summary> 80 /// <param name="source"></param> 81 /// <param name="target"></param> 82 public void ConvertValue(Type source, Type target) 83 { 84 Check.Require(source, "source"); 85 Check.Require(target, "target"); 86 87 this.InternalConvert(source, target, false); 88 } 89 90 91 /// <summary> 92 /// Castclass 93 /// </summary> 94 /// <param name="target"></param> 95 public void Castclass(Type target) 96 { 97 Check.Require(target, "target"); 98 99 this.ilGen.Emit(OpCodes.Castclass, target); 100 } 101 102 /// <summary> 103 /// Box 104 /// </summary> 105 /// <param name="type"></param> 106 public void Box(Type type) 107 { 108 Check.Require(type, "type"); 109 Check.Require(type.IsValueType, "type MUST be ValueType"); 110 111 this.ilGen.Emit(OpCodes.Box, type); 112 } 113 114 /// <summary> 115 /// Unbox 116 /// </summary> 117 /// <param name="type"></param> 118 public void Unbox(Type type) 119 { 120 Check.Require(type, "type"); 121 Check.Require(type.IsValueType, "type MUST be ValueType"); 122 //pre: 将对象引用推送到堆栈上 123 //Do1: 从堆栈中弹出对象引用并取消装箱为值类型指针 124 //Do2: 将值类型指针推送到堆栈上 125 //Result:栈顶保存值类型的指针 126 this.ilGen.Emit(OpCodes.Unbox, type); 127 //如果需将值加载到堆栈上=>ldobj 128 //Pre:将值类型对象的地址推送到地址上。 129 //Do1:从堆栈中弹出该地址并查找位于该特定地址处的实例。 130 //Do2:将存储在该地址处的对象的值推送到堆栈上。 131 } 132 133 /// <summary> 134 /// UnboxAny 135 /// 当应用于值类型的已装箱形式时，unbox.any 指令提取 obj（类型为 O）中包含的值，因此等效于 unbox 后跟 ldobj。 136 /// 当应用于引用类型时，unbox.any 指令与 castclass 效果相同。 137 /// </summary> 138 /// <param name="type"></param> 139 public void UnboxAny(Type type) 140 { 141 Check.Require(type, "type"); 142 Check.Require(type.IsValueType, "type MUST be ValueType"); 143 //Pre: 将对象引用 obj 推送到堆栈上 144 //Do1: 从堆栈中弹出对象引用，取消装箱到指令中指定的类型 145 //Do2: 将结果对象引用或值类型推送到堆栈上 146 //Result:栈顶保存值类型的值 147 this.ilGen.Emit(OpCodes.Unbox_Any, type); 148 149 //castclass 指令 150 // 将对象引用推送到堆栈上 151 // 从堆栈中弹出对象引用；引用的对象被转换为指定的 class 152 // 如果成功，则新对象引用被推送到堆栈上 153 }
运算符：
算式运算符
1 /// <summary> 2 /// Add 3 /// </summary> 4 public void Add() 5 { 6 this.ilGen.Emit(OpCodes.Add); 7 } 8 /// <summary> 9 /// Inc 10 /// </summary> 11 /// <param name="var"></param> 12 public void Inc(object var) 13 { 14 this.Load(var); 15 this.Load(1); 16 this.Add(); 17 this.Store(var); 18 } 19 /// <summary> 20 /// Dec 21 /// </summary> 22 /// <param name="var"></param> 23 public void Dec(object var) 24 { 25 this.Load(var); 26 this.Load(1); 27 this.Subtract(); 28 this.Store(var); 29 } 30 /// <summary> 31 /// Subtract 32 /// </summary> 33 public void Subtract() 34 { 35 this.ilGen.Emit(OpCodes.Sub); 36 }
位运算符
1 /// <summary> 2 /// And 3 /// </summary> 4 public void And() 5 { 6 this.ilGen.Emit(OpCodes.And); 7 } 8 /// <summary> 9 /// Not 10 /// </summary> 11 public void Not() 12 { 13 this.ilGen.Emit(OpCodes.Not); 14 } 15 16 /// <summary> 17 /// Or 18 /// </summary> 19 public void Or() 20 { 21 this.ilGen.Emit(OpCodes.Or); 22 }
关系运算符
1 /// <summary> 2 /// Ceq 3 /// </summary> 4 public void Ceq() 5 { 6 this.ilGen.Emit(OpCodes.Ceq); 7 }
公共操作：
指令获取
1 private OpCode GetBranchCode(Cmp cmp) 2 { 3 switch (cmp) 4 { 5 case Cmp.LessThan: 6 return OpCodes.Bge; 7 8 case Cmp.EqualTo: 9 return OpCodes.Bne_Un; 10 11 case Cmp.LessThanOrEqualTo: 12 return OpCodes.Bgt; 13 14 case Cmp.GreaterThan: 15 return OpCodes.Ble; 16 17 case Cmp.NotEqualTo: 18 return OpCodes.Beq; 19 } 20 return OpCodes.Blt; 21 } 22 23 //相反的比较关系 24 private Cmp GetCmpInverse(Cmp cmp) 25 { 26 switch (cmp) 27 { 28 case Cmp.LessThan: 29 return Cmp.GreaterThanOrEqualTo; 30 31 case Cmp.EqualTo: 32 return Cmp.NotEqualTo; 33 34 case Cmp.LessThanOrEqualTo: 35 return Cmp.GreaterThan; 36 37 case Cmp.GreaterThan: 38 return Cmp.LessThanOrEqualTo; 39 40 case Cmp.NotEqualTo: 41 return Cmp.EqualTo; 42 } 43 return Cmp.LessThan; 44 } 45 46 private OpCode GetConvOpCode(TypeCode typeCode) 47 { 48 switch (typeCode) 49 { 50 case TypeCode.Boolean: 51 //Pre:value 被推送到堆栈上。 52 //Do1:从堆栈中弹出 value，然后尝试执行转换操作。 53 //Do2:如果转换成功，则将结果值推送到堆栈上。 54 return OpCodes.Conv_I1; 55 56 case TypeCode.Char: 57 return OpCodes.Conv_I2; 58 59 case TypeCode.SByte: 60 return OpCodes.Conv_I1; 61 62 case TypeCode.Byte: 63 return OpCodes.Conv_U1; 64 65 case TypeCode.Int16: 66 return OpCodes.Conv_I2; 67 68 case TypeCode.UInt16: 69 return OpCodes.Conv_U2; 70 71 case TypeCode.Int32: 72 return OpCodes.Conv_I4; 73 74 case TypeCode.UInt32: 75 return OpCodes.Conv_U4; 76 77 case TypeCode.Int64: 78 return OpCodes.Conv_I8; 79 80 case TypeCode.UInt64: 81 return OpCodes.Conv_I8; 82 83 case TypeCode.Single: 84 return OpCodes.Conv_R4; 85 86 case TypeCode.Double: 87 return OpCodes.Conv_R8; 88 } 89 return OpCodes.Nop; 90 } 91 92 private OpCode GetLdelemOpCode(TypeCode typeCode) 93 { 94 switch (typeCode) 95 { 96 case TypeCode.Object: 97 case TypeCode.DBNull: 98 return OpCodes.Ldelem_Ref; 99 100 case TypeCode.Boolean: 101 return OpCodes.Ldelem_I1; 102 103 case TypeCode.Char: 104 return OpCodes.Ldelem_I2; 105 106 case TypeCode.SByte: 107 return OpCodes.Ldelem_I1; 108 109 case TypeCode.Byte: 110 return OpCodes.Ldelem_U1; 111 112 case TypeCode.Int16: 113 //Pre1：将对象引用 array 推送到堆栈上。 114 //Pre2：将索引值 index 推送到堆栈上。 115 //Do1:从堆栈中弹出 index 和 array；查找存储在 array 中的位置 index 处的值。 116 //Do2:将值推送到堆栈上。 117 return OpCodes.Ldelem_I2; 118 119 case TypeCode.UInt16: 120 return OpCodes.Ldelem_U2; 121 122 case TypeCode.Int32: 123 return OpCodes.Ldelem_I4; 124 125 case TypeCode.UInt32: 126 return OpCodes.Ldelem_U4; 127 128 case TypeCode.Int64: 129 return OpCodes.Ldelem_I8; 130 131 case TypeCode.UInt64: 132 return OpCodes.Ldelem_I8; 133 134 case TypeCode.Single: 135 return OpCodes.Ldelem_R4; 136 137 case TypeCode.Double: 138 return OpCodes.Ldelem_R8; 139 140 case TypeCode.String: 141 return OpCodes.Ldelem_Ref; 142 } 143 return OpCodes.Nop; 144 } 145 146 /// <summary> 147 /// 根据值类型，返回使用哪个指令将值类型复制到计算堆栈上(ldobj指令的功能) 148 /// 间址寻址 取数 149 /// 所有 ldind 指令都是指定相应内置值类的 Ldobj 指令的快捷方式 150 /// </summary> 151 /// <param name="typeCode">The type code.</param> 152 /// <returns></returns> 153 private OpCode GetLdindOpCode(TypeCode typeCode) 154 { 155 switch (typeCode) 156 { 157 case TypeCode.Boolean: 158 //将 int8 类型的值作为 int32 间接加载到计算堆栈上。 159 //也就是:将位于栈顶的地址,所对应的int8,作为int32加载到堆栈上。 160 161 return OpCodes.Ldind_I1; 162 163 case TypeCode.Char: 164 return OpCodes.Ldind_I2; 165 166 case TypeCode.SByte: 167 return OpCodes.Ldind_I1; 168 169 case TypeCode.Byte: 170 return OpCodes.Ldind_U1; 171 172 case TypeCode.Int16: 173 return OpCodes.Ldind_I2; 174 175 case TypeCode.UInt16: 176 return OpCodes.Ldind_U2; 177 178 case TypeCode.Int32: 179 return OpCodes.Ldind_I4; 180 181 case TypeCode.UInt32: 182 return OpCodes.Ldind_U4; 183 //请注意，小于 4 个字节的整数值在加载到计算堆栈上时会被扩展为 int32 184 // 185 case TypeCode.Int64: 186 return OpCodes.Ldind_I8; 187 188 case TypeCode.UInt64: 189 return OpCodes.Ldind_I8; 190 191 case TypeCode.Single: 192 return OpCodes.Ldind_R4; 193 194 case TypeCode.Double: 195 return OpCodes.Ldind_R8; 196 197 case TypeCode.String: 198 //将地址 addr 处的对象引用作为 O 类型加载到堆栈上 199 return OpCodes.Ldind_Ref; 200 } 201 return OpCodes.Nop; 202 } 203 204 private OpCode GetStelemOpCode(TypeCode typeCode) 205 { 206 switch (typeCode) 207 { 208 case TypeCode.Object: 209 case TypeCode.DBNull: 210 //用计算堆栈上的对象 ref 值（O 类型）替换给定索引处的数组元素。 211 return OpCodes.Stelem_Ref; 212 213 case TypeCode.Boolean: 214 return OpCodes.Stelem_I1; 215 216 case TypeCode.Char: 217 return OpCodes.Stelem_I2; 218 219 case TypeCode.SByte: 220 return OpCodes.Stelem_I1; 221 222 case TypeCode.Byte: 223 return OpCodes.Stelem_I1; 224 225 case TypeCode.Int16: 226 return OpCodes.Stelem_I2; 227 228 case TypeCode.UInt16: 229 //How:用计算堆栈上的 int16 值替换给定索引处的数组元素。 230 //Pre1: 将对数组 array 的对象引用推送到堆栈上。 231 //Pre2: 将array 中元素的有效索引推送到堆栈上。 232 //Pre3：将值推送到堆栈上。 233 //ToDo: 从堆栈中弹出值、索引和数组引用；将值放入给定索引处的数组元素中。 234 return OpCodes.Stelem_I2; 235 236 case TypeCode.Int32: 237 return OpCodes.Stelem_I4; 238 239 case TypeCode.UInt32: 240 return OpCodes.Stelem_I4; 241 242 case TypeCode.Int64: 243 return OpCodes.Stelem_I8; 244 245 case TypeCode.UInt64: 246 return OpCodes.Stelem_I8; 247 248 case TypeCode.Single: 249 return OpCodes.Stelem_R4; 250 251 case TypeCode.Double: 252 return OpCodes.Stelem_R8; 253 254 case TypeCode.String: 255 return OpCodes.Stelem_Ref; 256 } 257 return OpCodes.Nop; 258 }
常用方法
1 /// <summary> 2 /// DefineLabel 3 /// </summary> 4 /// <returns></returns> 5 public Label DefineLabel() 6 { 7 return this.ilGen.DefineLabel(); 8 } 9 10 /// <summary> 11 /// MarkLabel 12 /// </summary> 13 /// <param name="label"></param> 14 public void MarkLabel(Label label) 15 { 16 //不能多次定义一个标签 17 this.ilGen.MarkLabel(label); 18 } 19 20 /// <summary> 21 /// Dup：对堆栈顶部的数据 进行拷贝 22 /// </summary> 23 public void Dup() 24 { 25 this.ilGen.Emit(OpCodes.Dup); 26 } 27 28 29 /// <summary> 30 /// GetArg 31 /// </summary> 32 /// <param name="index"></param> 33 /// <returns></returns> 34 public ArgBuilder GetArg(int index) 35 { 36 return (ArgBuilder)this.argList[index]; 37 } 38 39 /// <summary> 40 /// GetVariableType 41 /// </summary> 42 /// <param name="var"></param> 43 /// <returns></returns> 44 public Type GetVariableType(object var) 45 { 46 if (var is ArgBuilder) 47 { 48 return ((ArgBuilder)var).ArgType; 49 } 50 if (var is LocalBuilder) 51 { 52 return ((LocalBuilder)var).LocalType; 53 } 54 return var.GetType(); 55 } 56 57 private static bool IsStruct(Type objType) 58 { 59 if (objType.IsValueType) 60 { 61 return !objType.IsPrimitive; //非原始的数值类型:也就是非int,long,bool等类型 62 } 63 return false; 64 } 65 66 67 /// <summary> 68 /// Pop:两个指令集有何区别 69 /// a=GetAge(); 70 /// GetAge(); 71 /// 前者需要将栈顶的值弹入a中,后者从栈顶弹出不保存 72 /// 前者是一个保存操作，后者即是Pop操作 73 /// </summary> 74 public void Pop() 75 { 76 this.ilGen.Emit(OpCodes.Pop); 77 } 78 79 /// <summary> 80 /// Throw 81 /// </summary> 82 public void Throw() 83 { 84 this.ilGen.Emit(OpCodes.Throw); 85 } 86 87 private void ThrowMismatchException(object expected) 88 { 89 throw new Exception("ExpectingEnd"); 90 }
结构语句：
条件跳转
1 /// <summary> 2 /// Bgt 3 /// </summary> 4 /// <param name="label"></param> 5 public void Bgt(Label label) 6 { 7 this.ilGen.Emit(OpCodes.Bgt, label); 8 } 9 10 /// <summary> 11 /// Ble 12 /// </summary> 13 /// <param name="label"></param> 14 public void Ble(Label label) 15 { 16 this.ilGen.Emit(OpCodes.Ble, label); 17 } 18 19 /// <summary> 20 /// Blt 21 /// </summary> 22 /// <param name="label"></param> 23 public void Blt(Label label) 24 { 25 this.ilGen.Emit(OpCodes.Blt, label); 26 } 27 28 /// <summary> 29 /// Br 无条件地将控制转移到目标指令 30 /// </summary> 31 /// <param name="label"></param> 32 public void Br(Label label) 33 { 34 this.ilGen.Emit(OpCodes.Br, label); 35 } 36 37 /// <summary> 38 /// Brfalse 39 /// </summary> 40 /// <param name="label"></param> 41 public void Brfalse(Label label) 42 { 43 this.ilGen.Emit(OpCodes.Brfalse, label); 44 } 45 46 /// <summary> 47 /// Brtrue 48 /// </summary> 49 /// <param name="label"></param> 50 public void Brtrue(Label label) 51 { 52 this.ilGen.Emit(OpCodes.Brtrue, label); 53 }
If语句
1 /// <summary> 2 /// If 3 /// </summary> 4 /// <param name="value1"></param> 5 /// <param name="cmpOp"></param> 6 /// <param name="value2"></param> 7 public void If(object value1, Cmp cmpOp, object value2) 8 { 9 this.Load(value1); 10 this.Load(value2); 11 this.If(cmpOp); 12 } 13 14 /// <summary> 15 /// If 16 /// </summary> 17 /// <param name="cmpOp"></param> 18 public void If(Cmp cmpOp) 19 { 20 //if(a==b){ } 21 IfState state = new IfState(); 22 state.EndIf = this.DefineLabel(); 23 state.ElseBegin = this.DefineLabel(); 24 this.ilGen.Emit(this.GetBranchCode(cmpOp), state.ElseBegin); 25 this.blockStack.Push(state); 26 } 27 /// <summary> 28 /// ElseIf 29 /// </summary> 30 /// <param name="value1"></param> 31 /// <param name="cmpOp"></param> 32 /// <param name="value2"></param> 33 public void ElseIf(object value1, Cmp cmpOp, object value2) 34 { 35 IfState state = (IfState)this.blockStack.Pop(); 36 this.Br(state.EndIf); 37 this.MarkLabel(state.ElseBegin); 38 this.Load(value1); 39 this.Load(value2); 40 state.ElseBegin = this.DefineLabel(); 41 this.ilGen.Emit(this.GetBranchCode(cmpOp), state.ElseBegin); 42 this.blockStack.Push(state); 43 } 44 45 46 /// <summary> 47 /// Else 48 /// </summary> 49 public void Else() 50 { 51 IfState state = this.PopIfState(); 52 this.Br(state.EndIf); 53 this.MarkLabel(state.ElseBegin); 54 state.ElseBegin = state.EndIf; 55 this.blockStack.Push(state); 56 } 57 58 59 /// <summary> 60 /// EndIf 61 /// </summary> 62 public void EndIf() 63 { 64 IfState state = this.PopIfState(); 65 if (!state.ElseBegin.Equals(state.EndIf)) 66 { 67 this.MarkLabel(state.ElseBegin); 68 } 69 this.MarkLabel(state.EndIf); 70 } 71 72 73 74 75 76 /// <summary> 77 /// If 78 /// </summary> 79 public void If() 80 { 81 this.InternalIf(false); 82 } 83 /// <summary> 84 /// IfNot 85 /// </summary> 86 public void IfNot() 87 { 88 this.InternalIf(true); 89 } 90 private void InternalIf(bool negate) 91 { 92 IfState state = new IfState(); 93 state.EndIf = this.DefineLabel(); 94 state.ElseBegin = this.DefineLabel(); 95 if (negate) 96 { 97 this.Brtrue(state.ElseBegin); 98 } 99 else 100 { 101 this.Brfalse(state.ElseBegin); 102 } 103 this.blockStack.Push(state); 104 } 105 106 107 108 /// <summary> 109 /// IfNotDefaultValue 110 /// </summary> 111 /// <param name="value"></param> 112 public void IfNotDefaultValue(object value) 113 { 114 Type variableType = this.GetVariableType(value); 115 TypeCode typeCode = Type.GetTypeCode(variableType); 116 if (((typeCode == TypeCode.Object) && variableType.IsValueType) || ((typeCode == TypeCode.DateTime) || (typeCode == TypeCode.Decimal))) 117 { 118 this.LoadDefaultValue(variableType); 119 this.ConvertValue(variableType, typeof(object)); 120 this.Load(value); 121 this.ConvertValue(variableType, typeof(object)); 122 this.Call(ObjectEquals); 123 this.IfNot(); 124 } 125 else 126 { 127 this.LoadDefaultValue(variableType); 128 this.Load(value); 129 this.If(Cmp.NotEqualTo); 130 } 131 } 132 133 private IfState PopIfState() 134 { 135 object expected = this.blockStack.Pop(); 136 IfState state = expected as IfState; 137 if (state == null) 138 { 139 this.ThrowMismatchException(expected); 140 } 141 return state; 142 }
If语句示意[有Else]
1 // if(...) Goto BeginIf 2 3 ////{IfCode} 4 5 // Goto EndIf 6 //:BeginIf 7 // if(...) Goto ElseIf1 8 9 ////{Else-IfCode} 10 11 // Goto Endif 12 //:ElseIf1 13 // if(...) Goto ElseIf2 14 15 ////{ElseCode} 16 17 ////注:(ElseIf2==EndIf),差异是无ElseIf2 18 //:EndIf
If语句示意[无Else]
1 // if(...) Goto BeginIf 2 3 //{If-Code} 4 5 // Goto EndIf 6 //:BeginIf 7 // if(...) Goto ElseIf1 8 9 //{Else-IfCode} 10 11 // Goto Endif 12 //:ElseIf1 13 // if(...) Goto ElseIf2 14 15 //{Else-IfCode} 16 17 //:ElseIf2 18 //:EndIf
Switch语句
1 /// <summary> 2 /// Switch 3 /// </summary> 4 /// <param name="labelCount"></param> 5 /// <returns></returns> 6 public Label[] Switch(int labelCount) 7 { 8 SwitchState state = new SwitchState(this.DefineLabel(), this.DefineLabel()); 9 Label[] labels = new Label[labelCount]; 10 for (int i = 0; i < labels.Length; i++) 11 { 12 labels[i] = this.DefineLabel(); 13 } 14 this.ilGen.Emit(OpCodes.Switch, labels); 15 this.Br(state.DefaultLabel); 16 this.blockStack.Push(state); 17 return labels; 18 } 19 20 21 /// <summary> 22 /// Case 23 /// </summary> 24 /// <param name="caseLabel1"></param> 25 /// <param name="caseLabelName"></param> 26 public void Case(Label caseLabel1, string caseLabelName) 27 { 28 this.MarkLabel(caseLabel1); 29 } 30 /// <summary> 31 /// DefaultCase:开始default代码块 32 /// </summary> 33 public void DefaultCase() 34 { 35 object expected = this.blockStack.Peek(); 36 SwitchState state = expected as SwitchState; 37 if (state == null) 38 { 39 this.ThrowMismatchException(expected); 40 } 41 this.MarkLabel(state.DefaultLabel); 42 state.DefaultDefined = true; 43 } 44 45 46 /// <summary> 47 /// EndCase:相当于Switch中的break 48 /// </summary> 49 public void EndCase() 50 { 51 object expected = this.blockStack.Peek(); 52 SwitchState state = expected as SwitchState; 53 if (state == null) 54 { 55 this.ThrowMismatchException(expected); 56 } 57 this.Br(state.EndOfSwitchLabel); 58 } 59 /// <summary> 60 /// EndSwitch 61 /// </summary> 62 public void EndSwitch() 63 { 64 object expected = this.blockStack.Pop(); 65 SwitchState state = expected as SwitchState; 66 if (state == null) 67 { 68 this.ThrowMismatchException(expected); 69 } 70 if (!state.DefaultDefined) 71 { 72 this.MarkLabel(state.DefaultLabel); 73 } 74 this.MarkLabel(state.EndOfSwitchLabel); 75 }
For||Foreach
1 /// <summary> 2 /// For 3 /// </summary> 4 /// <param name="local"></param> 5 /// <param name="start"></param> 6 /// <param name="end"></param> 7 /// <returns></returns> 8 public object For(LocalBuilder local, object start, object end) 9 { 10 Check.Require(local, "local"); 11 12 ForState state = new ForState(local, this.DefineLabel(), this.DefineLabel(), end); 13 if (state.Index != null) 14 { 15 this.Load(start); 16 this.Stloc(state.Index); 17 this.Br(state.TestLabel); 18 } 19 this.MarkLabel(state.BeginLabel); 20 this.blockStack.Push(state); 21 return state; 22 } 23 // Index=start; 24 // Begin: 25 // 26 // Index++; 27 // Test: 28 // if(Index<N) goto :Begin 29 // 30 // End: 31 /// <summary> 32 /// EndFor 33 /// </summary> 34 public void EndFor() 35 { 36 object expected = this.blockStack.Pop(); 37 ForState state = expected as ForState; 38 if (state == null) 39 { 40 this.ThrowMismatchException(expected); 41 } 42 if (state.Index != null) 43 { 44 //Inc: Index++ 45 this.Ldloc(state.Index); 46 this.Ldc(1); 47 this.Add(); 48 this.Stloc(state.Index); 49 50 this.MarkLabel(state.TestLabel); 51 52 //if(i<n) goto begin 53 this.Ldloc(state.Index);//加载:局部变量 与 常量的区别 54 //加载Length或循环n 55 this.Load(state.End); 56 if (this.GetVariableType(state.End).IsArray) 57 { 58 this.Ldlen(); 59 } 60 this.Blt(state.BeginLabel); 61 } 62 else 63 { //while(true) 64 this.Br(state.BeginLabel); 65 } 66 //如果需要,则添加End标签 67 if (state.RequiresEndLabel) 68 { 69 this.MarkLabel(state.EndLabel); 70 } 71 } 72 73 74 /// <summary> 75 /// ForEach 76 /// </summary> 77 /// <param name="local">当前元素接受变量</param> 78 /// <param name="elementType">元素类型</param> 79 /// <param name="enumeratorType">enumerator类型</param> 80 /// <param name="enumerator">enumerator实例</param> 81 /// <param name="getCurrentMethod">enumerator类型Getcurrent方法</param> 82 public void ForEach(LocalBuilder local, Type elementType, Type enumeratorType, LocalBuilder enumerator, MethodInfo getCurrentMethod) 83 { 84 Check.Require(local, "local"); 85 Check.Require(elementType, "elementType"); 86 Check.Require(enumeratorType, "enumeratorType"); 87 Check.Require(enumerator, "enumerator"); 88 Check.Require(getCurrentMethod, "getCurrentMethod"); 89 90 ForState state = new ForState(local, this.DefineLabel(), this.DefineLabel(), enumerator); 91 this.Br(state.TestLabel); 92 this.MarkLabel(state.BeginLabel); 93 if (enumeratorType == getCurrentMethod.DeclaringType) 94 { 95 this.LoadThis(enumerator, getCurrentMethod); 96 this.ilGen.Emit(OpCodes.Call, getCurrentMethod); 97 } 98 else 99 { 100 this.Call(enumerator, getCurrentMethod); 101 } 102 this.ConvertValue(elementType, this.GetVariableType(local)); 103 this.Stloc(local); 104 this.blockStack.Push(state); 105 } 106 107 // Goto Test 108 //Begin: 109 // local=(elementType)GetCurrent() 110 ///// [ForCode] 111 //:Test 112 // if(MoveNext()==true) Goto Begin 113 //:End 114 115 /// <summary> 116 /// EndForEach 117 /// </summary> 118 /// <param name="moveNextMethod"></param> 119 public void EndForEach(MethodInfo moveNextMethod) 120 { 121 Check.Require(moveNextMethod, "moveNextMethod"); 122 123 object expected = this.blockStack.Pop(); 124 ForState state = expected as ForState; 125 if (state == null) 126 { 127 this.ThrowMismatchException(expected); 128 } 129 this.MarkLabel(state.TestLabel); 130 object var = state.End; 131 if (this.GetVariableType(var) == moveNextMethod.DeclaringType) 132 { 133 this.LoadThis(var, moveNextMethod); 134 this.ilGen.Emit(OpCodes.Call, moveNextMethod); 135 } 136 else 137 { 138 this.Call(var, moveNextMethod); 139 } 140 this.Brtrue(state.BeginLabel); 141 if (state.RequiresEndLabel) 142 { 143 this.MarkLabel(state.EndLabel); 144 } 145 } 146 147 148 /// <summary> 149 /// Break 150 /// </summary> 151 /// <param name="forState"></param> 152 public void Break(object forState) 153 { 154 this.InternalBreakFor(forState, OpCodes.Br); 155 } 156 157 /// <summary> 158 /// IfTrueBreak 159 /// </summary> 160 /// <param name="forState"></param> 161 public void IfTrueBreak(object forState) 162 { 163 this.InternalBreakFor(forState, OpCodes.Brtrue); 164 } 165 166 /// <summary> 167 /// IfFalseBreak 168 /// </summary> 169 /// <param name="forState"></param> 170 public void IfFalseBreak(object forState) 171 { 172 this.InternalBreakFor(forState, OpCodes.Brfalse); 173 } 174 175 176 /// <summary> 177 /// InternalBreakFor:Break 178 /// </summary> 179 /// <param name="userForState"></param> 180 /// <param name="branchInstruction"></param> 181 public void InternalBreakFor(object userForState, OpCode branchInstruction) 182 { 183 foreach (object obj2 in this.blockStack) 184 { 185 ForState state = obj2 as ForState; 186 if ((state != null) && (state == userForState)) 187 { 188 //定义EndLabel 189 if (!state.RequiresEndLabel) 190 { 191 state.EndLabel = this.DefineLabel(); 192 state.RequiresEndLabel = true; 193 } 194 this.ilGen.Emit(branchInstruction, state.EndLabel); 195 break; 196 } 197 } 198 }
方法：
方法定义
1 /// <summary> 2 /// BeginMethod 3 /// </summary> 4 /// <param name="methodName"></param> 5 /// <param name="delegateType"></param> 6 public void BeginMethod(string methodName, Type delegateType) 7 { 8 Check.Require(this.methodOrConstructorBuilder == null, "BeginMethod() could not be called in this context."); 9 Check.Require(methodName, "methodName", Check.NotNullOrEmpty); 10 Check.Require(delegateType, "delegateType"); 11 //通过Invoke方法 来获取参数类型 及返回类型 12 MethodInfo method = delegateType.GetMethod("Invoke"); 13 ParameterInfo[] parameters = method.GetParameters(); 14 Type[] argTypes = new Type[parameters.Length]; 15 for (int i = 0; i < parameters.Length; i++) 16 { 17 argTypes[i] = parameters[i].ParameterType; 18 } 19 this.BeginMethod(method.ReturnType, methodName, argTypes); 20 this.delegateType = delegateType; 21 } 22 23 /// <summary> 24 /// BeginMethod 25 /// </summary> 26 /// <param name="returnType"></param> 27 /// <param name="methodName"></param> 28 /// <param name="argTypes"></param> 29 private void BeginMethod(Type returnType, string methodName, params Type[] argTypes) 30 { 31 //Emit 构建方法的一种 32 //对于定义整个类：可以参考另一种方式 typeBuilder.DefineMethod(targetMethod.Name, MethodAttributes.Public|MethodAttributes.Virtual, targetMethod.ReturnType, paramType); 33 //定义方法体 returnType methodName(argTypes){ } 34 this.dynamicMethod = new DynamicMethod(methodName, returnType, argTypes, serializationModule, true); 35 //获取方法体：写入流 36 this.ilGen = this.dynamicMethod.GetILGenerator();// this.ilGen代表当前方法上下文，所以Ldarg加载的是当前方法的。 在当前类里面，存于this.argList 37 this.methodEndLabel = this.ilGen.DefineLabel(); 38 this.blockStack = new Stack(); 39 this.argList = new ArrayList(); 40 for (int i = 0; i < argTypes.Length; i++) 41 { 42 this.argList.Add(new ArgBuilder(i, argTypes[i])); 43 } 44 } 45 46 47 /// <summary> 48 /// EndMethod 49 /// </summary> 50 /// <returns></returns> 51 public Delegate EndMethod() 52 { 53 Check.Require(this.methodOrConstructorBuilder == null, "EndMethod() could not be called in this context."); 54 //在此之前,通过this.ilGen添加操作代码，最后生成委托 55 56 //要返回的参数,现在在堆栈顶部 57 this.MarkLabel(this.methodEndLabel); 58 this.Ret(); 59 Delegate delegate2 = null; 60 delegate2 = this.dynamicMethod.CreateDelegate(this.delegateType); 61 62 //清空 63 this.dynamicMethod = null; 64 this.delegateType = null; 65 this.ilGen = null; 66 this.blockStack = null; 67 this.argList = null; 68 return delegate2; 69 } 70 71 /// <summary> 72 /// IgnoreReturnValue 73 /// </summary> 74 public void IgnoreReturnValue() 75 { 76 this.Pop(); 77 } 78 79 /// <summary> 80 /// Ret 从当前方法返回，并将返回值（如果存在）从调用方的计算堆栈推送到被调用方的计算堆栈上。 81 /// Do1: 从被调用方的计算堆栈中弹出返回值。 82 /// Do2:将步骤 1 中获取的返回值推送到调用方的计算堆栈中。 83 /// </summary> 84 public void Ret() 85 { 86 this.ilGen.Emit(OpCodes.Ret); 87 }
方法调用
1 /// <summary> 2 /// Call 调用由传递的方法说明符指示的方法。 3 /// </summary> 4 /// <param name="ctor"></param> 5 public void Call(ConstructorInfo ctor) 6 { 7 Check.Require(ctor, "ctor"); 8 9 this.ilGen.Emit(OpCodes.Call, ctor); 10 } 11 12 /// <summary> 13 /// Call 调用由传递的方法说明符指示的方法。 14 /// </summary> 15 /// <param name="methodInfo"></param> 16 public void Call(MethodInfo methodInfo) 17 { 18 Check.Require(methodInfo, "methodInfo"); 19 20 if (methodInfo.IsVirtual) 21 { 22 this.ilGen.Emit(OpCodes.Callvirt, methodInfo); 23 } 24 else if (methodInfo.IsStatic) 25 { 26 this.ilGen.Emit(OpCodes.Call, methodInfo); 27 } 28 else 29 { 30 this.ilGen.Emit(OpCodes.Call, methodInfo); 31 } 32 } 33 34 /// <summary> 35 /// Call 36 /// </summary> 37 /// <param name="thisObj"></param> 38 /// <param name="methodInfo"></param> 39 public void Call(object thisObj, MethodInfo methodInfo) 40 { 41 Check.Require(thisObj, "thisObj"); 42 Check.Require(methodInfo, "methodInfo"); 43 44 this.VerifyParameterCount(methodInfo, 0); 45 this.LoadThis(thisObj, methodInfo); 46 this.Call(methodInfo); 47 } 48 49 /// <summary> 50 /// Call 51 /// </summary> 52 /// <param name="thisObj"></param> 53 /// <param name="methodInfo"></param> 54 /// <param name="param1"></param> 55 public void Call(object thisObj, MethodInfo methodInfo, object param1) 56 { 57 Check.Require(thisObj, "thisObj"); 58 Check.Require(methodInfo, "methodInfo"); 59 60 this.VerifyParameterCount(methodInfo, 1); 61 //Loadthis：加载this对象,并且转换为方法声明类的类型 62 this.LoadThis(thisObj, methodInfo); 63 //LoadParam：加载参数,并且转换为方法参数所定义的类型 64 this.LoadParam(param1, 1, methodInfo); 65 this.Call(methodInfo); 66 } 67 68 /// <summary> 69 /// Call 70 /// </summary> 71 /// <param name="thisObj"></param> 72 /// <param name="methodInfo"></param> 73 /// <param name="param1"></param> 74 /// <param name="param2"></param> 75 public void Call(object thisObj, MethodInfo methodInfo, object param1, object param2) 76 { 77 Check.Require(thisObj, "thisObj"); 78 Check.Require(methodInfo, "methodInfo"); 79 80 this.VerifyParameterCount(methodInfo, 2); 81 this.LoadThis(thisObj, methodInfo); 82 this.LoadParam(param1, 1, methodInfo); 83 this.LoadParam(param2, 2, methodInfo); 84 this.Call(methodInfo); 85 } 86 87 /// <summary> 88 /// Call 89 /// </summary> 90 /// <param name="thisObj"></param> 91 /// <param name="methodInfo"></param> 92 /// <param name="param1"></param> 93 /// <param name="param2"></param> 94 /// <param name="param3"></param> 95 public void Call(object thisObj, MethodInfo methodInfo, object param1, object param2, object param3) 96 { 97 Check.Require(thisObj, "thisObj"); 98 Check.Require(methodInfo, "methodInfo"); 99 100 this.VerifyParameterCount(methodInfo, 3); 101 this.LoadThis(thisObj, methodInfo); 102 this.LoadParam(param1, 1, methodInfo); 103 this.LoadParam(param2, 2, methodInfo); 104 this.LoadParam(param3, 3, methodInfo); 105 this.Call(methodInfo); 106 } 107 108 /// <summary> 109 /// Call 110 /// </summary> 111 /// <param name="thisObj"></param> 112 /// <param name="methodInfo"></param> 113 /// <param name="param1"></param> 114 /// <param name="param2"></param> 115 /// <param name="param3"></param> 116 /// <param name="param4"></param> 117 public void Call(object thisObj, MethodInfo methodInfo, object param1, object param2, object param3, object param4) 118 { 119 Check.Require(thisObj, "thisObj"); 120 Check.Require(methodInfo, "methodInfo"); 121 122 this.VerifyParameterCount(methodInfo, 4); 123 this.LoadThis(thisObj, methodInfo); 124 //LoadParam:将参数变量转换成 方法中第N个参数的类型,加载到堆栈 125 this.LoadParam(param1, 1, methodInfo); 126 this.LoadParam(param2, 2, methodInfo); 127 this.LoadParam(param3, 3, methodInfo); 128 this.LoadParam(param4, 4, methodInfo); 129 this.Call(methodInfo); 130 } 131 132 /// <summary> 133 /// Call 134 /// </summary> 135 /// <param name="thisObj"></param> 136 /// <param name="methodInfo"></param> 137 /// <param name="param1"></param> 138 /// <param name="param2"></param> 139 /// <param name="param3"></param> 140 /// <param name="param4"></param> 141 /// <param name="param5"></param> 142 public void Call(object thisObj, MethodInfo methodInfo, object param1, object param2, object param3, object param4, object param5) 143 { 144 Check.Require(thisObj, "thisObj"); 145 Check.Require(methodInfo, "methodInfo"); 146 147 this.VerifyParameterCount(methodInfo, 5); 148 this.LoadThis(thisObj, methodInfo); 149 this.LoadParam(param1, 1, methodInfo); 150 this.LoadParam(param2, 2, methodInfo); 151 this.LoadParam(param3, 3, methodInfo); 152 this.LoadParam(param4, 4, methodInfo); 153 this.LoadParam(param5, 5, methodInfo); 154 this.Call(methodInfo); 155 } 156 157 /// <summary> 158 /// Call 159 /// </summary> 160 /// <param name="thisObj"></param> 161 /// <param name="methodInfo"></param> 162 /// <param name="param1"></param> 163 /// <param name="param2"></param> 164 /// <param name="param3"></param> 165 /// <param name="param4"></param> 166 /// <param name="param5"></param> 167 /// <param name="param6"></param> 168 public void Call(object thisObj, MethodInfo methodInfo, object param1, object param2, object param3, object param4, object param5, object param6) 169 { 170 Check.Require(thisObj, "thisObj"); 171 Check.Require(methodInfo, "methodInfo"); 172 173 this.VerifyParameterCount(methodInfo, 6); 174 this.LoadThis(thisObj, methodInfo); 175 this.LoadParam(param1, 1, methodInfo); 176 this.LoadParam(param2, 2, methodInfo); 177 this.LoadParam(param3, 3, methodInfo); 178 this.LoadParam(param4, 4, methodInfo); 179 this.LoadParam(param5, 5, methodInfo); 180 this.LoadParam(param6, 6, methodInfo); 181 this.Call(methodInfo); 182 } 183 184 185 /// <summary> 186 /// VerifyParameterCount 187 /// </summary> 188 /// <param name="methodInfo"></param> 189 /// <param name="expectedCount"></param> 190 public void VerifyParameterCount(MethodInfo methodInfo, int expectedCount) 191 { 192 Check.Require(methodInfo, "methodInfo"); 193 194 if (methodInfo.GetParameters().Length != expectedCount) 195 { 196 throw new Exception("ParameterCountMismatch"); 197 } 198 }