ILRuntime 学习

ILRuntime:　　https://github.com/Ourpalm/ILRuntime

Demo:　　https://github.com/Ourpalm/ILRuntimeU3D

中文在线文档:　　https://ourpalm.github.io/ILRuntime/public/v1/guide/index.html

Mono:　　https://www.mono-project.com/

 

 

主工程:

void OnHotFixLoaded() {
    appdomain.Invoke("HotFix_Project.InstanceClass", "StaticFunText", null, null);
}

热更工程:

namespace HotFix_Project {
    public class InstanceClass {
        public InstanceClass() {
            UnityEngine.Debug.Log("!!! InstanceClass::InstanceClass()");
        }
    }
}

01_HelloWorld

主工程

void OnHotFixLoaded() {

    Debug.Log("调用无参数静态方法");
    // 调用无参数静态方法, appdomain.Invoke("类名“, "方法名", 对象引用, 参数列表);    
    appdomain.Invoke("HotFix_Project.InstanceClass", "StaticFunTest", null, null);
    
    Debug.Log("调用带参数的静态方法");
    // 调用带参数的静态方法
    appdomain.Invoke("HotFix_Project.InstanceClass", "StaticFunTest2", null, 123);
    
    Debug.Log("通过IMethod调用方法");
    // 预先获得IMethod, 可以减低每次调用查找方法耗用的时间
    IType type = appdomain.LoadedTypes["HotFix_Project.InstanceClass"];
    // 根据方法名称和参数个数获取方法
    IMethod method = type.GetMethod("StaticFunTes", 0);
    appdomain.Invoke(method, null, null);
    
    Debug.Log("指定参数类型来获得IMethod");
    IType intType = appdomain.GetType(typeof(int));
    // 参数类型列表
    List paramList = new List();
    paramList.Add(intType);
    // 根据方法名称和参数类型列表获取方法
    method = type.GetMethod("StaticFunTest2", paramList, null);
    appdomain.Invoke(method, null, 456);
    
    Debug.Log("实例化热更里的类");
    object obj = appdomain.Instantiate("HotFix_Project.InstanceClass", new object[] { 233 } );
    // 第二种方式
    object obj2 = ((ILType)type).Instantiate();
    
    Debug.Log("调用成员方法");
    int id = (int)appdomain.Invoke("HotFix_Project.InstanceClass", "get_ID", obj, null);
    Debug.Log("!! HotFix_Project.InstanceClass.ID = " + id);
    id = (int)appdomain.Invoke("HotFix_Project.InstanceClass", "get_ID", obj2, null);
    Debug.Log("!! HotFix_Project.InstanceClass.ID = " + id);
    
    Debug.Log("调用泛型方法");
    IType stringType = appdomain.GetType(typeof(string));
    IType[] genericArguments = new IType[] { stringType };
    appdomain.InvokeGenericMethod("HotFix_Project.InstanceClass", "GenericMethod", genericArguments, null, "TestString");
    
    Debug.Log("获取泛型方法的IMethod");
    paramList.Clear();
    paramList.Add(intType);
    genericArguments = new IType[] { intType };
    method = type.GetMethod("GenericMethod", paramList, genericArguments);
    appdomain.Invoke(method, null, 33333);
}
    
    
    
热更新工程

namespace HotFix_Project {
    public class InstanceClass {
        private int id;
        
        public InstanceClass() {
            UnityEngine.Debug.Log("!!! InstanceClass::InstanceClass()");
            this.id = 0;
        }
        
        public InstanceClass(int id) {
            UnityEngine.Debug.Log("!!! InstanceClass::InstanceClass() id = " + id);
            this.id = id;
        }
        
        public int ID {
            get { return id; }
        }
                        
        public static void StaticFunTest() {
            UnityEngine.Debug.Log("!!! InstanceClass.StaticFunTest()");
        }
        
        public static void StaticFunTest2(int a) {
            UnityEngine.Debug.Log("!!! InstanceClass.StaticFunTest2(), a=" + a);
        }
        
        public static void GenericMethod(T a) {
            UnityEngine.Debug.Log("!!! InstanceClass.GenericMethod(), a=" + a);
        }
    }
}

02_Invocation

主工程

public delegate void TestDelegateMethod(int a);
public delegate string TestDelegateFunction(int a);

public class DelegateDemo: MonoBehaviour {

    public static TestDelegateMethod TestMethodDelegate;
    public static TestDelegateFunction TestFunctionDelegate;
    public static System.Action<string> TestActionDelegate;

    // 这个方法仅仅是为了演示,强制删除缓存的委托适配器,实际项目不要这么调用
    void ClearDelegateCache() {
        var type = appdomain.LoadedTypes["HotFix_Project.TestDelegate"];
        ILMethod m = type.GetMethod("Method", 1) as ILMethod;
        m.DelegateAdapter = null;
        
        m = type.GetMethod("Function", 1) as ILMethod;
        m.DelegateAdapter = null;
        
        m = type.GetMethod("Action", 1) as ILMethod;
        m.DelegateAdapter = null;
    }

    void OnHotFixLoaded() {
        Debug.Log("完全在热更DLL内部使用的委托,直接可用,不需要做任何处理");
        appdomain.Invoke("HotFix_Project.TestDelegate", "Initialize", null, null);    
        appdomain.Invoke("HotFix_Project.TestDelegate", "RunTest", null, null);
        
        Debug.Log("如果需要跨域调用委托(将热更DLL里面的委托实例传到Unity主工程用), 就需要注册适配器,不然就会像下面这样");
        try {
            appdomain.Invoke("HotFix_Project.TestDelegate", "Initialize2", null, null);
        } catch (System.Exception ex) {
            Debug.LogError(ex.ToString());
        }
        
        // 为了演示,清除适配器缓存,实际使用中不要这么做
        ClearDelegateCache();
        
        Debug.Log("这是因为iOS的IL2CPP模式下,不能动态生成类型,为了避免出现不可预知的问题,我们没有通过反射的方式创建委托实例,因此需要手动进行一些注册");
        Debug.Log("首先需要注册委托适配器,刚刚的报错的错误提示中,有提示需要的注册代码");
        // 下面这些注册代码,正式使用的时候,应该写在InitializeILRuntime中
        // TestDelegateMethod, 这个委托类型为有个参数为int的方法,注册仅需要注册不同的参数搭配即可
        appdomain.DelegateManager.RegisterMethodDelegate<int>();
        // 带返回值的委托的话需要用RegisterFunctionDelegate,返回类型为最后一个
        appdomain.DelegateManager.RegisterFunctionDelegate<int, string>();
        // Action的参数为一个string
        appdomain.DelegateManager.RegisterMethodDelegate<string>();
        
        Debug.Log("注册完毕后再次运行会发现这次会报另外的错误");
        try {
            appdomain.Invoke("HotFix_Project.TestDelegate", "Initialize2", null, null);
        } catch (System.Exception ex) {
            Debug.LogError(ex.ToString());
        }
        
        Debug.Log("ILRuntime内部是用Action和Func这两个系统内置的委托类型来创建实例的,所以其他的委托类型都需要写转换器");
        Debug.Log("将Action或者Func转换成目标委托类型");
        
        appdomain.DelegateManager.RegisterDelegateConvertor((action) => {
            // 转换器的目的是把Action或者Func转换成正确的类型,这里则是把Action转换成TestDelegateMethod
            return new TestDelegateMethod((a) => {
                // 调用委托实例
                ((System.Action<int>)action)(a);
            });
        });
        
        // 对于TestDelegateFunction同理,只是是将Func转换成TestDelegateFunction
        appdomain.DelegateManager.RegisterDelegateConvertor((action) = >
            return new TestDelegateFunction((a) => {
                return ((System.Func<int, string>)action)(a);
            });
        });
        
        Debug.Log("现在我们再来运行一次");
        appdomain.Invoke("HotFix_Project.TestDelegate", "Initialize2", null, null);
        appdomain.Invoke("HotFix_Project.TestDelegate", "RunTest2", null, null);
        Debug.Log("运行成功，我们可以看见，用Action或者Func当作委托类型的话，可以避免写转换器，所以项目中在不必要的情况下尽量只用Action和Func");
        Debug.Log("另外应该尽量减少不必要的跨域委托调用，如果委托只在热更DLL中用，是不需要进行任何注册的");
        Debug.Log("---------");
        Debug.Log("我们再来在Unity主工程中调用一下刚刚的委托试试");
        TestMethodDelegate(789);
        var str = TestFunctionDelegate(098);
        Debug.Log("!! OnHotFixLoaded str = " + str);
        TestActionDelegate("Hello From Unity Main Project");
    }
}


    
    
    
热更新工程

namespace HotFix_Project {
    public class TestDelegate {
        // TestDelegateMethod, TestDelegateFunction 位于主工程
        static TestDelegateMethod delegateMethod;
        static TestDelegateFunction delegateFunc;
        static Action<string> delegateAction;
        
        public static void Initialize() {
            delegateMethod = Method;
            delegateFunc = Function;
            delegateAction = Action;
        }
        
        public static void RunTest() {
            delegateMethod(123);
            var res = delegateFunc(456);
            UnityEngine.Debug.Log("!! TestDelegate.RunTest res = " + res);
            delegateAction("rrr");
        }
        
        public static void Initialize2() {
            // DelegateDemo 位于主工程
            DelegateDemo.TestMethodDelegate = Method;
            DelegateDemo.TestFunctionDelegate = Function;
            DelegateDemo.TestActionDelegate = Action;
        }
        
        public static void RunTest2() {
            DelegateDemo.TestMethodDelegate(123);
            var res = DelegateDemo.TestFunctionDelegate(456);
            UnityEngine.Debug.Log("!! TestDelegate.RunTest2 res = " + res);
            DelegateDemo.TestActionDelegate("rrr");
        }
        
        static void Method(int a) {
            UnityEngine.Debug.Log("!! TestDelegate.Method, a = " + a);
        }
        
        static string Function(int a) {
            return a.ToString();
        }
        
        static void Action(string a) {
            UnityEngine.Debug.Log("!! TestDelegate.Action, a = " + a);
        }
    }
}

03_DelegateDemo

主工程

using System;
using ILRuntime.CLR.Method;
using ILRuntime.Runtime.Enviorment;
using ILRuntime.Runtime.Intepreter;

public class InheritanceAdapter: CrossBindingAdaptor {
    public override Type BaseCLR Type {
        get {
            return typeof(TestClassBase);    // 这是你想继承的那个类
        }
    }

    public override Type AdaptorType {
        get {
            return typeof(Adaptor);    // 这是实际的适配器类
        }
    }

    public override object CreateCLRInstance(ILRuntime.Runtime.Enviorment.AppDomain appdomain, ILTypeInstance instance) {
        return new Adaptor(appdomain, instance);    // 创建一个新得实例
    }

    // 实际的适配器类需要继承你想继承的那个类
    class Adaptor: TestClassBase, CrossBindingAdaptorType {
        ILTypeInstance instance;
        ILRuntime.Runtime.Enviorment.AppDomain appdomain;
        IMethod mTestAbstract;
        bool mTestAbstractGot;
        IMethod mTestVirtual;
        bool mTestVirtualGot;
        bool isTestVirtualInvoking = false;
        IMethod mGetValue;
        bool mGetValueGot;
        bool isGetValueInvoking = false;
        // 缓存这个数组来避免调用时的GC Alloc
        object[] param1 = new object[1];
        
        public Adaptor() {
        
        }
        
        public Adaptor(ILRuntime.Runtime.Enviorment.AppDomain appdomain, ILTypeInstance instance) {
            this.appdomain = appdomain;
            this.instance = instance;
        }
        
        public ILTypeInstance ILInstance { get { return instance; } }
        
        // 你需要重写所有你希望在热更脚本里面重写的方法,并且将控制权转到脚本里去
        public override void TestAbstract(int ab) {
            if (!mTestAbstractGot) {
                mTestAbstract = instance.Type.GetMethod("TestAbstract", 1);
                mTestAbstractGot = true;
            }
            if (mTestAbstract != null) {
                param1[0] = ab;
                // 没有参数建议显式传递null为参数列表,否则会自动new object[0]导致GC Alloc
                appdomain.Invoke(mTestAbstract, instance, param1);
            }
        }
        
        public override void TestVirtual(string str) {
            if (!mTestVirtualGot) {
                mTestVirtual = instance.Type.GetMethod("TestVirtual", 1);
                mTestVirtualGot = true;
            }
            // 对于虚函数而言,必须设定一个标识位来确定是否当前已经在调用中,否则如果脚本类中调用base.TestVirtual()就会造成无限循环,最终导致爆栈
            if (mTestVirtual != null && !isTestVirtualInvoking) {
                isTestVirtualInvoking = true;
                param1[0] = str;
                appdomain.Invoke(mTestVirtual, instance, param1);
                isTestVirtualInvoking = false;
            } else {
                base.TestVirtual(str);
            }
        }
        
        public override int Value {
            get {
                if (!mGetValueGot) {
                    // 属性的Getter编译以后会以get_XXX存在,如果不确定的话可以打开Reflector等反编译软件看一下函数名称
                    mGetValue = instance.Type.GetMethod"get_Value", 1);
                    mGetValueGot = true;
                }
                
                // 对于虚函数而言,必须设定一个标识位来确定是否当前已经在调用中,否则如果脚本类中调用base.Value就会造成无限循环,最终导致爆栈
                if (mGetValue != null && !isGetValueInvoking) {
                    isGetValueInvoking = true;
                    var res = (int)appdomain.Invoke(mGetValue, instance, null);
                    isGetValueInvoking = false;
                    return res;
                } else {
                    return base.Value;
                }
            }
        }
        
        public override string ToString() {
            IMethod m = appdomain.ObjectType.GetMethod("ToString", 0);
            m = instance.Type.GetVirtualMethod(m);
            if (m == null || m is ILMethod) {
                return instancde.ToString();
            } else {
                return instance.Type.FullName;
            }
        }
    }

}



public abstract class TestClassBase {
    public virtual int Value {
        get {
            return 0;
        }
    }
    
    public virtual void TestVirtual(string str) {
        Debug.Log("!! TestClassBase.TestVirtual, str = " + str);
    }
    
    public abstract void TestAbstract(int gg);
}

public class Inheritance: MonoBehaviour {
    void OnHotFixLoaded() {
        Debug.Log("首先我们来创建热更里的类实例");
        
        TestClassBase obj;
        
        try {
            obj = appdomain.Instantiate("HotFix_Project.TestInheritance");
        } catch (System.Exception ex) {
            Debug.LogError(ex.ToString());
        }
        Debug.Log("Oops, 报错了, 因为跨域继承必须要注册适配器.如果是热更DLL里面继承热更里面的类型,不需要任何注册.");
        Debug.Log("所以现在我们来注册适配器");
        appdomain.RegisterCrossBindingAdaptor(new InheritanceAdapter());
        Debug.Log("现在再来尝试创建一个实例");
        obj = appdomain.Instantiate("HotFix_Project.TestInheritance");
        Debug.Log("现在来调用成员方法");
        obj.TestAbstract(123);
        obj.TestVirtual("Hello");
        
        Debug.Log("现在换个方式创建实例");
        obj = appdomain.Invoke("HotFix_Project.TestInheritance", "NewObject", null, null) as TestClassBase;
        obj.TestAbstract(456);
        obj.TestVirtual("Foorbar");
    }
}

    
热更新工程

namespace HotFix_Project {
    // 一定要特别注意: 后面只允许有1个Unity主工程的类或者接口,但是可以有随便多少个热更DLL中的接口
    public class TestInheritance: TestClassBase {
        UnityEngine.Debug.Log("!! TestInheritance.TestAbstract gg = " + gg);
    }
    
    public override void TestVirtual(string str) {
        base.TestVirtual(str);
        UnityEngine.Debug.Log("!! TestInheritance.TestVirtual str =" + str);
    }
    
    public static TestInheritance NewObject() {
        return new HotFix_Project.TestInheritance();
    }
}

04_Inheritance

主工程



unsafe void OnHotFixLoaded() {
    Debug.Log("什么时候需要CLR重定向呢,当我们需要挟持原方法实现,添加一些热更DLL中的特殊处理的时候,就需要CLR重定向了");
    Debug.Log("详细文档请参见Github主页的相关文档");
    Debug.Log("CLR重定向对ILRuntime底层实现密切相关,因此要完全理解这个Demo, 需要大家先看关于ILRuntime实现原理的Demo");
    
    Debug.Log("下面介绍一个CLR重定向的典型用法,比如我们在DLL里调用Debug.Log,默认情况下是无法显示DLL内堆栈的,像下面这样");
    Debug.Log("但是经过CLR重定向之后可以做到输出DLL内堆栈,接下来进行CLR重定向注册");
    
    var mi = typeof(Debug).GetMethod("Log", new System.Type[] { typeof(object) });
    // appdomain.RegisterCLRMethodRedirection(mi, Log_11);
    // 这个只是为了演示加的,平时不要这么用,直接在InitializeILRuntime方法里面写CLR重定向注册就行了
    Debug.Log("我们再来调用一次刚刚的方法,注意看下一行日志的变化");
    appdomain.Invoke("HotFix_Project.TestCLRRedirection", "RunTest", null, null);
}


//编写重定向方法对于刚接触ILRuntime的朋友可能比较困难，比较简单的方式是通过CLR绑定生成绑定代码，然后在这个基础上改，比如下面这个代码是从UnityEngine_Debug_Binding里面复制来改的
//如何使用CLR绑定请看相关教程和文档
unsafe static StackObject* Log_11(ILIntepreter __intp, StackObject* __esp, IList<object> __mStack, CLRMethod __method, bool isNewObj)
{
    //ILRuntime的调用约定为被调用者清理堆栈，因此执行这个函数后需要将参数从堆栈清理干净，并把返回值放在栈顶，具体请看ILRuntime实现原理文档
    ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
    StackObject* ptr_of_this_method;
    //这个是最后方法返回后esp栈指针的值，应该返回清理完参数并指向返回值，这里是只需要返回清理完参数的值即可
    StackObject* __ret = ILIntepreter.Minus(__esp, 1);
    //取Log方法的参数，如果有两个参数的话，第一个参数是esp - 2,第二个参数是esp -1, 因为Mono的bug，直接-2值会错误，所以要调用ILIntepreter.Minus
    ptr_of_this_method = ILIntepreter.Minus(__esp, 1);

    //这里是将栈指针上的值转换成object，如果是基础类型可直接通过ptr->Value和ptr->ValueLow访问到值，具体请看ILRuntime实现原理文档
    object message = typeof(object).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
    //所有非基础类型都得调用Free来释放托管堆栈
    __intp.Free(ptr_of_this_method);

    //在真实调用Debug.Log前，我们先获取DLL内的堆栈
    var stacktrace = __domain.DebugService.GetStackTrace(__intp);

    //我们在输出信息后面加上DLL堆栈
    UnityEngine.Debug.Log(message + "\n" + stacktrace);

    return __ret;
}

看看这行的详细Log信息
System.Reflection.MethodBase:Invoke(Object, Object[])
ILRuntime.CLR.Method.CLRMethod:Invoke(ILIntepreter, StackObject*, IList`1, Boolean) (at Assets/ILRuntime/CLR/Method/CLRMethod.cs:316)
ILRuntime.Runtime.Intepreter.ILIntepreter:Execute(ILMethod, StackObject*, Boolean&) (at Assets/ILRuntime/Runtime/Intepreter/ILIntepreter.cs:1797)
ILRuntime.Runtime.Intepreter.ILIntepreter:Run(ILMethod, Object, Object[]) (at Assets/ILRuntime/Runtime/Intepreter/ILIntepreter.cs:96)
ILRuntime.Runtime.Enviorment.AppDomain:Invoke(IMethod, Object, Object[]) (at Assets/ILRuntime/Runtime/Enviorment/AppDomain.cs:1086)
ILRuntime.Runtime.Enviorment.AppDomain:Invoke(String, String, Object, Object[]) (at Assets/ILRuntime/Runtime/Enviorment/AppDomain.cs:989)
CLRRedirectionDemo:OnHotFixLoaded() (at Assets/Scripts/Examples/05_CLRRedirection/CLRRedirectionDemo.cs:85)
d__4:MoveNext() (at Assets/Scripts/Examples/05_CLRRedirection/CLRRedirectionDemo.cs:63)
UnityEngine.SetupCoroutine:InvokeMoveNext(IEnumerator, IntPtr)


热更新工程

namespace HotFix_Project {
    public class TestCLRRedirection {
        public static void RunTest() {
            UnityEngine.Debug.Log("看看这行的详细Log信息");
        }
    }
}

05_CLRRedirection

主工程

public class CLRBindingTestClass {
    public static float DoSomeTest(int a, float b) {
        return a + b;
    }
}

public class CLRBindingDemo: MonoBehaviour {
    
    unsafe void OnHotFixLoaded() {
        ilruntimeReady = true;
    }
    
    bool ilruntimeReady = false;
    bool executed = false;
    void Update()
    {
        if (ilruntimeReady && !executed && Time.realtimeSinceStartup > 3)
        {
            executed = true;
            //这里为了方便看Profiler，代码挪到Update中了
            System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
            Debug.LogWarning("运行这个Demo前请先点击菜单ILRuntime->Generate来生成所需的绑定代码，并按照提示解除下面相关代码的注释");
            Debug.Log("默认情况下，从热更DLL里调用Unity主工程的方法，是通过反射的方式调用的，这个过程中会产生GC Alloc，并且执行效率会偏低");
            
            Debug.Log("接下来进行CLR绑定注册，在进行注册前，需要先在ILRuntimeCodeGenerator的绑定列表里面，添加上CLRBindingTestClass这个测试类型");
            Debug.Log("CLR绑定会生成较多C#代码，最终会增大包体和Native Code的内存耗用，所以只添加常用类型和频繁调用的接口即可");
            Debug.Log("接下来需要点击Unity菜单里面的ILRuntime->Generate CLR Binding Code来生成绑定代码");
            Debug.Log("ILRuntime->Generate CLR Binding Code by Analysis是ILRT1.2版新加入的功能，可以根据热更DLL自动生成绑定代码");
            
            //由于CLR重定向只能重定向一次，并且CLR绑定就是利用的CLR重定向，所以请在初始化最后阶段再执行下面的代码，以保证CLR重定向生效
            //请在生成了绑定代码后注释下面这行
            //throw new System.Exception("请在生成了绑定代码后再运行这个示例");//
            //请在生成了绑定代码后解除下面这行的注释
            //请在生成了绑定代码后解除下面这行的注释
            //请在生成了绑定代码后解除下面这行的注释
            //ILRuntime.Runtime.Generated.CLRBindings.Initialize(appdomain);
            //这个只是为了演示加的，平时不需要这么用，直接在InitializeILRuntime方法里面写CLR绑定注册就行了
            
            var type = appdomain.LoadedTypes["HotFix_Project.TestCLRBinding"];
            var m = type.GetMethod("RunTest", 0);
            Debug.Log("现在我们再来试试绑定后的效果");
            sw.Reset();
            sw.Start();
            Profiler.BeginSample("RunTest2");
            appdomain.Invoke(m, null, null);
            Profiler.EndSample();
            sw.Stop();
            Debug.LogFormat("刚刚的方法执行了:{0} ms", sw.ElapsedMilliseconds);

            Debug.Log("可以看到运行时间和GC Alloc有大量的差别，RunTest2之所以有20字节的GC Alloc是因为Editor模式ILRuntime会有调试支持，正式发布（关闭Development Build）时这20字节也会随之消失");
        }
    }

    void RunTest()
    {
        appdomain.Invoke("HotFix_Project.TestCLRBinding", "RunTest", null, null);
    }

    void RunTest2(IMethod m)
    {
        appdomain.Invoke(m, null, null);
    }
}


热更新工程

namespace HotFix_Project {
    public class TestCLRBinding {
        public static void RunTest() {
            for (int i = 0; i < 100000; i++) {
                CLRBindingTestClass.DoSomeTest(i, i);
            }
        }
    }
}

06_CLRBinding

主工程

using System.Collections.Generic;
using System;
using System.Collections;
using ILRuntime.Runtime.Enviorment;
using ILRuntime.Runtime.Intepreter;
using ILRuntime.CLR.Method;

public class CoroutineAdapter: CrossBindingAdaptor {

    public override Type BaseCLRType {
        get {
            return null;
        }
    }
    
    public override Type[] BaseCLRTypes {
        get {
            //跨域继承只能有1个Adapter，因此应该尽量避免一个类同时实现多个外部接口，对于coroutine来说是IEnumerator