Xlua原理分析 四

已于 2024-07-31 10:26:55 修改
阅读量633 收藏 4
点赞数 9
分类专栏： unity热更系列 文章标签： unity
于 2024-07-30 22:02:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25978293/article/details/140633001
版权

前面已经介绍了Xlua的通信原理，这篇主要记录Xlua如何做到Hotfix的。

我们项目就用到Xlua的Hotfix特性，周更用Lua去修改代码。版本内用C#开发。这点我觉得是Xlua比toLua强大的重要特性之一。

如何使用Hotfix本篇不介绍了，看Xlua教程懂得都懂，着重于原理部分。

一、如何进行Hotfix

先上测试代码：

    void Update()
        {
            if (++tick % 50 == 0)
            {
                Debug.Log(">>>>>>>>Update in C#, tick = " + tick);
                TestHotFixLog("C#");
            }
        }

        public void TestHotFixLog(string str)
        {
            Debug.Log("TestHotFixLog:" + str);
        }
        void OnGUI()
        {
            if (GUI.Button(new Rect(10, 10, 300, 80), "Hotfix"))
            {
                luaenv.DoString(@"
                xlua.hotfix(CS.XLuaTest.HotfixTest, 'Update', function(self)
                    self.tick = self.tick + 1
                    if (self.tick % 50) == 0 then
                        print('<<<<<<<<Update in lua, tick = ' .. self.tick)
                        self:TestHotFixLog('lua')
                    end
                end)
            ");
            }
        }

使用反编译编译Library\ScriptAssemblies\Assembly-CSharp.dll。可以看到这段

可以清晰的看到，反编译后是生成了一些委托，如果委托函数有值就不走原函数。

看看DelegateBridge 的结构：

对应上面的Update的这个函数，又看到了熟悉的压栈操作，通过这样的方式可实现热修

C#端的基础原理搞清后。看看xlua.hotfix都干了什么事。

xlua.hotfix = function(cs, field, func)
                if func == nil then func = false end
                local tbl = (type(field) == 'table') and field or {[field] = func}
                for k, v in pairs(tbl) do
                    local cflag = ''
                    if k == '.ctor' then
                        cflag = '_c'
                        k = 'ctor'
                    end
                    local f = type(v) == 'function' and v or nil
                    xlua.access(cs, cflag .. '__Hotfix0_'..k, f) -- at least one
                    pcall(function()
                        for i = 1, 99 do
                            xlua.access(cs, cflag .. '__Hotfix'..i..'_'..k, f)
                        end
                    end)
                end
                xlua.private_accessible(cs)
            end

cs对应改的C#类，跟上面的反编译脚本一致。

field一个字符串

func方法。

可以看到他这里拼接了字符串，然后去向C#的委托去传递这个方法。

xlua.access(cs, cflag .. '__Hotfix0_'..k, f) -- at least one 
这里对应上述修改的__Hotfix0_Update

后面1-99 是修改了重载函数，造成了一定的性能损失。

PS：我们项目不允许C#代码使用同名重载函数，会出现很多意外的问题，可能就跟这里有关

再刨个根吧，看看xlua.access的实现：

[MonoPInvokeCallback(typeof(LuaCSFunction))]
        public static int XLuaAccess(RealStatePtr L)
        {
            try
            {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Type type = getType(L, translator, 1);
                object obj = null;
                if (type == null && LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TUSERDATA)
                {
                    obj = translator.SafeGetCSObj(L, 1);
                    if (obj == null)
                    {
                        return LuaAPI.luaL_error(L, "xlua.access, #1 parameter must a type/c# object/string");
                    }
                    type = obj.GetType();
                }

                if (type == null)
                {
                    return LuaAPI.luaL_error(L, "xlua.access, can not find c# type");
                }

                string fieldName = LuaAPI.lua_tostring(L, 2);

                BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static;

                if (LuaAPI.lua_gettop(L) > 2) // set
                {
                    var field = type.GetField(fieldName, bindingFlags);
                    if (field != null)
                    {
                        field.SetValue(obj, translator.GetObject(L, 3, field.FieldType));
                        return 0;
                    }
                    var prop = type.GetProperty(fieldName, bindingFlags);
                    if (prop != null)
                    {
                        prop.SetValue(obj, translator.GetObject(L, 3, prop.PropertyType), null);
                        return 0;
                    }
                }
                else
                {
                    var field = type.GetField(fieldName, bindingFlags);
                    if (field != null)
                    {
                        translator.PushAny(L, field.GetValue(obj));
                        return 1;
                    }
                    var prop = type.GetProperty(fieldName, bindingFlags);
                    if (prop != null)
                    {
                        translator.PushAny(L, prop.GetValue(obj, null));
                        return 1;
                    }
                }
                return LuaAPI.luaL_error(L, "xlua.access, no field " + fieldName);
            }
            catch (Exception e)
            {
                return LuaAPI.luaL_error(L, "c# exception in xlua.access: " + e);
            }
        }

这里是使用了type获取元数据进行调用。

至此，xlua的hotfix原理已经清晰了。

util.hotfix就是先执行一遍lua的函数体，然后再执行一遍hotfix。所以可以执行原函数

--和xlua.hotfix的区别是：这个可以调用原来的函数
local function hotfix_ex(cs, field, func)
    assert(type(field) == 'string' and type(func) == 'function', 'invalid argument: #2 string needed, #3 function needed!')
    local function func_after(...)
        xlua.hotfix(cs, field, nil)
        local ret = {func(...)}
        xlua.hotfix(cs, field, func_after)
        return unpack(ret)
    end
    xlua.hotfix(cs, field, func_after)
end

二、如何生成程序集

  1. Generate Code
    这一步主要根据是根据C#类中需要支持热更的方法生成其对应的委托方法，但是并不是每个方法对应一个委托，而是根据调用参数和返回参数公用委托。这块之前有详细介绍代码，就不复述了。
  2. Hotfix Inject
    这一步主要是对Unity编译出的Dll中的C#类添加判断条件，以此来选择调用Lua中的修复方法还是直接执行C#代码

这一步是在Unity为C#代码生成完对应dll之后，由XLua再来对dll注入一些判断条件式来完成是否进行Lua调用的行为。
判断方法很简单，检查对应类静态字段是否有DelegateBridge对象。
实现如下：

bool injectMethod(MethodDefinition method, HotfixFlagInTool hotfixType)
        {
            var type = method.DeclaringType;
            
            bool isFinalize = (method.Name == "Finalize" && method.IsSpecialName);
            //__Gen_Delegate_Imp 方法引用
            MethodReference invoke = null;

            int param_count = method.Parameters.Count + (method.IsStatic ? 0 : 1);
			//根据返回值和参数个数类型和方法全名找对应的C#方法
            if (!findHotfixDelegate(method, out invoke, hotfixType))
            {
                Error("can not find delegate for " + method.DeclaringType + "." + method.Name + "! try re-genertate code.");
                return false;
            }

            if (invoke == null)
            {
                throw new Exception("unknow exception!");
            }

#if XLUA_GENERAL
            invoke = injectAssembly.MainModule.ImportReference(invoke);
#else
            invoke = injectAssembly.MainModule.Import(invoke);
#endif
			//插入的类静态字段，用来标记对应的方法是否有对应的Lua注入
            FieldReference fieldReference = null;
			//方法中的变量定义
            VariableDefinition injection = null;
			//IntKey前面InjectType设置过，没有泛型参数并且是同一个程序集
            bool isIntKey = hotfixType.HasFlag(HotfixFlagInTool.IntKey) && !type.HasGenericParameters && isTheSameAssembly;
            //isIntKey = !type.HasGenericParameters;
			
            if (!isIntKey)
            {
				//新建变量，看起来跟重载函数有关系
                injection = new VariableDefinition(invoke.DeclaringType);
                method.Body.Variables.Add(injection);
				//luaDelegateName 是个string方法名称
				//获取这个方法对应的委托名，因为有重载方法存在，所以之前已经注入的过的方法会在这边获取时候计数加1，
                //比如第一个重载获取的是__Hotfix0，那么下一个重载会是__Hotfix1，判断是否注入就是是否设置对应FieldReference。
                var luaDelegateName = getDelegateName(method);
				//一般不error，除非超过 MAX_OVERLOAD 100个。
                if (luaDelegateName == null)
                {
                    Error("too many overload!");
                    return false;
                }
				//创建对应的静态Field名字就是上面取到的luaDelegateName
                FieldDefinition fieldDefinition = new FieldDefinition(luaDelegateName, Mono.Cecil.FieldAttributes.Static | Mono.Cecil.FieldAttributes.Private,
                    invoke.DeclaringType);
                type.Fields.Add(fieldDefinition);
                fieldReference = fieldDefinition.GetGeneric();
            }

            bool ignoreValueType = hotfixType.HasFlag(HotfixFlagInTool.ValueTypeBoxing);
			 //IL插入位置，现在定位的是方法体的第一行
            var insertPoint = method.Body.Instructions[0];
			//获取IL处理器
            var processor = method.Body.GetILProcessor();
			//构造函数换个位置插。先不管了
            if (method.IsConstructor)
            {
                insertPoint = findNextRet(method.Body.Instructions, insertPoint);
            }

            Dictionary<Instruction, Instruction> originToNewTarget = new Dictionary<Instruction, Instruction>();
            HashSet<Instruction> noCheck = new HashSet<Instruction>();

            while (insertPoint != null)
            {
                Instruction firstInstruction;
				//isIntKey这边用到的是Xlua中的AutoIdMap，这边只对最基础的功能做分析，这边就分析基础的注入了。
                if (isIntKey)
                {
                    firstInstruction = processor.Create(OpCodes.Ldc_I4, bridgeIndexByKey.Count);
                    processor.InsertBefore(insertPoint, firstInstruction);
					//调用方法
                    processor.InsertBefore(insertPoint, processor.Create(OpCodes.Call, hotfixFlagGetter));
                }
                else
                {
					//创建第一条IL语句，获取类的静态Field压入方法栈中，其实就是之前luaDelegateName获取的字段（换句话说这里就是创建诸如 __Hotfix0_Start;）
                    firstInstruction = processor.Create(OpCodes.Ldsfld, fieldReference);
                    //插入insertPoint之前
                    processor.InsertBefore(insertPoint, firstInstruction);
                    //创建并插入IL，获取栈顶的值并压入到对应的变量中，injection就是我们之前创建的新建变量
                    processor.InsertBefore(insertPoint, processor.Create(OpCodes.Stloc, injection));
                    //创建并插入IL，压入变量体中的值到栈
                    processor.InsertBefore(insertPoint, processor.Create(OpCodes.Ldloc, injection));
                }
				//创建跳转语句，为false时候直接跳转insertPoint,
                //这边OpCodes.Brfalse看起来是布尔值判断，其实也会判断是否为null
                var jmpInstruction = processor.Create(OpCodes.Brfalse, insertPoint);
                processor.InsertBefore(insertPoint, jmpInstruction);

                if (isIntKey)
                {
					//创建当前指令参数数据源并后续调用
                    processor.InsertBefore(insertPoint, processor.Create(OpCodes.Ldc_I4, bridgeIndexByKey.Count));
					//创建委托函数对象
                    processor.InsertBefore(insertPoint, processor.Create(OpCodes.Call, delegateBridgeGetter));
                }
                else
                {
					//创建并插入IL,再次压入变量的值，因为上面做完判断后，栈顶的值就会被弹出，所以这边要再次压入
                    processor.InsertBefore(insertPoint, processor.Create(OpCodes.Ldloc, injection));
                }
				//成员函数比静态函数多了个参数，即自身，这步是压栈参数个数
                for (int i = 0; i < param_count; i++)
                {
                    if (i < ldargs.Length)
                    {
                        processor.InsertBefore(insertPoint, processor.Create(ldargs[i]));
                    }
                    else if (i < 256)
                    {
                        processor.InsertBefore(insertPoint, processor.Create(OpCodes.Ldarg_S, (byte)i));
                    }
                    else
                    {
                        processor.InsertBefore(insertPoint, processor.Create(OpCodes.Ldarg, (short)i));
                    }
                    if (i == 0 && !method.IsStatic && type.IsValueType)
                    {
                        processor.InsertBefore(insertPoint, processor.Create(OpCodes.Ldobj, type));
                        
                    }
					 //对值类型进行Box
                    if (ignoreValueType)
                    {
                        TypeReference paramType;
                        if (method.IsStatic)
                        {
                            paramType = method.Parameters[i].ParameterType;
                        }
                        else
                        {
                            paramType = (i == 0) ? type : method.Parameters[i - 1].ParameterType;
                        }
                        if (paramType.IsValueType)
                        {
                            processor.InsertBefore(insertPoint, processor.Create(OpCodes.Box, paramType));
                        }
                    }
                }
				//创建并插入IL，调用invoke方法，因为之前已经压入injection的值，DelegateBridge的对象
                processor.InsertBefore(insertPoint, processor.Create(OpCodes.Call, invoke));
				//如果不是结构体，或者isFinalize，从当前方法返回，并将返回值（如果存在）从调用方的计算堆栈推送到被调用方的计算堆栈上。
                if (!method.IsConstructor && !isFinalize)
                {
                    processor.InsertBefore(insertPoint, processor.Create(OpCodes.Ret));
                }
				
                if (!method.IsConstructor)
                {
                    break;
                }
                else
                {
					//普通方法，加入返回操作
                    originToNewTarget[insertPoint] = firstInstruction;
                    noCheck.Add(jmpInstruction);
                }
				//寻找下一个插入位置
                insertPoint = findNextRet(method.Body.Instructions, insertPoint);
            }
			//结构体的处理
            if (method.IsConstructor)
            {
                fixBranch(processor, method.Body.Instructions, originToNewTarget, noCheck);
            }
			//isFinalize的处理
            if (isFinalize)
            {
                if (method.Body.ExceptionHandlers.Count == 0)
                {
                    throw new InvalidProgramException("Finalize has not try-catch? Type :" + method.DeclaringType);
                }
                method.Body.ExceptionHandlers[0].TryStart = method.Body.Instructions[0];
            }
            if (isIntKey)
            {
                bridgeIndexByKey.Add(method);
            }
            return true;
        }

     

参考：

xlua hotfix分析

https://zhuanlan.zhihu.com/p/68907610/

OpCodes指令

https://www.cnblogs.com/chenxiaoran/archive/2012/11/19/2776807.html

雷霆嘎子
关注
  • 9
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
xLua框架源码
09-16
对于Unity开发者来说，掌握xLua的使用和原理，无疑能提升项目开发的灵活性和效率。因此，无论是初学者还是经验丰富的开发者，都应该花时间去探索和研究xLua的源码，这将对你的Unity项目带来极大的助益。
mac M1 xlua 重新编译的 xlua bundle
04-10
4. 编译XLua：使用Unity的命令行工具（如Unity Hub中的"Open in Terminal"功能）来构建项目，确保编译选项指定为ARM64架构。在C#部分，确保Unity Editor和Player都使用了正确的Target Framework版本。在C++部分，...
XLua 原理分析 三
qq_25978293的博客
07-23 724
Xlua 通信调用
XLua原理（一）
qq_25978293的博客
07-18 859
xlua原理深入分析
Xlua原理 二
qq_25978293的博客
07-22 768
Xlua Wrap文件分析
Xlua调用c#原理浅析
u014516123的博客
09-08 1057
浅析Xlua原理
xlua源码分析（五） struct类型优化
异次元的归来
01-15 1195
而数据传输的逻辑，稍微不太相同，tolua是使用lua函数进行数据传输，例如Vector3，tolua可以通过一个get函数直接返回3个float*给C#层，也可以通过一个new函数直接使用x，y，z三个参数构造出一个lua层的struct，pack和unpack的逻辑都放在了lua层里。函数是在C层实现的，那其实很简单了，就是把userdata作为要访问内存的首地址，加上偏移量offset，执行memcpy即可，如果是get，就是从userdata拷贝到value，再push到lua栈；
xlua源码分析
UNITY3D游戏引擎技术专家
12-26 653
xlua调用c#代码 在xlua中可以直接调用c#代码，例如： CS.UnityEngine.Debug.Log('hello world') CS是一个全局的Table，所以CS.UnityEngine可以当做是在一个名为CS的Table表中查询名为UnityEngine的值。获取其值是通过CS的元方法__index来实现的。其逻辑代码在创建LuaEnv时候调用下面的代码，进行CS表的初始化 DoString(init_xlua, "Init"); 下面代码是截取了部分的init_xlu.
Xlua调用C#重载函数原理
u014516123的博客
09-09 658
lua中调用C#重载函数原理
xlua源码分析（一） C# Call lua的实现
异次元的归来
10-21 332
与tolua一样，lua函数被C#引用时，都会存放到registry表中缓存，同时C#获取到该函数的reference之后，会生成一个负责生成具体委托的包装类对象，这里就是DelegateBridge，它是以弱引用的形式存放在delegate_bridges里的，这里使用弱引用，因为delegate_bridges只负责查询，真正引用它的是具体的委托。另外，xlua的DoString是有返回值的，返回类型是object数组，也就是C#可以执行任意的lua代码，并且直接获取到lua代码的返回值。
xlua源码分析（六） C#与lua的交互总结
异次元的归来
02-21 1008
我们分析了xlua对struct类型所做的优化，本节我们系统性地梳理一下xlua中C#与lua的交互。所谓C#与lua的交互，其实主要就分为两部分，第一是往lua层中传数据，第二则是从lua层中取数据。
XLua与Unity交互
06-29
4. 在C#脚本中，可以使用[CSharpCallLua]注解，将C#函数暴露给Lua环境。 5. 使用metatable实现Lua表与C#对象的交互。 XLua与Unity交互提供了一个强大的工具，可以快速编写游戏逻辑、简化游戏开发流程、提高开发效率...
unity xlua lua5.4.4最新版lua库文件
07-26
4. 示例脚本：可能包含一些示例Lua脚本，帮助开发者了解如何在Unity项目中使用XLua。 使用这些文件，你可以开始在Unity项目中集成Lua脚本。首先，将"Plugins"目录导入到Unity工程中。然后，你可以创建或修改Lua脚本...
xLua-master
03-26
《使用xLua开发热更新...通过深入理解xLua的工作原理，正确集成并运用到项目中，能够显著提升开发效率，同时为用户提供无缝的更新体验。希望这份基于“xLua-master”的实践指南能帮助开发者顺利开启xLua的热更新之旅。
开题报告电影票订票APP的设计与实现 已通过开题答辩的.doc
07-30
近些年的电影在人们文娱活动中占据重要地位，另外，由于人们的生活越来越富有，越来越多的人们不再选择在家里看电影，而是选择去电影院看电影。但是，以往的售票方式是需要工作人员一张张的录入到账户薄中的，这一模式已不再适应现在的实际情况，因为手动的操作不仅繁琐还容易存在差错。随着电子商务的发展，网络购票已经成为一种趋势，电子影票也已经慢慢走入人们的生活。目前，网票网作为国内首家全国性的网上选座购买电影票平台完全实现网上/手机查看影讯、自助选座、网银支付、自助验票全自助化营运模式。
Magene_C506_1722330141_905661_1722351868.fit
最新发布
07-30
Magene_C506_1722330141_905661_1722351868.fit
麻雀搜索算法SSA-CNN-BiLSTM-Mutilhead-Attention多变量时序预测含源码 5631.zip
07-30
CSDN海神之光上传的全部代码均可运行，亲测可用，直接替换数据即可，适合小白； 1、代码压缩包内容 主函数：Main .m； 数据； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除Main.m的其他m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博主博客文章底部QQ名片； 4.1 CSDN博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 智能优化算法-CNN-BiLSTM-Mutilhead-Attention回归预测系列程序定制或科研合作方向： 4.4.1 遗传算法GA/蚁群算法ACO-CNN-BiLSTM-Mutilhead-Attention回归预测 4.4.2 粒子群算法PSO/蛙跳算法SFLA-CNN-BiLSTM-Mutilhead-Attention回归预测 4.4.3 灰狼算法GWO/狼群算法WPA-CNN-BiLSTM-Mutilhead-Attention回归预测 4.4.4 鲸鱼算法WOA/麻雀算法SSA-CNN-BiLSTM-Mutilhead-Attention回归预测 4.4.5 萤火虫算法FA/差分算法DE-CNN-BiLSTM-Mutilhead-Attention回归预测
开题报告 二手手机收售系统【答辩高分内容】.doc
07-30
当换手机变成如“女人换衣服”般的容易，你被换下的那款二手手机究竟流向何处，才能释放其最大经济价值？某环保组织曾批露一组数据——每年，中国都会产生230万吨电子垃圾，仅次于美国的300万吨，是世界第二大电子垃圾生产国，并且还以年均20％的速度增加。另外据不完全统计，目前全国仅闲置手机就有10亿多部，并且每年新增3至5亿部。机遇与危机并存 据统计，我国手机用户数量现已达11．46亿。仅去年一年，全国就销售4．25亿部新手机，同时有近4亿部手机被淘汰。在这个手机更新换代比眨眼还快的年代，我国旧手机的回收和无害化处理措施却没能跟上，不少淘汰下来的旧手机都面临“无处可去”的尴尬。
XLUA框架的底层实现原理
03-13
XLUA是一种用于Lua脚本与C#代码交互的框架，它的底层实现原理主要包括以下几个方面： 1. Lua虚拟机：XLUA使用了Lua虚拟机作为脚本的执行环境。Lua虚拟机是一个轻量级的解释器，可以解析和执行Lua脚本。XLUA通过调用Lua虚拟机提供的API来加载和执行Lua脚本。 2. C#与Lua的交互：XLUA通过封装Lua虚拟机提供的API，实现了C#与Lua之间的双向交互。在C#中，XLUA提供了一系列的API，可以用来加载和执行Lua脚本，获取和设置Lua变量，调用Lua函数等。在Lua中，XLUA提供了一些特殊的语法和函数，可以直接调用C#中的方法和访问C#中的变量。 3. 自动化绑定：XLUA通过自动化绑定机制，将C#中的类、方法、属性等与Lua中的对应概念进行绑定。这样，在Lua中就可以直接使用C#中定义的类和方法，而无需手动编写繁琐的绑定代码。XLUA使用了一些元数据技术，通过反射等方式来自动分析C#代码，并生成相应的绑定信息。 4. 性能优化：XLUA在底层实现中进行了一些性能优化，以提高脚本的执行效率。例如，XLUA使用了缓存机制来避免重复的绑定操作，使用了快速访问方式来提高Lua变量和C#变量的访问速度，使用了内存池来减少内存分配等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值