C# 运行时替换方法（需要unsafe编译）

/* https://stackoverflow.com/questions/7299097/dynamically-replace-the-contents-of-a-c-sharp-method
   For .NET 4 and above

"C:Program Files (x86)MSBuild14.0Bincsc.exe" /unsafe+ /out:replacemethod.exe replacemethod.cs && start "replacemethod.exe" replacemethod.exe
PrintInfo: Version x64 Release

1. Replace Instance Method Class1.Demo()
Demo
Replace result: True
Foo

2. Replace Instance Overload of Method Class1.Demo(10)
Demo: 10
Replace result: True
Foo: 10

3. Replace Static Method Class1.DemoStatic()
DemoStatic
Replace result: True
FooStatic

Press any key to EXIT...
*/

using System;
using System.Reflection;
using System.Runtime.CompilerServices;

class Program {
    public static void Main(params string[] args){
        PrintInfo();
        Console.WriteLine();

        Test();

        Console.Write("
Press any key to EXIT...");
        Console.ReadKey(true);
    }

    public static void PrintInfo() {
        Console.Write("PrintInfo: ");
        if (IntPtr.Size == 4) {
#if DEBUG
            Console.WriteLine("Version x86 Debug");
#else
            Console.WriteLine("Version x86 Release");
#endif
        } else {
#if DEBUG
            Console.WriteLine("Version x64 Debug");
#else
            Console.WriteLine("Version x64 Release");
#endif
        }
    }

    public static void Test() {
        Console.WriteLine("1. Replace Instance Method Class1.Demo()");
        var o = new Class1();
        o.Demo();
        var r = CSharpUtils.ReplaceMethod(typeof(Class1), "Demo", typeof(Program), "Foo");
        Console.WriteLine("Replace result: {0}", r);
        o.Demo();

        Console.WriteLine();

        Console.WriteLine("2. Replace Instance Overload of Method Class1.Demo(10)");
        o.Demo(10);
        r = CSharpUtils.ReplaceMethod(typeof(Class1), "Demo", typeof(Program), "Foo", types:new Type[]{ typeof(int) });
        Console.WriteLine("Replace result: {0}" ,r);
        o.Demo(10);

        Console.WriteLine();
        
        Console.WriteLine("3. Replace Static Method Class1.DemoStatic()");
        Class1.DemoStatic();
        r = CSharpUtils.ReplaceMethod(typeof(Class1), "DemoStatic", typeof(Program), "FooStatic", BindingFlags.Static|BindingFlags.NonPublic|BindingFlags.Public);
        Console.WriteLine("Replace result: {0}" ,r);
        Class1.DemoStatic();
    }

    private void Foo() {
        Console.WriteLine("Foo"); 
    }

    private void Foo(int d) {
        Console.WriteLine("Foo: {0}", d); 
    }

    private static void FooStatic() {
        Console.WriteLine("FooStatic");
    }
}


class Class1 {
    public void Demo() {
        Console.WriteLine("Demo");
    }

    public void Demo(int d) {
        Console.WriteLine("Demo: {0}", d);
    }

    public static void DemoStatic() {
        Console.WriteLine("DemoStatic");
    }
}


public static class CSharpUtils {
    public static bool ReplaceMethod(Type targetType, string targetMethod, Type injectType, string injectMethod, BindingFlags bindingAttr = BindingFlags.Instance|BindingFlags.NonPublic|BindingFlags.Public, Binder binder = null, CallingConventions callConvention = CallingConventions.Any, Type[] types = null, ParameterModifier[] modifiers = null) {
        if (types == null) {
            types = Type.EmptyTypes;
        }
        MethodInfo tarMethod = targetType.GetMethod(targetMethod, bindingAttr, binder, callConvention, types, modifiers);
        MethodInfo injMethod = injectType.GetMethod(injectMethod, bindingAttr, binder, callConvention, types, modifiers);
        if (tarMethod == null || injMethod == null) {
            return false;
        }
        RuntimeHelpers.PrepareMethod(tarMethod.MethodHandle);
        RuntimeHelpers.PrepareMethod(injMethod.MethodHandle);
        unsafe {
            if (IntPtr.Size == 4) {
                int* tar = (int*)tarMethod.MethodHandle.Value.ToPointer() + 2;
                int* inj = (int*)injMethod.MethodHandle.Value.ToPointer() + 2;
                *tar = *inj;
            } else {
                long* tar = (long*)tarMethod.MethodHandle.Value.ToPointer() + 1;
                long* inj = (long*)injMethod.MethodHandle.Value.ToPointer() + 1;
                *tar = *inj;
            }
        }
        return true;
    }
}