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)\MSBuild\14.0\Bin\csc.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("\nPress any key to EXIT...");
         Console.ReadKey(true);
     }

     public static void PrintInfo() {
         Console.Write("PrintInfo: ");
         if (IntPtr.Size == ) {
 #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();
         r = CSharpUtils.ReplaceMethod(typeof(Class1), "Demo", typeof(Program), "Foo", types:new Type[]{ typeof(int) });
         Console.WriteLine("Replace result: {0}" ,r);
         o.Demo();

         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 == ) {
                 int* tar = (int*)tarMethod.MethodHandle.Value.ToPointer() + ;
                 int* inj = (int*)injMethod.MethodHandle.Value.ToPointer() + ;
                 *tar = *inj;
             } else {
                 long* tar = (long*)tarMethod.MethodHandle.Value.ToPointer() + ;
                 long* inj = (long*)injMethod.MethodHandle.Value.ToPointer() + ;
                 *tar = *inj;
             }
         }
         return true;
     }
 }