通过 Reflection.Emit 生成代理仅在使用调试启动时有效

Question

大学时的一个任务是使用 Reflection.Emit 实现一个简单的代理生成器/拦截器机制。 我想出了以下程序。

它似乎在调试模式 [F5]（调试 -> 开始调试）下在 Visual Studio 中工作得很好，但在不调试的情况下启动时大多数时候会崩溃[Ctrl + F5]（调试->开始而不调试）。

这两种模式有什么区别？ （我不指的是调试<>发布模式）。 该问题出现在多台计算机/设置上（Win XP SP3 32 位和 64 位、Windows 7 32 位）。

点击获取pastebin。

// The proxy generator; I assume that the error is buried along the lines emitting the IL code
public static class ProxyGenerator
{
    public static T Create<T>(object obj, IInterception interception)
    {
        Type type = obj.GetType();

        TypeBuilder proxy = DefineProxy(type);

        FieldBuilder wrappedField = DefinePrivateField(proxy, "wrappedObject", type);
        FieldBuilder interceptionField = DefinePrivateField(proxy, "interception", interception.GetType());

        DefineConstructor(proxy, wrappedField, interceptionField);
        DefineInterfaceMethods(type, proxy, wrappedField, interceptionField);

        return (T) Activator.CreateInstance(proxy.CreateType(), obj, interception);
    }

    private static TypeBuilder DefineProxy(Type type)
    {
        var assemblyName = new AssemblyName {Name = "GeneratedProxyAssembly"};
        AssemblyBuilder assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(
            assemblyName, AssemblyBuilderAccess.Run);

        ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("GeneratedProxyModule");

        return moduleBuilder.DefineType(
            type.Name + "Proxy",
            type.Attributes,
            typeof (object),
            type.GetInterfaces());
    }

    private static FieldBuilder DefinePrivateField(TypeBuilder typeBuilder, string fieldName, Type fieldType)
    {
        return typeBuilder.DefineField(fieldName, fieldType, FieldAttributes.Private);
    }

    private static void DefineConstructor(TypeBuilder typeBuilder, params FieldBuilder[] parameters)
    {
        ConstructorBuilder ctor = typeBuilder.DefineConstructor(
            MethodAttributes.Public, CallingConventions.Standard, parameters.Select(f => f.FieldType).ToArray());

        // Emit constructor
        ILGenerator g = ctor.GetILGenerator();

        // Load "this" pointer and call base constructor
        g.Emit(OpCodes.Ldarg_0);
        g.Emit(OpCodes.Call, typeof(object).GetConstructor(new Type[0]));

        // Store parameters in private fields
        for (int i = 0; i < parameters.Length; i++)
        {
            // Load "this" pointer and parameter and store paramater in private field
            g.Emit(OpCodes.Ldarg_0);
            g.Emit(OpCodes.Ldarg, i + 1);
            g.Emit(OpCodes.Stfld, parameters[i]);
        }

        // Return
        g.Emit(OpCodes.Ret);
    }

    private static void DefineInterfaceMethods(Type type, TypeBuilder proxy, FieldInfo wrappedField, FieldInfo interceptionField)
    {
        // Loop through all interface methods
        foreach (MethodInfo interfaceMethod in type.GetInterfaces().SelectMany(i => i.GetMethods()))
        {
            MethodInfo method = type.GetMethod(interfaceMethod.Name);

            MethodBuilder methodBuilder = proxy.DefineMethod(
                method.Name,
                method.Attributes,
                method.ReturnType,
                method.GetParameters().Select(p => p.ParameterType).ToArray());

            // Emit method
            ILGenerator g = methodBuilder.GetILGenerator();

            // Intercept before
            EmitMethodCallOnMember(g, interceptionField, "Before", false);

            // Delegate method call
            EmitMethodCallOnMember(g, wrappedField, method.Name, true);

            // Intercept after
            EmitMethodCallOnMember(g, interceptionField, "After", false);

            // Return
            g.Emit(OpCodes.Ret);
        }
    }

    private static void EmitMethodCallOnMember(ILGenerator g, FieldInfo field, string methodName, bool delegateParameters)
    {
        // Load "this" pointer to get address of field
        g.Emit(OpCodes.Ldarg_0);
        g.Emit(OpCodes.Ldflda, field);

        MethodInfo method = field.FieldType.GetMethod(methodName);
        if (delegateParameters)
        {
            // Load method parameters
            for (int i = 0; i < method.GetParameters().Length; i++)
            {
                g.Emit(OpCodes.Ldarg, i + 1);
            }
        }

        // Emit call
        g.Emit(OpCodes.Call, method);
    }
}

// Some infrastructure
public interface IInterception
{
    void Before();
    void After();
}

public class LogInterception : IInterception
{
    public void Before()
    {
        Console.WriteLine("Before ... ");
    }

    public void After()
    {
        Console.WriteLine("... After");
    }
}

public interface ITest
{
    string DoSomething(string s1, string s2);
}

public class Test : ITest
{
    public string DoSomething(string s1, string s2)
    {
        Console.WriteLine("... doing something ...");
        return s1 + s2;
    }
}

 // The test program, expected output is down below

internal class Program
{
    internal static void Main(string[] args)
    {
        var test = new Test();
        var proxy = ProxyGenerator.Create<ITest>(test, new LogInterception());

        Console.WriteLine(test.DoSomething("Hello", " World"));
        Console.WriteLine("----------------------------------------");
        Console.WriteLine(proxy.DoSomething("Hello", " World"));

        Console.ReadKey();
    }
}

另一个问题：缩小此类问题范围的最佳方法是什么？ 我尝试将生成的程序集保存到磁盘并在 Reflector 中打开生成的 dll，但它似乎是空的。

如上所述，当在调试模式下启动时，程序似乎可以工作并打印以下输出。

... doing something ...
Hello World
----------------------------------------
Before ...
... doing something ...
... After
Hello World

感谢您抽出时间。

Answer 1

尝试在项目设置选项卡上显式设置x86模式。

仅当在x64或中运行程序时，我才遇到致命异常AnyCpu 模式。


啊，我明白了。将 Ldflda 替换为 Ldfld。即使没有调试器它也能正常工作（我刚刚运行了.exe）。
Ldflda 用于使用 ref 或 out 关键字作为参数传递到方法中的字段。