替换方法 MethodBody 中的指令

Question

（首先，这是一篇非常长的文章，但不用担心：我已经实现了所有这些，我只是询问您的意见或可能的替代方案。）

我在实现以下内容时遇到了困难；我希望得到一些帮助：

1. 我得到一个 Type 作为参数。
2. 我使用反射定义了一个子类。请注意，我并不打算修改原始类型，而是创建一个新类型。

3. 我为原始类的每个字段创建一个属性，如下所示：

   公共类 OriginalClass {
       私有 int x;
   }
   
   
   公共类子类：OriginalClass {
       私有 int x;
   
       公共 int X {
           得到{返回x; }
           设置 { x = 值; }
       }
   
   }
   

4. 对于超类的每个方法，我在子类中创建一个类似的方法。方法的主体必须相同，只是我将指令 ldfld x 替换为 callvirt this.get_X，也就是说，我不是直接从字段读取，而是调用 get 访问器.

我在执行第 4 步时遇到了麻烦。我知道您不应该像这样操作代码，但我确实需要这样做。

以下是我的尝试：

尝试#1：使用 Mono.Cecil。这将使我能够将方法的主体解析为人类可读的指令，并轻松替换指令。但是，原始类型不在 .dll 文件中，因此我找不到使用 Mono.Cecil 加载它的方法。将类型写入 .dll，然后加载它，然后修改它并将新类型写入磁盘（我认为这是使用 Mono.Cecil 创建类型的方式），然后加载它看起来像一个巨大的 开销。

尝试#2：使用 Mono.Reflection。这也允许我将正文解析为指令，但随后我不支持替换指令。我已经使用 Mono.Reflection 实现了一个非常丑陋且低效的解决方案，但它还不支持包含 try-catch 语句的方法（尽管我想我可以实现这个），而且我担心可能还有其他场景它不会工作，因为我以一种不寻常的方式使用 ILGenerator 。而且，它非常难看；）。这就是我所做的：

private void TransformMethod(MethodInfo methodInfo) {

    // Create a method with the same signature.
    ParameterInfo[] paramList = methodInfo.GetParameters();
    Type[] args = new Type[paramList.Length];
    for (int i = 0; i < args.Length; i++) {
        args[i] = paramList[i].ParameterType;
    }
    MethodBuilder methodBuilder = typeBuilder.DefineMethod(
        methodInfo.Name, methodInfo.Attributes, methodInfo.ReturnType, args);
    ILGenerator ilGen = methodBuilder.GetILGenerator();

    // Declare the same local variables as in the original method.
    IList<LocalVariableInfo> locals = methodInfo.GetMethodBody().LocalVariables;
    foreach (LocalVariableInfo local in locals) {
        ilGen.DeclareLocal(local.LocalType);
    }

    // Get readable instructions.
    IList<Instruction> instructions = methodInfo.GetInstructions();

    // I first need to define labels for every instruction in case I
    // later find a jump to that instruction. Once the instruction has
    // been emitted I cannot label it, so I'll need to do it in advance.
    // Since I'm doing a first pass on the method's body anyway, I could
    // instead just create labels where they are truly needed, but for
    // now I'm using this quick fix.
    Dictionary<int, Label> labels = new Dictionary<int, Label>();
    foreach (Instruction instr in instructions) {
        labels[instr.Offset] = ilGen.DefineLabel();
    }

    foreach (Instruction instr in instructions) {

        // Mark this instruction with a label, in case there's a branch
        // instruction that jumps here.
        ilGen.MarkLabel(labels[instr.Offset]);

        // If this is the instruction that I want to replace (ldfld x)...
        if (instr.OpCode == OpCodes.Ldfld) {
            // ...get the get accessor for the accessed field (get_X())
            // (I have the accessors in a dictionary; this isn't relevant),
            MethodInfo safeReadAccessor = dataMembersSafeAccessors[((FieldInfo) instr.Operand).Name][0];
            // ...instead of emitting the original instruction (ldfld x),
            // emit a call to the get accessor,
            ilGen.Emit(OpCodes.Callvirt, safeReadAccessor);

        // Else (it's any other instruction), reemit the instruction, unaltered.
        } else {
            Reemit(instr, ilGen, labels);
        }

    }

}

可怕的 Reemit 方法来了：

private void Reemit(Instruction instr, ILGenerator ilGen, Dictionary<int, Label> labels) {

    // If the instruction doesn't have an operand, emit the opcode and return.
    if (instr.Operand == null) {
        ilGen.Emit(instr.OpCode);
        return;
    }

    // Else (it has an operand)...

    // If it's a branch instruction, retrieve the corresponding label (to
    // which we want to jump), emit the instruction and return.
    if (instr.OpCode.FlowControl == FlowControl.Branch) {
        ilGen.Emit(instr.OpCode, labels[Int32.Parse(instr.Operand.ToString())]);
        return;
    }

    // Otherwise, simply emit the instruction. I need to use the right
    // Emit call, so I need to cast the operand to its type.
    Type operandType = instr.Operand.GetType();
    if (typeof(byte).IsAssignableFrom(operandType))
        ilGen.Emit(instr.OpCode, (byte) instr.Operand);
    else if (typeof(double).IsAssignableFrom(operandType))
        ilGen.Emit(instr.OpCode, (double) instr.Operand);
    else if (typeof(float).IsAssignableFrom(operandType))
        ilGen.Emit(instr.OpCode, (float) instr.Operand);
    else if (typeof(int).IsAssignableFrom(operandType))
        ilGen.Emit(instr.OpCode, (int) instr.Operand);
    ... // you get the idea. This is a pretty long method, all like this.
}

分支指令是一种特殊情况，因为 instr.Operand 是 SByte ，但 Emit 需要一个 Label 类型的操作数。因此需要字典标签。

正如你所看到的，这非常可怕。更重要的是，它并不适用于所有情况，例如包含 try-catch 语句的方法，因为我没有使用方法 BeginExceptionBlock、BeginCatchBlock 发出它们， ILGenerator 等。这变得越来越复杂。我想我可以做到：MethodBody 有一个ExceptionHandlingClause 列表，其中应包含执行此操作所需的信息。但无论如何我不喜欢这个解决方案，所以我会将其保存为最后的解决方案。

尝试#3：直接复制 MethodBody.GetILAsByteArray() 返回的字节数组，因为我只想将一条指令替换为另一条指令相同的大小会产生完全相同的结果：它在堆栈上加载相同类型的对象，等等。因此不会有任何标签移动，并且一切都应该完全相同。我已经这样做了，替换了数组的特定字节，然后调用 MethodBuilder.CreateMethodBody(byte[], int)，但我仍然遇到同样的错误，但有异常，而且我仍然需要声明局部变量，否则我会收到错误...即使我只是复制方法的主体并且不更改任何内容。 所以这更有效，但我仍然必须处理异常等。

叹息。

这是尝试 #3 的实现，以防有人感兴趣：（

private void TransformMethod(MethodInfo methodInfo, Dictionary<string, MethodInfo[]> dataMembersSafeAccessors, ModuleBuilder moduleBuilder) {

    ParameterInfo[] paramList = methodInfo.GetParameters();
    Type[] args = new Type[paramList.Length];
    for (int i = 0; i < args.Length; i++) {
        args[i] = paramList[i].ParameterType;
    }
    MethodBuilder methodBuilder = typeBuilder.DefineMethod(
        methodInfo.Name, methodInfo.Attributes, methodInfo.ReturnType, args);

    ILGenerator ilGen = methodBuilder.GetILGenerator();

    IList<LocalVariableInfo> locals = methodInfo.GetMethodBody().LocalVariables;
    foreach (LocalVariableInfo local in locals) {
        ilGen.DeclareLocal(local.LocalType);
    }

    byte[] rawInstructions = methodInfo.GetMethodBody().GetILAsByteArray();
    IList<Instruction> instructions = methodInfo.GetInstructions();

    int k = 0;
    foreach (Instruction instr in instructions) {

        if (instr.OpCode == OpCodes.Ldfld) {

            MethodInfo safeReadAccessor = dataMembersSafeAccessors[((FieldInfo) instr.Operand).Name][0];

            // Copy the opcode: Callvirt.
            byte[] bytes = toByteArray(OpCodes.Callvirt.Value);
            for (int m = 0; m < OpCodes.Callvirt.Size; m++) {
                rawInstructions[k++] = bytes[put.Length - 1 - m];
            }

            // Copy the operand: the accessor's metadata token.
            bytes = toByteArray(moduleBuilder.GetMethodToken(safeReadAccessor).Token);
            for (int m = instr.Size - OpCodes.Ldfld.Size - 1; m >= 0; m--) {
                rawInstructions[k++] = bytes[m];
            }

        // Skip this instruction (do not replace it).
        } else {
            k += instr.Size;
        }

    }

    methodBuilder.CreateMethodBody(rawInstructions, rawInstructions.Length);

}


private static byte[] toByteArray(int intValue) {
    byte[] intBytes = BitConverter.GetBytes(intValue);
    if (BitConverter.IsLittleEndian)
        Array.Reverse(intBytes);
    return intBytes;
}



private static byte[] toByteArray(short shortValue) {
    byte[] intBytes = BitConverter.GetBytes(shortValue);
    if (BitConverter.IsLittleEndian)
        Array.Reverse(intBytes);
    return intBytes;
}

我知道它不太漂亮。抱歉。我很快把它放在一起，看看它是否可行。）

我没有太大希望，但有人可以建议吗还有比这更好的吗？

抱歉这篇文章太长了，谢谢。

---

更新#1：啊……我刚刚读过这个msdn 文档：

[CreateMethodBody 方法] 是 目前不完全支持。这 用户无法提供位置 令牌修复和异常处理程序。

在尝试任何事情之前我真的应该阅读文档。有一天我会了解到...

这意味着选项 #3 不能支持 try-catch 语句，这使得它对我来说毫无用处。我真的必须使用可怕的#2吗？ ：/ 帮助！ :P

---

更新 #2: 我已经成功实现了支持异常的尝试 #2。它很丑陋，但它有效。当我稍微完善代码时，我会将其发布在这里。这不是优先事项，因此可能需要几周后才能完成。只是让您知道，以防有人对此感兴趣。

感谢您的建议。

Answer 1

我正在尝试做一件非常相似的事情。我已经尝试过你的#1方法，我同意，这会产生巨大的开销（尽管我还没有精确测量）。

有一个 DynamicMethod 类 - 根据MSDN - “定义并表示可以编译、执行和丢弃的动态方法。丢弃的方法可用于垃圾收集。”

就性能而言，听起来不错。

使用 ILReader我可以将正常的 MethodInfo 转换为 动态方法。当您查看 ILReader 库，您可以找到我们需要的代码：

byte[] code = body.GetILAsByteArray();
ILReader reader = new ILReader(method);
ILInfoGetTokenVisitor visitor = new ILInfoGetTokenVisitor(ilInfo, code);
reader.Accept(visitor);

ilInfo.SetCode(code, body.MaxStackSize);

理论上，这让我们可以修改现有方法的代码并将其作为动态方法运行。

我现在唯一的问题是 Mono.Cecil 不允许我们保存方法的字节码（至少我找不到方法）。当您下载 Mono.Cecil 源代码时，它有一个 CodeWriter 类来完成任务，但它不是公开的。

我对这种方法的另一个问题是 MethodInfo -> DynamicMethod 转换仅适用于 ILReader。但这是可以解决的。

调用的性能取决于我使用的方法。调用短方法 10'000'000 次后，我得到以下结果：

• Reflection.Invoke - 14 sec
• DynamicMethod.Invoke - 26 sec
• DynamicMethod with delegates - 9 sec

接下来我要尝试的是：

1. 使用 Cecil 加载原始方法
2. 修改Cecil 中的代码
3. 从程序集中剥离未修改的代码
4. 将程序集保存为 MemoryStream 而不是文件 使用
5. 反射加载新程序集（从内存）
6. 如果是一次性调用，则使用反射调用方法 调用方法
7. 生成 DynamicMethod 的委托并存储它们我想定期调用该方法，
8. 尝​​试找出是否可以从内存中卸载不需要的程序集（释放 MemoryStream 和运行时程序集表示），

这听起来像是很多工作，但可能不起作用，我们会看到:)

我希望它有帮助，让我知道你的想法。

Answer 2

您尝试过 PostSharp 吗？我认为它已经通过 关于字段访问方面。

Answer 3

也许我理解错误，但如果您想扩展，拦截类的现有实例，您可以查看 城堡动态代理。

Answer 4

您必须首先将基类中的属性定义为虚拟或抽象。
此外，这些字段需要修改为“受保护”而不是“私有”。

或者我在这里误解了什么？

Answer 5

使用 SetMethodBody 代替 CreateMethodBody 怎么样（这将是 #3 的变体）？这是 .NET 4.5 中引入的新方法，似乎支持异常和修复。

Answer 6

基本上，您正在复制原始类的程序文本，然后对其进行定期更改。您当前的方法是复制该类的对象代码并对其进行修补。我能理解为什么这看起来很丑；你的工作水平非常低。

这似乎很容易通过源到源程序转换来完成。
为了精度，它对源代码的 AST 进行操作，而不是对源代码本身进行操作。请参阅 DMS Software Reengineering Toolkit 了解此类工具。 DMS 具有完整的 C# 4.0 解析器。