Yang ingin saya lakukan adalah mengubah cara metode C # dijalankan ketika dipanggil, sehingga saya dapat menulis sesuatu seperti ini:

[Distributed]
public DTask<bool> Solve(int n, DEvent<bool> callback)
{
    for (int m = 2; m < n - 1; m += 1)
        if (m % n == 0)
            return false;
    return true;
}

Pada waktu proses, saya harus dapat menganalisis metode yang memiliki atribut Terdistribusi (yang sudah dapat saya lakukan) dan kemudian memasukkan kode sebelum badan fungsi dijalankan dan setelah fungsi kembali. Lebih penting lagi, saya harus dapat melakukannya tanpa memodifikasi kode di mana Solve dipanggil atau di awal fungsi (pada waktu kompilasi; tujuannya adalah melakukannya saat run-time).

Saat ini saya telah mencoba sedikit kode ini (asumsikan t adalah tipe tempat penyimpanan Solve, dan m adalah MethodInfo of Solve) :

private void WrapMethod(Type t, MethodInfo m)
{
    // Generate ILasm for delegate.
    byte[] il = typeof(Dpm).GetMethod("ReplacedSolve").GetMethodBody().GetILAsByteArray();

    // Pin the bytes in the garbage collection.
    GCHandle h = GCHandle.Alloc((object)il, GCHandleType.Pinned);
    IntPtr addr = h.AddrOfPinnedObject();
    int size = il.Length;

    // Swap the method.
    MethodRental.SwapMethodBody(t, m.MetadataToken, addr, size, MethodRental.JitImmediate);
}

public DTask<bool> ReplacedSolve(int n, DEvent<bool> callback)
{
    Console.WriteLine("This was executed instead!");
    return true;
}

Namun, MethodRental.SwapMethodBody hanya bekerja pada modul dinamis; bukan yang sudah dikompilasi dan disimpan di assembly.

Jadi saya mencari cara untuk secara efektif melakukan SwapMethodBody dengan metode yang sudah disimpan dalam rakitan yang dimuat dan dijalankan .

Catatan, ini bukan masalah jika saya harus menyalin sepenuhnya metode ke dalam modul dinamis, tetapi dalam kasus ini saya perlu menemukan cara untuk menyalin di IL serta memperbarui semua panggilan ke Solve () sehingga mereka akan mengarah ke salinan baru.

Pengungkapan: Harmoni adalah perpustakaan yang ditulis dan dipelihara oleh saya, penulis posting ini.

Harmony 2 adalah pustaka sumber terbuka (lisensi MIT) yang dirancang untuk menggantikan, menghias, atau memodifikasi metode C # apa pun yang ada selama runtime. Fokus utamanya adalah game dan plugin yang ditulis dalam Mono atau .NET. Ini menangani beberapa perubahan pada metode yang sama - mereka menumpuk, bukan menimpa satu sama lain.

Ini membuat metode penggantian dinamis untuk setiap metode asli dan memancarkan kode yang memanggil metode kustom di awal dan akhir. Ini juga memungkinkan Anda menulis filter untuk memproses kode IL asli dan penangan pengecualian khusus yang memungkinkan manipulasi yang lebih detail dari metode asli.

Untuk menyelesaikan prosesnya, ia menulis lompatan assembler sederhana ke trampolin dari metode asli yang menunjuk ke assembler yang dihasilkan dari kompilasi metode dinamis. Ini berfungsi untuk 32 / 64Bit di Windows, macOS, dan Linux apa pun yang didukung Mono.

Dokumentasi dapat ditemukan di sini .

Contoh

( Sumber )

Kode Asli

public class SomeGameClass
{
    private bool isRunning;
    private int counter;

    private int DoSomething()
    {
        if (isRunning)
        {
            counter++;
            return counter * 10;
        }
    }
}

Menambal dengan anotasi Harmoni

using SomeGame;
using HarmonyLib;

public class MyPatcher
{
    // make sure DoPatching() is called at start either by
    // the mod loader or by your injector

    public static void DoPatching()
    {
        var harmony = new Harmony("com.example.patch");
        harmony.PatchAll();
    }
}

[HarmonyPatch(typeof(SomeGameClass))]
[HarmonyPatch("DoSomething")]
class Patch01
{
    static FieldRef<SomeGameClass,bool> isRunningRef =
        AccessTools.FieldRefAccess<SomeGameClass, bool>("isRunning");

    static bool Prefix(SomeGameClass __instance, ref int ___counter)
    {
        isRunningRef(__instance) = true;
        if (___counter > 100)
            return false;
        ___counter = 0;
        return true;
    }

    static void Postfix(ref int __result)
    {
        __result *= 2;
    }
}

Atau, tambalan manual dengan refleksi

using SomeGame;
using HarmonyLib;

public class MyPatcher
{
    // make sure DoPatching() is called at start either by
    // the mod loader or by your injector

    public static void DoPatching()
    {
        var harmony = new Harmony("com.example.patch");

        var mOriginal = typeof(SomeGameClass).GetMethod("DoSomething", BindingFlags.Instance | BindingFlags.NonPublic);
        var mPrefix = typeof(MyPatcher).GetMethod("MyPrefix", BindingFlags.Static | BindingFlags.Public);
        var mPostfix = typeof(MyPatcher).GetMethod("MyPostfix", BindingFlags.Static | BindingFlags.Public);
        // add null checks here

        harmony.Patch(mOriginal, new HarmonyMethod(mPrefix), new HarmonyMethod(mPostfix));
    }

    public static void MyPrefix()
    {
        // ...
    }

    public static void MyPostfix()
    {
        // ...
    }
}

Untuk .NET 4 ke atas

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


namespace InjectionTest
{
    class Program
    {
        static void Main(string[] args)
        {
            Target targetInstance = new Target();

            targetInstance.test();

            Injection.install(1);
            Injection.install(2);
            Injection.install(3);
            Injection.install(4);

            targetInstance.test();

            Console.Read();
        }
    }

    public class Target
    {
        public void test()
        {
            targetMethod1();
            Console.WriteLine(targetMethod2());
            targetMethod3("Test");
            targetMethod4();
        }

        private void targetMethod1()
        {
            Console.WriteLine("Target.targetMethod1()");

        }

        private string targetMethod2()
        {
            Console.WriteLine("Target.targetMethod2()");
            return "Not injected 2";
        }

        public void targetMethod3(string text)
        {
            Console.WriteLine("Target.targetMethod3("+text+")");
        }

        private void targetMethod4()
        {
            Console.WriteLine("Target.targetMethod4()");
        }
    }

    public class Injection
    {        
        public static void install(int funcNum)
        {
            MethodInfo methodToReplace = typeof(Target).GetMethod("targetMethod"+ funcNum, BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
            MethodInfo methodToInject = typeof(Injection).GetMethod("injectionMethod"+ funcNum, 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
                }
            }
        }

        private void injectionMethod1()
        {
            Console.WriteLine("Injection.injectionMethod1");
        }

        private string injectionMethod2()
        {
            Console.WriteLine("Injection.injectionMethod2");
            return "Injected 2";
        }

        private void injectionMethod3(string text)
        {
            Console.WriteLine("Injection.injectionMethod3 " + text);
        }

        private void injectionMethod4()
        {
            System.Diagnostics.Process.Start("calc");
        }
    }

}

Anda DAPAT mengubah konten metode saat runtime. Tetapi Anda tidak seharusnya melakukannya, dan sangat disarankan untuk menyimpannya untuk tujuan pengujian.

Lihat saja:

http://www.codeproject.com/Articles/463508/NET-CLR-Injection-Modify-IL-Code-during-Run-time

Pada dasarnya, Anda dapat:

1. Dapatkan konten metode IL melalui MethodInfo.GetMethodBody (). GetILAsByteArray ()

2. Berantakan dengan byte ini.

   Jika Anda hanya ingin menambahkan atau menambahkan beberapa kode, maka cukup praprend / tambahkan opcode yang Anda inginkan (berhati-hatilah dalam membiarkan tumpukan tetap bersih)

   Berikut beberapa tip untuk "mengurai" IL yang ada:

   • Byte yang dikembalikan adalah urutan instruksi IL, diikuti dengan argumennya (jika memiliki beberapa - misalnya, '.call' memiliki satu argumen: token metode yang dipanggil, dan '.pop' tidak memiliki argumen)
   • Korespondensi antara kode IL dan byte yang Anda temukan dalam larik yang dikembalikan dapat ditemukan menggunakan OpCodes.YourOpCode.Value (yang merupakan nilai byte opcode nyata seperti yang disimpan dalam rakitan Anda)
   • Argumen yang ditambahkan setelah kode IL mungkin memiliki ukuran berbeda (dari satu hingga beberapa byte), tergantung pada opcode yang dipanggil
   • Anda mungkin menemukan token yang dirujuk argumen tesis melalui metode yang sesuai. Misalnya, jika IL Anda berisi ".call 354354" (dikodekan sebagai 28 00 05 68 32 dalam hexa, 28h = 40 adalah opcode '.call' dan 56832h = 354354), metode dipanggil yang sesuai dapat ditemukan menggunakan MethodBase.GetMethodFromHandle (354354 )

3. Setelah diubah, array byte IL Anda dapat diinjeksikan kembali melalui InjectionHelper.UpdateILCodes (metode MethodInfo, byte [] ilCodes) - lihat tautan yang disebutkan di atas

   Ini adalah bagian yang "tidak aman" ... Ini berfungsi dengan baik, tetapi ini terdiri dari peretasan mekanisme CLR internal ...

Anda dapat menggantinya jika metodenya non virtual, non generik, bukan dalam tipe generik, tidak sebaris dan pada bentuk pelat x86:

MethodInfo methodToReplace = ...
RuntimeHelpers.PrepareMetod(methodToReplace.MethodHandle);

var getDynamicHandle = Delegate.CreateDelegate(Metadata<Func<DynamicMethod, RuntimeMethodHandle>>.Type, Metadata<DynamicMethod>.Type.GetMethod("GetMethodDescriptor", BindingFlags.Instance | BindingFlags.NonPublic)) as Func<DynamicMethod, RuntimeMethodHandle>;

var newMethod = new DynamicMethod(...);
var body = newMethod.GetILGenerator();
body.Emit(...) // do what you want.
body.Emit(OpCodes.jmp, methodToReplace);
body.Emit(OpCodes.ret);

var handle = getDynamicHandle(newMethod);
RuntimeHelpers.PrepareMethod(handle);

*((int*)new IntPtr(((int*)methodToReplace.MethodHandle.Value.ToPointer() + 2)).ToPointer()) = handle.GetFunctionPointer().ToInt32();

//all call on methodToReplace redirect to newMethod and methodToReplace is called in newMethod and you can continue to debug it, enjoy.

Terdapat beberapa kerangka kerja yang memungkinkan Anda untuk secara dinamis mengubah metode apa pun pada waktu proses (mereka menggunakan antarmuka ICLRProfiling yang disebutkan oleh user152949):

• Prig : Gratis dan Sumber Terbuka!
• Microsoft Fakes : Komersial, termasuk dalam Visual Studio Premium dan Ultimate tetapi tidak dalam Community and Professional
• Telerik JustMock : Komersial, tersedia versi "lite"
• Typemock Isolator : Komersial

Ada juga beberapa kerangka kerja yang mengolok-olok dengan internal .NET, ini kemungkinan lebih rapuh, dan mungkin tidak dapat mengubah kode sebaris, tetapi di sisi lain mereka sepenuhnya mandiri dan tidak mengharuskan Anda untuk menggunakan peluncur khusus.

• Harmony : MIT berlisensi. Tampaknya benar-benar telah berhasil digunakan dalam beberapa mod game, mendukung .NET dan Mono.
• Deviare Dalam Proses Mesin Instrumentasi : GPLv3 dan Komersial. Dukungan .NET saat ini ditandai sebagai eksperimental, tetapi di sisi lain memiliki keuntungan karena didukung secara komersial.

Solusi Logman , tetapi dengan antarmuka untuk menukar badan metode. Juga, contoh yang lebih sederhana.

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

namespace DynamicMojo
{
    class Program
    {
        static void Main(string[] args)
        {
            Animal kitty = new HouseCat();
            Animal lion = new Lion();
            var meow = typeof(HouseCat).GetMethod("Meow", BindingFlags.Instance | BindingFlags.NonPublic);
            var roar = typeof(Lion).GetMethod("Roar", BindingFlags.Instance | BindingFlags.NonPublic);

            Console.WriteLine("<==(Normal Run)==>");
            kitty.MakeNoise(); //HouseCat: Meow.
            lion.MakeNoise(); //Lion: Roar!

            Console.WriteLine("<==(Dynamic Mojo!)==>");
            DynamicMojo.SwapMethodBodies(meow, roar);
            kitty.MakeNoise(); //HouseCat: Roar!
            lion.MakeNoise(); //Lion: Meow.

            Console.WriteLine("<==(Normality Restored)==>");
            DynamicMojo.SwapMethodBodies(meow, roar);
            kitty.MakeNoise(); //HouseCat: Meow.
            lion.MakeNoise(); //Lion: Roar!

            Console.Read();
        }
    }

    public abstract class Animal
    {
        public void MakeNoise() => Console.WriteLine($"{this.GetType().Name}: {GetSound()}");

        protected abstract string GetSound();
    }

    public sealed class HouseCat : Animal
    {
        protected override string GetSound() => Meow();

        private string Meow() => "Meow.";
    }

    public sealed class Lion : Animal
    {
        protected override string GetSound() => Roar();

        private string Roar() => "Roar!";
    }

    public static class DynamicMojo
    {
        /// <summary>
        /// Swaps the function pointers for a and b, effectively swapping the method bodies.
        /// </summary>
        /// <exception cref="ArgumentException">
        /// a and b must have same signature
        /// </exception>
        /// <param name="a">Method to swap</param>
        /// <param name="b">Method to swap</param>
        public static void SwapMethodBodies(MethodInfo a, MethodInfo b)
        {
            if (!HasSameSignature(a, b))
            {
                throw new ArgumentException("a and b must have have same signature");
            }

            RuntimeHelpers.PrepareMethod(a.MethodHandle);
            RuntimeHelpers.PrepareMethod(b.MethodHandle);

            unsafe
            {
                if (IntPtr.Size == 4)
                {
                    int* inj = (int*)b.MethodHandle.Value.ToPointer() + 2;
                    int* tar = (int*)a.MethodHandle.Value.ToPointer() + 2;

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

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

                    int tmp = *tarSrc;
                    *tarSrc = (((int)injInst + 5) + *injSrc) - ((int)tarInst + 5);
                    *injSrc = (((int)tarInst + 5) + tmp) - ((int)injInst + 5);
                }
                else
                {
                    throw new NotImplementedException($"{nameof(SwapMethodBodies)} doesn't yet handle IntPtr size of {IntPtr.Size}");
                }
            }
        }

        private static bool HasSameSignature(MethodInfo a, MethodInfo b)
        {
            bool sameParams = !a.GetParameters().Any(x => !b.GetParameters().Any(y => x == y));
            bool sameReturnType = a.ReturnType == b.ReturnType;
            return sameParams && sameReturnType;
        }
    }
}

Berdasarkan jawaban atas pertanyaan ini dan pertanyaan lainnya, ive muncul dengan versi rapi ini:

// Note: This method replaces methodToReplace with methodToInject
// Note: methodToInject will still remain pointing to the same location
public static unsafe MethodReplacementState Replace(this MethodInfo methodToReplace, MethodInfo methodToInject)
        {
//#if DEBUG
            RuntimeHelpers.PrepareMethod(methodToReplace.MethodHandle);
            RuntimeHelpers.PrepareMethod(methodToInject.MethodHandle);
//#endif
            MethodReplacementState state;

            IntPtr tar = methodToReplace.MethodHandle.Value;
            if (!methodToReplace.IsVirtual)
                tar += 8;
            else
            {
                var index = (int)(((*(long*)tar) >> 32) & 0xFF);
                var classStart = *(IntPtr*)(methodToReplace.DeclaringType.TypeHandle.Value + (IntPtr.Size == 4 ? 40 : 64));
                tar = classStart + IntPtr.Size * index;
            }
            var inj = methodToInject.MethodHandle.Value + 8;
#if DEBUG
            tar = *(IntPtr*)tar + 1;
            inj = *(IntPtr*)inj + 1;
            state.Location = tar;
            state.OriginalValue = new IntPtr(*(int*)tar);

            *(int*)tar = *(int*)inj + (int)(long)inj - (int)(long)tar;
            return state;

#else
            state.Location = tar;
            state.OriginalValue = *(IntPtr*)tar;
            * (IntPtr*)tar = *(IntPtr*)inj;
            return state;
#endif
        }
    }

    public struct MethodReplacementState : IDisposable
    {
        internal IntPtr Location;
        internal IntPtr OriginalValue;
        public void Dispose()
        {
            this.Restore();
        }

        public unsafe void Restore()
        {
#if DEBUG
            *(int*)Location = (int)OriginalValue;
#else
            *(IntPtr*)Location = OriginalValue;
#endif
        }
    }

Anda dapat mengganti metode saat runtime dengan menggunakan ICLRPRofiling Interface .

1. Panggil AttachProfiler untuk melampirkan ke proses.
2. Panggil SetILFunctionBody untuk mengganti kode metode.

Lihat blog ini untuk lebih jelasnya.

Saya tahu ini bukan jawaban yang tepat untuk pertanyaan Anda, tetapi cara yang biasa dilakukan adalah menggunakan pendekatan pabrik / proxy.

Pertama kami mendeklarasikan tipe dasar.

public class SimpleClass
{
    public virtual DTask<bool> Solve(int n, DEvent<bool> callback)
    {
        for (int m = 2; m < n - 1; m += 1)
            if (m % n == 0)
                return false;
        return true;
    }
}

Kemudian kita bisa mendeklarasikan tipe turunan (sebut saja proxy).

public class DistributedClass
{
    public override DTask<bool> Solve(int n, DEvent<bool> callback)
    {
        CodeToExecuteBefore();
        return base.Slove(n, callback);
    }
}

// At runtime

MyClass myInstance;

if (distributed)
    myInstance = new DistributedClass();
else
    myInstance = new SimpleClass();

Jenis turunan juga dapat dibuat saat runtime.

public static class Distributeds
{
    private static readonly ConcurrentDictionary<Type, Type> pDistributedTypes = new ConcurrentDictionary<Type, Type>();

    public Type MakeDistributedType(Type type)
    {
        Type result;
        if (!pDistributedTypes.TryGetValue(type, out result))
        {
            if (there is at least one method that have [Distributed] attribute)
            {
                result = create a new dynamic type that inherits the specified type;
            }
            else
            {
                result = type;
            }

            pDistributedTypes[type] = result;
        }
        return result;
    }

    public T MakeDistributedInstance<T>()
        where T : class
    {
        Type type = MakeDistributedType(typeof(T));
        if (type != null)
        {
            // Instead of activator you can also register a constructor delegate generated at runtime if performances are important.
            return Activator.CreateInstance(type);
        }
        return null;
    }
}

// In your code...

MyClass myclass = Distributeds.MakeDistributedInstance<MyClass>();
myclass.Solve(...);

Satu-satunya kerugian kinerja adalah selama konstruksi objek turunan, pertama kali cukup lambat karena akan menggunakan banyak pantulan dan pancaran pantulan. Di lain waktu, ini adalah biaya pencarian tabel bersamaan dan konstruktor. Seperti yang dikatakan, Anda dapat mengoptimalkan penggunaan konstruksi

ConcurrentDictionary<Type, Func<object>>.