c# - 动态类型创建中的 MethodBuilder.CreateMethodBody() 问题

对于实验，我试图从源类型读取方法主体(使用 GetILAsByteArray() )并将其添加到新类型(使用 CreateMethodBody() )。

我的源类就是这样

public class FullClass
{
    public string Test(string data)
    {
        return data;
    }
    public string Test2(string data)
    {
        return data;
    }
    public string Test5(string data, string data1)
    {
        return data + data1;
    }
}

为此代码生成的 IL(使用反射器获取)

.method public hidebysig instance string Test(string data) cil managed
{
    .maxstack 1
    .locals init (
        [0] string CS$1$0000)
    L_0000: nop
    L_0001: ldarg.1
    L_0002: stloc.0
    L_0003: br.s L_0005
    L_0005: ldloc.0
    L_0006: ret
}

但是从我的新类型生成的 IL 看起来像这样

.method public hidebysig virtual instance string Test(string) cil managed
{
    .maxstack 0
    L_0000: nop
    L_0001: ldarg.1
    L_0002: stloc.0
    L_0003: br.s L_0005
    L_0005: ldloc.0
    L_0006: ret
}

不同之处在于 maxstack 值和 .locals 指令。我不明白为什么我的实际类会生成本地变量，尽管它没有任何局部变量？

为什么 .maxstack 值存在差异，因为我使用来自源的相同 IL 来创建新类型。？

因此，在调用该方法时，我收到错误 “公共(public)语言运行时检测到无效程序”。

我创建 Dynamic 类型的代码如下所示

public static class Mixin<Target>
    {

       public static Target compose<TSource>()
        {
            Type newType = null;

            AppDomain currentDom = Thread.GetDomain();

            AssemblyName DAssembly = new AssemblyName();
            DAssembly.Name = "DynamicTypesAssembly";

            AssemblyBuilder DAssemblyBldr = currentDom.DefineDynamicAssembly(
                               DAssembly,
                               AssemblyBuilderAccess.RunAndSave);



            ModuleBuilder DModuleBldr = DAssemblyBldr.DefineDynamicModule(DAssembly.Name, DAssembly.Name + ".dll", false);
         //   var DInterface = EmitInterface(DModuleBldr);
            TypeBuilder TypeBldr = DModuleBldr.DefineType("WorkOut.DType",
                    TypeAttributes.Public | TypeAttributes.BeforeFieldInit | TypeAttributes.Serializable
                    ,typeof(object), new[] { typeof(Target) });

            //TypeBldr.AddInterfaceImplementation(typeof(DInterface));

            var methodCol = typeof(Target).GetMethods(BindingFlags.Public| BindingFlags.Instance);

            foreach (var ms in methodCol)
            {
                var paramCol = ms.GetParameters();
                var paramTypeArray = paramCol.Select(x => x.ParameterType).ToArray();
                var paramNameArray = paramCol.Select(x=>x.Name).ToArray();
                MethodBuilder MthdBldr = TypeBldr.DefineMethod(ms.Name,
                                  MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.HideBySig,
                                  ms.ReturnType,
                                  paramTypeArray);

                for(int i=0;i<paramCol.Count();i++)
                {
                    MthdBldr.DefineParameter(i+1, ParameterAttributes.None, paramNameArray[i]);
                }


                MethodInfo[] methodInfos = typeof(TSource).GetMethods(BindingFlags.Public | BindingFlags.NonPublic |
                             BindingFlags.Static | BindingFlags.Instance);

                for (int i = 0; i < methodInfos.Count(); i++)
                {
                    var paramSrc = methodInfos[i].GetParameters();
                    var paramSrcTypeArray = paramSrc.Select(x => x.ParameterType).ToArray();

                    if (methodInfos[i].Name == ms.Name && methodInfos[i].ReturnType == ms.ReturnType && paramSrc.Count() == paramCol.Count() && paramTypeArray.SequenceEqual(paramSrcTypeArray))
                     {
                        var ILcodes = methodInfos[i].GetMethodBody().GetILAsByteArray();
                        var ilGen = MthdBldr.GetILGenerator();
                        //ilGen.Emit(OpCodes.Ldarg_0); //Load the 'this' reference onto the evaluation stack
                        //ilGen.Emit(OpCodes.Initobj);
                        MthdBldr.CreateMethodBody(ILcodes, ILcodes.Length);
                        //ilGen.Emit(OpCodes.Ret);
                        break;
                    }
                }

            }
            newType = TypeBldr.CreateType();
            DAssemblyBldr.Save("a.dll");
            return (Target)Activator.CreateInstance(newType);
        }

调用它的代码是

     var resMix = Mixin<ITest>.compose<FullClass>();
     var returned1 = resMix.Test("sam");

编辑: 而 ITest (Target) 接口(interface)是

public interface ITest
{
     string Test(string data);
}

编辑:

评论这一行时

  //var ilGen = MthdBldr.GetILGenerator();

maxstack 变成 .maxstack 16

我针对 PEverify 工具对新的 dll 进行了检查，这给出了以下错误

WorkOut.DType::Test][offset 0x00000002] 无法识别的局部变量号。

任何帮助真的很感激.... :)

最佳答案

正如关于 CreateMethodBody 的 MSDN 页面所说，这不是完全支持的。

该实现很可能不会将 IL 解析为字节数组，因此它突然将 maxstack 设置为 16。

如果您为该方法创建一个 ILGenerator，它会将方法 maxstack 设置为零。当您使用不同的 Emit 重载时，ILGenerator 将增加它。由于您没有这样做，并且使用 CreateMethodBody，它会保持为零。这解释了差异。

对于不涉及简单代码的场景，CreateMethodBody 绝对是有问题的。每个采用元数据标记的操作码都将不可用，因为当您创建字节数组时，您不知道模块范围内的有限标记。它不允许您发出异常处理程序。

长话短说，实际上 CreateMethodBody 毫无意义。

如果你想继续实验，我建议你使用我的 reflection IL reader 来获取方法指令的表示，然后使用 ILGenerator 在方法构建器中重现方法体。

关于c# - 动态类型创建中的 MethodBuilder.CreateMethodBody() 问题，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/4460859/