Nbear讲解 之核心类 DynamicMethodFactory

DynamicMethodFactory的作用就像它的名字一样,构建动态的方法。

所产生的动态方法基于两种委托类型：分别对应实例方法和静态方法，下面重点说静态的动态方法。

public delegate object StaticDynamicMethodProxyHandler(object[] paramObjs);
public delegate object DynamicMethodProxyHandler(object ownerInstance, object[] paramObjs);

基于委托StaticDynamicMethodProxyHandler, 动态创建一个方法,用StaticDynamicMethodProxyHandler传进来的参数作为genericMethodInfo方法的参数进行调用。

传参数的工作由LoadParameters()方法完成，因为委托中参数是用objcet数组的形式传进来的,所以现在就要将object数组的对象按照genericMethodInfo方法中的参数列表进行类型转换,

然后加载到堆栈内。

   protected static StaticDynamicMethodProxyHandler DoGetStaticMethodDelegate(
            Module targetModule, 
            MethodInfo genericMethodInfo, 
            params Type[] genericParameterTypes)
        { 

            //Create a dynamic method proxy delegate used to call the specified methodinfo
            CodeGenerator gen = new CodeGenerator(targetModule);
            gen.BeginMethod("dm" + Guid.NewGuid().ToString("N"), typeof(StaticDynamicMethodProxyHandler));

            MethodInfo makeGenericMethodInfo = MakeMethodGeneric(genericMethodInfo, genericParameterTypes);
            LoadParameters(gen, makeGenericMethodInfo.GetParameters(), true);//将StaticDynamicMethodProxyHandler委托传入的参数,转给genericMethodInfo方法调用
            gen.Call(makeGenericMethodInfo);

            CastValueToObject(gen, makeGenericMethodInfo.ReturnType);

            return (StaticDynamicMethodProxyHandler)gen.EndMethod();
        }

LoadParameters方法：out参数类型与ref参数类型的差别如下，

C#:  void ILStudy(out int abc,ref int acc,ref string[] aaa,out string[] ccc)
IL： void ILStudy([out] int32& abc,int32& acc,string[]& aaa,[out] string[]& ccc)
在这里注意区分 ParameterInfo[] pis 参数和gen.Ldarg(0)参数的差别:gen.Ldarg(0)是新定义的方法的参数,也就是所基于的委托的参数列表。
而pis是当前动态方法里面所要调用的方法genericMethodInfo的参数列表。

      private static void LoadParameters(CodeGenerator gen, ParameterInfo[] pis, bool isMethodStatic)
        {
            Check.Require(gen, "gen");

            //gen.Ldarg所加载的是从委托那边定义的参数，即 object DynamicMethodProxyHandler(object ownerInstance, object[] paramObjs);
            //而ParameterInfo[] pis参数的作用,就是将委托中paramObjs，转化为pis所对应的参数类型，然后调用参数列表所对应的方法
            if (pis != null)
            {
                for (int i = 0; i < pis.Length; ++i)
                {  //加载委托中参数 object[] paramObjs
                    if (isMethodStatic)
                    {
                        gen.Ldarg(0);//Ldarg是针对产生gen的方法的上下文决定的，方法上下文有参数列表
                    }
                    else
                    {  //实例方法 arg0 是this对象,所以第一个参数是arg1
                        gen.Ldarg(1);
                    }
                    //将索引值 index 推送到堆栈上。
                    gen.Ldc(i);

                    Type srcType = pis[i].ParameterType;
                    string str = srcType.ToString();

                    //对比方法
                   //IL： void ILStudy([out] int32& abc,int32& acc,string[]& aaa,[out] string[]& ccc)
                   //C#:  void ILStudy(out int abc,ref int acc,ref string[] aaa,out string[] ccc)
                    if (str.EndsWith("&"))
                    {
                        srcType = CommonUtils.GetType(str.Substring(0, str.Length - 1));
                    }

                    if (str.EndsWith("&")) //ref or out param
                    {
                        if (srcType.IsValueType && (pis[i].Attributes & ParameterAttributes.Out) != ParameterAttributes.Out) //ref value param
                        {  
                            //根据object类型的指令：将数组第i个数据，取为object形式
                            gen.Ldelem(typeof(object));
                            gen.Unbox(srcType);
                        }
                        else
                        {
                            if (srcType.IsValueType && srcType != typeof(object)) //out value param
                            {   
                                //先保存，srcType的初始类型
                                gen.LoadDefaultValue(srcType);
                                gen.Box(srcType);
                                gen.Stelem(typeof(object));

                                if (isMethodStatic)
                                {
                                    gen.Ldarg(0);
                                }
                                else
                                {
                                    gen.Ldarg(1);
                                }
                                gen.Ldc(i);
                                gen.Ldelem(typeof(object));
                                gen.Unbox(srcType);
                            }
                            else //ref or out class param
                            {
                                gen.Ldelema(typeof(object));
                            }
                        }
                    }
                    else
                    {
                        gen.Ldelem(typeof(object));
                        //转为实际类型
                        if (srcType.IsValueType)
                        {
                            gen.UnboxAny(srcType);
                        }
                        else if (srcType != typeof(object))
                        {
                            gen.Castclass(srcType);
                        }
                    }
                }
            }
        }