using System;

using System.Reflection;

using System.Runtime.CompilerServices;

using System.Runtime.InteropServices;

​

class Program

{

    public static void Main()

    {

        ExternalClass.Initialize();

        int soma = Somar(1,1);

        Console.WriteLine(soma);

    }

​

    public static int Somar(int a, int b){

        return a + b;

    }

    public static int Subtrair(int a, int b){

        return a - b;

    }

}

​

//Uma classe externa somente para simular

static class ExternalClass

{

    public static void Initialize()

    {

        MethodInfo methodFrom = typeof(Program).GetMethod("Somar");

        MethodInfo methodTo = typeof(Program).GetMethod("Subtrair");

        ReplaceMethodCall(methodFrom, methodTo);

    }

​

    private static void ReplaceMethodCall(MethodInfo from, MethodInfo target)

    {

        //Força a compilação do JIT

        RuntimeHelpers.PrepareMethod(from.MethodHandle);

        RuntimeHelpers.PrepareMethod(target.MethodHandle);

​

        //Obtém o endereço do corpo do método

        long fromPointer = from.MethodHandle.GetFunctionPointer().ToInt64();

        long targetPointer = target.MethodHandle.GetFunctionPointer().ToInt64();

​

        WriteBytes(ref fromPointer, new byte[] { 0x48, 0xB8 }); //Escreve um MOV

        WriteLong(ref fromPointer, targetPointer); //Escreve o endereço

        WriteBytes(ref fromPointer, new byte[] { 0xFF, 0xE0 });

    }

​

    private static void WriteBytes(ref long address, byte[] bytes)

    {

        foreach (byte b in bytes)

        {

            Marshal.WriteByte(new IntPtr(address), b);

            address += sizeof(byte);

        }

    }

​

    private static void WriteLong(ref long address, long value)

    {

        Marshal.WriteInt64(new IntPtr(address), value);

        address += sizeof(long);

    }

}

​