Yapmak istediğim şey, bir C # yönteminin çağrıldığında nasıl çalışacağını değiştirmektir, böylece şöyle bir şey yazabilirim:

[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;
}

Çalışma zamanında, Dağıtılmış özniteliğine (zaten yapabildiğim) sahip yöntemleri analiz edebilmem ve ardından işlevin gövdesi çalıştırılmadan önce ve işlev döndükten sonra kod ekleyebilmem gerekiyor. Daha da önemlisi, Solve'nin çağrıldığı yerde veya işlevin başlangıcında (derleme zamanında; bunu çalışma zamanında yapmak amaçtır) kodu değiştirmeden yapabilmem gerekiyor.

Şu anda bu kod parçasını denedim (t'nin Solve'da depolandığı tür olduğunu ve m'nin Çözme'nin MethodInfo olduğunu varsayın) :

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;
}

Ancak, MethodRental.SwapMethodBody yalnızca dinamik modüller üzerinde çalışır; montajda önceden derlenmiş ve saklanmış olanlar değil.

Bu yüzden, SwapMethodBody'yi zaten yüklenmiş ve çalıştırılan bir derlemede depolanan bir yöntemde etkili bir şekilde yapmanın bir yolunu arıyorum .

Yöntemi tamamen dinamik bir modüle kopyalamam gerekip gerekmediğini unutmayın, ancak bu durumda IL genelinde kopyalama yapmanın bir yolunu bulmam ve Solve () 'e yapılan tüm çağrıları, yeni kopyayı gösterir.

Açıklama: Harmony, bu yazının yazarı olan benim tarafımdan yazılmış ve sürdürülen bir kütüphanedir.

Harmony 2 , çalışma zamanı sırasında her türden mevcut C # yöntemlerini değiştirmek, süslemek veya değiştirmek için tasarlanmış bir açık kaynak kitaplığıdır (MIT lisansı). Ana odak noktası, Mono veya .NET ile yazılmış oyunlar ve eklentilerdir. Aynı yöntemde birden fazla değişiklik yapılmasını sağlar - birbirlerinin üzerine yazmak yerine birikirler.

Her orijinal yöntem için dinamik değiştirme yöntemleri oluşturur ve bunlara başlangıçta ve sonda özel yöntemler çağıran kod yayar. Ayrıca, orijinal IL kodunu işlemek için filtreler yazmanıza ve orijinal yöntemin daha ayrıntılı işlemesine izin veren özel istisna işleyicileri yazmanıza olanak tanır.

Süreci tamamlamak için, dinamik yöntemin derlenmesiyle oluşturulan birleştiriciye işaret eden orijinal yöntemin trambolinine basit bir assembler atlaması yazar. Bu, Windows, macOS ve Mono'nun desteklediği herhangi bir Linux'ta 32 / 64Bit için çalışır.

Belgeler burada bulunabilir .

Misal

( Kaynak )

Orijinal Kod

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

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

Harmony ek açıklamalarıyla yama yapma

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;
    }
}

Alternatif olarak, yansımalı manuel yama

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()
    {
        // ...
    }
}

.NET 4 ve üstü için

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");
        }
    }

}

Bir yöntemin içeriğini çalışma zamanında değiştirebilirsiniz. Ancak bunu yapmamalısınız ve bunu test amacıyla saklamanız şiddetle tavsiye edilir.

Sadece şuna bir göz atın:

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

Temel olarak şunları yapabilirsiniz:

1. MethodInfo.GetMethodBody () aracılığıyla IL yöntemi içeriğini alın. GetILAsByteArray ()

2. Bu baytlarla karıştırın.

   Yalnızca bir kodun başına veya sonuna eklemek istiyorsanız, istediğiniz işlem kodlarını önceden ekleyin / ekleyin (yığını temiz bırakmaya dikkat edin)

   Mevcut IL'yi "derlemek" için bazı ipuçları şunlardır:

   • Döndürülen baytlar, IL komutlarının bir dizisidir ve ardından argümanları gelir (eğer bazılarına sahiplerse - örneğin, '.call' bir argümana sahiptir: çağrılan yöntem simgesi ve '.pop' hiçbiri içermez)
   • Döndürülen dizide bulduğunuz IL kodları ve baytlar arasındaki yazışmalar, OpCodes.YourOpCode.Value kullanılarak bulunabilir (bu, derlemenizde kaydedildiği şekliyle gerçek işlem kodu bayt değeridir)
   • IL kodlarından sonra eklenen bağımsız değişkenler, çağrılan işlem koduna bağlı olarak farklı boyutlara (bir ila birkaç bayta kadar) sahip olabilir.
   • Bu argümanların atıfta bulunduğu simgeleri uygun yöntemlerle bulabilirsiniz. Örneğin, IL'niz ".call 354354" içeriyorsa (hexa'da 28 00 05 68 32 kodlu, 28h = 40 '.call' opcode ve 56832h = 354354), karşılık gelen çağrılan yöntem MethodBase.GetMethodFromHandle (354354 )

3. IL bayt dizisi değiştirildikten sonra, InjectionHelper.UpdateILCodes (MethodInfo yöntemi, bayt [] ilCodes) aracılığıyla yeniden enjekte edilebilir - yukarıda belirtilen bağlantıya bakın

   Bu "güvenli olmayan" kısım ... İyi çalışıyor, ancak bu dahili CLR mekanizmalarını hacklemekten ibaret ...

yöntem sanal değilse, jenerik değilse, jenerik türde değilse, satır içi değilse ve x86 plaka biçimindeyse değiştirebilirsiniz:

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.

Çalışma zamanında herhangi bir yöntemi dinamik olarak değiştirmenize izin veren birkaç çerçeve vardır (user152949 tarafından belirtilen ICLRProfiling arayüzünü kullanırlar):

• Prig : Ücretsiz ve Açık Kaynak!
• Microsoft Fakes : Ticari, Visual Studio Premium ve Ultimate'a dahildir, ancak Community ve Professional'a dahil değildir
• Telerik JustMock : Ticari, "lite" versiyonu mevcuttur
• Typemock İzolatörü : Ticari

Ayrıca .NET'in iç kısımlarıyla dalga geçen birkaç çerçeve vardır, bunlar muhtemelen daha kırılgandır ve muhtemelen satır içi kodu değiştiremezler, ancak diğer yandan tamamen bağımsızdırlar ve bir özel başlatıcı.

• Harmony : MIT lisanslıdır. Birkaç oyun modunda başarılı bir şekilde kullanılmış gibi görünüyor, hem .NET hem de Mono'yu destekliyor.
• İşlem Enstrümantasyon Motorunda Sapma : GPLv3 ve Ticari. .NET desteği şu anda deneysel olarak işaretlenmiştir, ancak diğer yandan ticari olarak desteklenme avantajına sahiptir.

Logman'ın çözümü , ancak yöntem gövdelerini değiştirmek için bir arayüze sahip. Ayrıca daha basit bir örnek.

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;
        }
    }
}

Bu ve başka bir sorunun cevabına dayanarak, bu düzenli versiyonu buldum:

// 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
        }
    }

ICLRPRofiling Arabirimini kullanarak çalışma zamanında bir yöntemi değiştirebilirsiniz .

1. İşleme eklemek için AttachProfiler'ı arayın .
2. Yöntem kodunu değiştirmek için SetILFunctionBody'yi çağırın .

Daha fazla ayrıntı için bu bloga bakın.

Sorunuzun tam cevabı olmadığını biliyorum, ancak bunu yapmanın olağan yolu fabrikalar / vekil yaklaşımı kullanmaktır.

İlk önce bir temel tür bildiriyoruz.

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;
    }
}

Sonra türetilmiş bir tür tanımlayabiliriz (buna proxy diyebiliriz).

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();

Türetilmiş tür, çalışma zamanında da üretilebilir.

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(...);

Tek performans kaybı, türetilen nesnenin yapımı sırasında, ilk kez oldukça yavaştır çünkü çok fazla yansıma ve yansıma yayması kullanacaktır. Diğer tüm zamanlarda, eşzamanlı bir tablo araması ve bir yapıcının maliyetidir. Söylediği gibi, inşaatı optimize edebilirsiniz.

ConcurrentDictionary<Type, Func<object>>.