Q:

Dynamically Append Code to a method .Net-Core

I'm interested in dynamically appending code in .Net-Core.  Note: This is for education purposes only.
Currently I have a class which swaps methods:
public static void Inject<TTarget, TInject>(string targetFuncName, string injectFuncName)
{
    MethodInfo methodToReplace = typeof(TTarget).GetMethod(targetFuncName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
    MethodInfo methodToInject = typeof(TInject).GetMethod(injectFuncName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
    RuntimeHelpers.PrepareMethod(methodToReplace.MethodHandle);
    RuntimeHelpers.PrepareMethod(methodToInject.MethodHandle);

    unsafe
    {
        if (IntPtr.Size == 4)
        {
            int* inj = (int*)methodToInject.MethodHandle.Value.ToPointer() + 2;
            int* tar = (int*)methodToReplace.MethodHandle.Value.ToPointer() + 2;
#if DEBUG
            Console.WriteLine("\nVersion x86 Debug\n");

            byte* injInst = (byte*)*inj;
            byte* tarInst = (byte*)*tar;

            int* injSrc = (int*)(injInst + 1);
            int* tarSrc = (int*)(tarInst + 1);

            *tarSrc = (((int)injInst + 5) + *injSrc) - ((int)tarInst + 5);
#else
            Console.WriteLine("\nVersion x86 Release\n");
            *tar = *inj;
#endif
        }
        else
        {
            long* inj = (long*)methodToInject.MethodHandle.Value.ToPointer() + 1;
            long* tar = (long*)methodToReplace.MethodHandle.Value.ToPointer() + 1;
#if DEBUG
            Console.WriteLine("\nVersion x64 Debug\n");
            byte* injInst = (byte*)*inj;
            byte* tarInst = (byte*)*tar;

            int* injSrc = (int*)(injInst + 1);
            int* tarSrc = (int*)(tarInst + 1);

            *tarSrc = (((int)injInst + 5) + *injSrc) - ((int)tarInst + 5);
 #else
            Console.WriteLine("\nVersion x64 Release\n");
            *tar = *inj;
#endif
        }
    }
}

This Code swaps the method fine, However, if you're debugging it seems like to original code is never hit.  Instead I would like to swap the return statements from the method bytes and replace it with a jump statement to another function with the same parameters.  
However, .Net Core doesn't currently support the MethodRental.SwapMethodBody  How Can dynamically append code to the end of a function?

A:

I figured out a cheat way to do it.  I haven't written all the code yet but I'll explain in pseudo code
Say we have a method:
public class ValuesController: ControllerBase
{
    [HttpGet("Seven")]
    public int Seven(string id)
    {
        return 7;
    }
}

We want to swap it with another method 
public int Eight(int retValue)
{
    return retValue + 1;
}

We can generate a Func in a dynamic assembly. Which looks like so:
public int Dummy(string id)
{}

public int DummyFuncContainer(string id)
{
    var result = Dummy(id);
    return Eight(result);
}

Then all you need to do is.  
Swap the Dummy() method with the func we want Seven() and then we swap Seven()(Which is now pointing at Dummy()) with DummyFuncContainer().  

