一.热更新方案简介
在Unity游戏工程中，C#代码（编译型语言）资源和Resources文件夹下的资源打包后都不可以更改，因此这部分内容不能进行热更新，而lua代码（解释型语言）逻辑不需要进行预编译再运行，可以在游戏运行过程中进行修改，AB包资源也可以在游戏运行过程中下载解压缩并使用其中的资源。因此客户端可以在启动时检验服务器端的AB包资源是否有更新，如果有更新先下载更新，将lua代码资源和其他更新资源打包为AB包放在服务器端，客户端下载后直接在运行过程中解压缩并使用更新资源，实现了客户端不中断运行即完成更新的目的，也就是热更新。
二.xlua热更新方案简介
xlua框架提供了C#和lua相互调用的功能及Hotfix热补丁的功能，主要目的是方便我们将纯C#工程在不重做的情况下改造成具备热更新功能的工程。
三.准备工作--说明：使用的Unity版本为2019.4.18f1c1，导入的xlua为2021年4月4日从GitHub上直接clone的工程文件，没有下载release版本。
1.xlua框架导入
在GitHub上搜索xlua，找到腾讯的xlua项目，下载项目的压缩包。
下载完成后解压，发现下载的是一个Unity工程文件：
在工程文件中，核心代码是Assets目录下的Plugins和XLua这两个文件夹中的内容，将其复制到自己的工程文件中即可。
将这两个文件夹复制到自己的工程中后稍等一会儿，就会发现在菜单栏中Windows菜单选项左侧出现了XLua菜单选项，没有报错的话说明成功导入。
2.AB包工具导入
在Unity中通过PackageManager导入AB包工具，导入方法详见：热更新基础--AssetBundle学习笔记
3.AB包管理器
为了方便加载AB包，我们可以制作一个AB包的管理器脚本，脚本详见：热更新基础--AssetBundle学习笔记
四.C#调用lua
1.lua解析器
void Start() { //Lua解析器，能够在Unity中执行Lua LuaEnv env = new LuaEnv(); //执行单行Lua语言，使用DoString成员方法 env.DoString("print('hello world!')"); //执行lua脚本，一般都是直接调用lua语言的require关键字执行lua脚本 //默认寻找脚本的路径是在Resources下 //lua后缀Unity不能识别，需要将lua文件添加上.txt以便Unity识别 env.DoString("require('Main')"); //清除lua中没有手动释放的对象，相当于垃圾回收，一般在帧更新中定时执行或者切换场景时执行 env.Tick(); //销毁lua解析器，但是一般不会销毁，因为最好保持解析器的唯一性以节约性能 env.Dispose(); }
2.lua文件加载重定向，即更改使用require关键字加载lua文件时寻找lua文件的位置（默认lua脚本在Resources下才能识别，这和热更新的目的冲突）
void Start() { LuaEnv env = new LuaEnv(); //使用AddLoader方法添加重定向，即自定义文件加载的规则 //参数为一个委托，这个委托有一个ref参数，自动执行传入require执行的脚本文件名，在委托中拼接好完整的路径；委托的返回值为lua文件转化出的字节数组 //添加委托后，委托在执行require语句时自动执行 env.AddLoader(MyCustomLoader); //使用require语句执行lua文件，会自动先调用添加的重定向方法寻找lua文件，如果找不到再到默认路径Resources下寻找 env.DoString("require('Main')"); } /// <summary> /// 重定向方法 /// </summary> /// <param name="filePath">文件名</param> /// <returns></returns> private byte[] MyCustomLoader(ref string filePath) { //拼接完整的lua文件所在路径 string path = Application.dataPath + "/Lua/" + filePath + ".lua"; Debug.Log(path); //判断文件是否存在，存在返回读取的文件字节数组，不存在打印提醒信息，返回null if (File.Exists(path)) { return File.ReadAllBytes(path); } else { Debug.Log("MyCustomLoader重定向失败，文件名为" + filePath); } return null; }
3.lua解析器管理器：对lua解析器的进一步封装以方便使用（4.16更新，增加了只需要直接输入lua文件名即可从Lua文件夹中的子文件夹中读取lua文件的功能）
/// <summary> /// lua管理器，对lua解析器的进一步封装，保证lua解析器的唯一性 /// </summary> public class LuaManager { //单例模块 private static LuaManager instance; public static LuaManager Instance { get { if (instance == null) instance = new LuaManager(); return instance; } } private LuaManager() { //在构造方法中就为唯一的lua解析器赋值 luaEnv = new LuaEnv(); //加载lua脚本重定向 //重定向到lua文件夹下 luaEnv.AddLoader((ref string filePath) => { //用于存储读取结果的数组 byte[] fileContent = null; //拼接lua文件夹的位置 string path = Application.dataPath + "/Lua/"; //调用自定义方法读取lua文件 if(TryGetLoadFile(path,ref fileContent,filePath)) return fileContent; return null; }); //重定向加载AB包中的lua脚本 luaEnv.AddLoader((ref string filePath) => { /*//加载AB包 string path = Application.streamingAssetsPath + "/lua"; AssetBundle bundle = AssetBundle.LoadFromFile(path); //加载lua文件，返回 TextAsset texts = bundle.LoadAsset<TextAsset>(filePath + ".lua"); //返回加载到的lua文件的byte数组 return texts.bytes;*/ /*//使用AB包管理器加载，异步加载，这段代码会始终返回空，因为还没等异步加载完成已经返回了，lua也不适合异步加载，不要使用 byte[] luaBytes = null; AssetBundleManager.Instance.LoadResAsync<TextAsset>("lua", filePath + ".lua", (lua) => { if (lua != null) luaBytes = lua.bytes; else Debug.Log("重定向失败，从AB包加载lua文件失败"); }); return luaBytes;*/ //使用AB包管理器加载，同步加载 TextAsset texts = AssetBundleManager.Instance.LoadRes<TextAsset>("lua", filePath + ".lua"); if (texts != null) return texts.bytes; else Debug.Log("从AB包加载lua文件失败，文件名是" + filePath); return null; }); } //持有一个唯一的lua解析器 private LuaEnv luaEnv; //luaEnv中的大G表，提供给外部调用 public LuaTable Global { get { //校验一下instance是否是null，避免dispose后无法获取的情况出现 if (instance == null) instance = new LuaManager(); return luaEnv.Global; } } /// <summary> /// 执行单句lua代码 /// </summary> /// <param name="luaCodeString"></param> public void DoString(string luaCodeString) { luaEnv.DoString(luaCodeString); } /// <summary> /// 执行lua文件的代码，直接提供文件名即可执行文件，不需要再书写lua的require语句，在方法内部拼接lua语句 /// </summary> /// <param name="fileName">lua文件名</param> public void DoLuaFile(string fileName) { luaEnv.DoString("require('" + fileName + "')"); } /// <summary> /// 释放解析器 /// </summary> public void Tick() { luaEnv.Tick(); } /// <summary> /// 销毁解析器 /// </summary> public void Dispose() { luaEnv.Dispose(); //销毁解析器后将lua解析器对象和单例变量都置空，下次调用时会自动调用构造函数创建lua解析器，以免报空 luaEnv = null; instance = null; } /// <summary> /// 用于重定向读取lua文件的方法，使用递归读取Lua文件夹下的子文件夹 /// </summary> /// <param name="path">文件夹路径</param> /// <param name="fileContent">存储读取结果的数组</param> /// <param name="filePath">lua文件的名称</param> /// <returns></returns> private bool TryGetLoadFile(string path,ref byte[] fileContent,string filePath){ //读取当前文件夹下的文件夹 string[] directories = Directory.GetDirectories(path); //有文件夹的情况下遍历这些文件夹依次递归 if(directories.Length > 0) for(int i = 0;i < directories.Length;i++) //递归，如果读取到了文件，则返回 if(TryGetLoadFile(directories[i],ref fileContent,filePath)) return true; //递归在子文件夹下读取到了文件，下面代码不会执行，如果没有递归读取到，再执行下面的代码 //下面的代码获取当前文件夹下的文件并读取文件 //拼接完整的lua文件所在路径 path = path + "/" + filePath + ".lua"; //判断文件是否存在，存在返回读取的文件字节数组，不存在打印提醒信息，返回null if (File.Exists(path)) { fileContent = File.ReadAllBytes(path); Debug.Log("Lua文件夹重定向成功，文件路径为" + path); return true; } else { Debug.Log("Lua文件夹重定向失败，文件路径为" + path); return false; } } }
4.访问变量
void Start() { LuaManager.Instance.DoLuaFile("Main"); //使用_G表获取luaenv中的global变量值 Debug.Log(LuaManager.Instance.Global.Get<int>("testNumber")); Debug.Log(LuaManager.Instance.Global.Get<bool>("testBool")); Debug.Log(LuaManager.Instance.Global.Get<float>("testFloat")); //使用_G表修改luaenv中的global变量值 LuaManager.Instance.Global.Set("testBool",false); Debug.Log(LuaManager.Instance.Global.Get<bool>("testBool")); //不能直接获取和设置本地变量 }
5.访问函数，使用委托接收
//自定义委托，对于有参数和返回值的委托，必须加上特性[CSharpCallLua],否则无法处理，无参无返回值的委托不需要 //特性起作用还需要在Unity中生成脚本 [CSharpCallLua] public delegate void CustomCall(int a); //自定义含有out或者ref参数的委托用于接收多返回值函数，out和ref根据需要选择，都可以用于接收多返回值 [CSharpCallLua] public delegate int CustomCall2(out int a, out int b); [CSharpCallLua] public delegate void CustomCall3(params int[] args);
void Start() { LuaManager.Instance.DoLuaFile("Main"); //获取函数，使用委托存储 UnityAction npnr = LuaManager.Instance.Global.Get<UnityAction>("NoParamNoReturn"); npnr(); //xlua提供了获取函数的方法，但是不推荐使用，推荐使用Unity或者C#提供的委托或者自定义委托存储 LuaFunction luaFun = LuaManager.Instance.Global.Get<LuaFunction>("NoParamNoReturn"); luaFun.Call(); //有参无返回值 //使用自定义的委托需要声明特性且在Unity中生成代码 CustomCall hpnr = LuaManager.Instance.Global.Get<CustomCall>("HaveParamNoReturn"); hpnr(2); //使用C#提供的委托存储，不用声明特性 Action<int> hpnr2 = LuaManager.Instance.Global.Get<Action<int>>("HaveParamNoReturn"); hpnr2(2); //多返回值 //不能使用系统自带的委托，多返回值需要自定义委托 CustomCall2 mr = LuaManager.Instance.Global.Get<CustomCall2>("ManyReturns"); int m; int n; int p = mr(out m, out n); Debug.Log(m + "-" + n + "-" + p); //变长参数 CustomCall3 vp = LuaManager.Instance.Global.Get<CustomCall3>("VariableParams"); vp(1, 2, 3, 4, 5); }
6.表映射为List或者Dictionary
void Start() { LuaManager.Instance.DoLuaFile("Main"); //得到List List<int> list = LuaManager.Instance.Global.Get<List<int>>("ListTable"); foreach (int i in list) { Debug.Log(i); } //得到Dictionary Dictionary<string, int> dic = LuaManager.Instance.Global.Get<Dictionary<string, int>>("DictionaryTable"); foreach (KeyValuePair<string,int> pair in dic) { Debug.Log(pair.Key + ":" + pair.Value); } }
7.表映射到类对象
/// <summary> /// 声明一个类来和lua中的类进行映射，变量名称必须和lua中的对应类一致，但是不必一一对应，映射时会自动丢弃找不到的内容 /// </summary> public class CallLuaClass { public string name; public int age; public int sex; public UnityAction eat; }
void Start() { LuaManager.Instance.DoLuaFile("Main"); //获得类对象 CallLuaClass clc = LuaManager.Instance.Global.Get<CallLuaClass>("testClass"); Debug.Log(clc.name + "-" + clc.age + "-" + clc.sex); clc.eat(); }
8.表映射到接口
/// <summary> /// 使用一个接口接收表的映射，但是接口中的变量不允许被赋值，这里使用属性 /// 必须加上特性[CSharpCallLua] /// </summary> [CSharpCallLua] public interface ICSharpCallLua { string name { get; set; } int age { get; set; } int sex { get; set; } Action eat { get; set; } }
void Start() { LuaManager.Instance.DoLuaFile("Main"); //得到接口对象 ICSharpCallLua icscl = LuaManager.Instance.Global.Get<ICSharpCallLua>("testClass"); Debug.Log(icscl.name + "-" + icscl.age + "-" + icscl.sex); icscl.eat(); }
注意：之前实现的所有拷贝都是引用拷贝，也就是c#中的拷贝值发生改变，lua代码不受影响，但是接口的拷贝是引用拷贝，也就是改变C#中的拷贝的值，lua中的值也发生了改变。
9.映射到luaTable类
void Start() { LuaManager.Instance.DoLuaFile("Main"); //得到LuaTable，对应lua中的table。 //本质上Global也是LuaTable类型的变量，使用方法和之前通过Global获取各种变量函数等方法相同 //不推荐使用LuaTable和LuaFunction，效率低 //LuaTable的拷贝是引用拷贝 LuaTable table = LuaManager.Instance.Global.Get<LuaTable>("testClass"); Debug.Log(table.Get<int>("age")); Debug.Log(table.Get<string>("name")); Debug.Log(table.Get<int>("sex")); table.Get<LuaFunction>("eat").Call(); }
LuaTable类对应Lua中的表，本质上Global变量也是LuaTable类型，所以LuaTable的使用方法和之前讲的通过Global获取各种变量的方法相同。LuaTable和LuaFunction使用后记得调用dispose方法释放垃圾，否则容易造成内存泄漏。
五.lua调用C#
1.在Unity中无法直接运行lua，因此需要使用C#脚本作为lua脚本的主入口启动lua脚本的运行，接下来都不再赘述这一步骤，所有的lua代码也都在这个特定的lua脚本中编写。
public class Main : MonoBehaviour { private void Start() { //在这个脚本中启动特定的lua脚本，接下来的lua代码都在这个脚本中编写 LuaManager.Instance.DoLuaFile("Main"); } }
Main.lua这个脚本作为lua脚本的入口，接下来再在这个Main.lua脚本中调用其他脚本。
require("CallClass")
2.创建类对象
--lua中调用C#脚本 --创建类对象 --Unity中的类如GameObject、Transform等类都存储在CS表中 --使用CS.命名空间.类名的方式调用Unity中的类 local obj1 = CS.UnityEngine.GameObject("使用lua创建的第一个空物体")
--lua中调用C#脚本 --创建类对象 --Unity中的类如GameObject、Transform等类都存储在CS表中 --使用CS.命名空间.类名的方式调用Unity中的类 --每次都写命名空间太麻烦，可以定义全局变量先把类存储起来，也能节约性能 GameObject = CS.UnityEngine.GameObject local obj = GameObject("movin") --使用点来调用静态方法 local obj2 = GameObject.Find("movin") --使用.来调用对象中的成员变量 Log = CS.UnityEngine.Debug.Log Log(obj.transform.position) Vector3 = CS.UnityEngine.Vector3 --使用对象中的成员方法必须使用:调用 obj.transform:Translate(Vector3.right) Log(obj.transform.position) --自定义类的调用 --直接使用CS点的方式调用 local customClass = CS.CustomClass() customClass.name = "movin" customClass:Eat() --有命名空间的类再点一层 local customClassInNamespace = CS.CustomNamespace.CustomClassInNamespace() customClassInNamespace.name = "movin2" customClassInNamespace:Eat() --继承了mono的类不能new出来，只能获取组件 --xlua提供了typeof的方法得到类的Type --自定义的脚本组件直接用CS点出来即可 obj:AddComponent(typeof(CS.Main)) --系统自带的脚本一般在UnityEngine命名空间下 obj:AddComponent(typeof(CS.UnityEngine.Rigidbody))
/// <summary> /// 自定义类 /// </summary> public class CustomClass { public string name; public void Eat() { Debug.Log(name + "在吃饭"); } } /// <summary> /// 自定义类，包裹在命名空间中 /// </summary> namespace CustomNamespace { public class CustomClassInNamespace { public string name; public void Eat() { Debug.Log(name + "在吃饭"); } } }
3.使用枚举
--调用枚举 --调用Unity提供的枚举 --Unity提供的枚举一般在UnityEngine中 PrimitiveType = CS.UnityEngine.PrimitiveType GameObject = CS.UnityEngine.GameObject local obj = GameObject.CreatePrimitive(PrimitiveType.Cube) --调用自定义的枚举 E_CustomEnum = CS.E_CustomEnum Log = CS.UnityEngine.Debug.Log Log(E_CustomEnum.Idle) --使用_CastFrom方法进行枚举类型转换，可以从数字转换成枚举或者字符串转换成枚举 Log(E_CustomEnum.__CastFrom(1)) Log(E_CustomEnum.__CastFrom("Atk"))
4.使用List和Dictionary
local CustomClass = CS.CustomClass local Log = CS.UnityEngine.Debug.Log --调用数组，使用C#的数组相关API，不要使用lua的方法 obj = CustomClass(); Log(obj.array.Length) --遍历数组,注意从0到length-1，按照C#的下标遍历不是lua的 for i=0,obj.array.Length-1 do Log(obj.array[i]) end Log("******************") --创建数组，利用数组类Array的CreateInstance静态方法创建数组 --参数意思：创建数组中存储元素的类型、创建的数组的长度 local arr = CS.System.Array.CreateInstance(typeof(CS.System.Int32),5) Log(arr.Length) Log(arr[1]) Log("******************") --调用List，调用成员方法用: obj.list:Add('M') for i = 0,obj.list.Count-1 do Log(obj.list[i]) end Log("******************") --创建List --老版，方法很麻烦 local list2 = CS.System.Collections.Generic["List`1[System.String]"]() list2:Add("abcde") Log(list2[0]) --新版 版本>v2.1.12 先创建一个类，再实例化出来list local List_String = CS.System.Collections.Generic.List(CS.System.String) local list3 = List_String() list3:Add("aaaaaaaaaa") Log(list3[0]) Log("******************") --调用dic obj.dic:Add(1,"abc") obj.dic:Add(2,"def") --遍历 for k,v in pairs(obj.dic) do Log(k.."--"..v) end Log("******************") --创建dic local Dic_String_Vector3 = CS.System.Collections.Generic.Dictionary(CS.System.String,CS.UnityEngine.Vector3) local dic2 = Dic_String_Vector3() dic2:Add("abc",CS.UnityEngine.Vector3.right) dic2:Add("def",CS.UnityEngine.Vector3.up) Log(dic2["abc"]) --在lua中创建的字典使用这种方式得不到值，这句代码打印出的结果是空值 Log(dic2:get_Item("abc")) --在lua中自己创建的字典使用get_Item方法得到值 dic2:set_Item("abc",CS.UnityEngine.Vector3.left) --同样地，通过set_Item方法设置字典地值 Log(dic2:get_Item("abc")) print(dic2:TryGetValue("abc")) --也可以通过TryGetValue方法获取值 for k,v in pairs(dic2) do print(k,v) end
/// <summary> /// 自定义类 /// </summary> public class CustomClass { public string[] array = { "a","b","c","d","e","f","g","h" }; public List<char> list = new List<char>{ 'A','B','C','D','E','F','G','H','I','J' }; public Dictionary<int, string> dic = new Dictionary<int, string>(); }
5.使用C#拓展方法
CustomClass = CS.CustomClass --使用成员方法 local customClass = CustomClass() customClass.name = "movin" customClass:Eat() --使用拓展方法，拓展方法一定是静态方法，但是调用时和成员方法一样的调用方式 --在定义拓展方法的工具类前一定加上特性[LuaCallCSharp]，并且生成代码 customClass:Move()
/// <summary> /// 自定义类 /// </summary> public class CustomClass { public string name; public void Eat() { Debug.Log(name + "在吃饭"); } } /// <summary> /// 工具类，定义拓展方法 /// </summary> [LuaCallCSharp] public static class Tools { public static void Move(this CustomClass cc) { Debug.Log(cc.name + "在移动"); } }
建议：要在lua中使用的C#类都可以加上[LuaCallCSharp]特性，这样预先将代码生成，可以提高Lua访问C#类的性能。
6.使用含有ref和out参数的函数
CustomClass = CS.CustomClass local obj = CustomClass() --ref参数，使用多返回值形式接收 --如果函数有返回值，这个返回值是多返回值的第一个 --参数数量不够，会默认使用默认值补位 local a,b,c = obj:RefFun(1,0,0,1) print(a,b,c) --out参数，还是以多返回值的形式接收 --out参数不需要传递值 local a,b,c = obj:OutFun(23,24) print(a,b,c) --综合来看 --从返回值上看，ref和out都会以多返回值的形式返回，原来如果有返回值的话原来的返回值是多返回值中的第一个 --从参数看，ref参数需要传递，out参数不需要传递 local a,b,c = obj:RefOutFun(12,23) print(a,b,c)
/// <summary> /// 自定义类 /// </summary> public class CustomClass { public int RefFun(int a ,ref int b,ref int c,int d) { b = a + d; c = a - d; return 100; } public int OutFun(int a,out int b,out int c,int d) { b = a; c = d; return 200; } public int RefOutFun(int a,out int b,ref int c) { b = a * 10; c = a * 20; return 200; } }
7.使用重载函数
CustomClass = CS.CustomClass local customClass = CustomClass() --使用重载函数 --lua支持调用C#的重载函数 --lua中的数值类型只有number，所以对C#中多精度的重载函数支持不好，使用时可能出现问题 --如第四个重载函数调用结果为0（应该是11.4），所以应避免这种情况 print(customClass:Calc()) print(customClass:Calc(1)) print(customClass:Calc(2,3)) print(customClass:Calc(1.4)) --解决重载函数含糊的问题（效率低，仅作了解） --运用反射 local m1 = typeof(CustomClass):GetMethod("Calc",{typeof(CS.System.Int32)}) local m2 = typeof(CustomClass):GetMethod("Calc",{typeof(CS.System.Single)}) --通过xlua提供的tofunction方法将反射得到的方法信息转化为函数 local f1 = xlua.tofunction(m1) local f2 = xlua.tofunction(m2) --再次调用函数，非静态方法需要传入对象 print(f1(customClass,10)) print(f2(customClass,1.4))
/// <summary> /// 自定义类 /// </summary> public class CustomClass { public int Calc() { return 100; } public int Calc(int a,int b) { return a + b; } public int Calc(int a) { return a; } public float Calc(float a) { return a + 10; } }
8.委托和事件
local customClass = CS.CustomClass() --委托中存储的是函数，声明函数存储到委托中 local fun = function() print("函数fun") end --委托中第一次添加函数使用=添加 customClass.action = fun --委托中第二次添加函数使用+=，lua中不支持+=运算符，需要分开写 customClass.action = customClass.action + fun --委托中也可以添加匿名函数 customClass.action = customClass.action + function() print("临时函数") end --使用点调用委托还是冒号调用委托都可以调用，最好使用冒号 customClass:action() print("********************") --事件和委托的使用方法不一致（事件不能在外部调用） --使用冒号添加和删除函数，第一个参数传入加号或者减号字符串，表示添加还是修改函数 --事件也可以添加匿名函数 customClass:eventAction("+",fun) --事件不能直接调用，必须在C#中提供调用事件的方法，这里已经提供了DoEvent方法执行事件 customClass:DoEvent() --同样地，事件不能直接清空，需要在C#中提供对应地方法
/// <summary> /// 自定义类 /// </summary> public class CustomClass { public UnityAction action; public event UnityAction eventAction; public void DoEvent() { if (eventAction != null) eventAction(); } }
9.特殊问题
local customClass = CS.CustomClass() --特殊问题一：得到二维数组指定位置元素的值 --获取二维数组的长度 print("行："..customClass.array:GetLength(0)) print("行："..customClass.array:GetLength(1)) --不能通过C#的索引访问元素(array[0,0]或array[0][0]) --使用数组提供的成员方法GetValue访问元素 print(customClass.array:GetValue(0,0)) --遍历 for i=0,customClass.array:GetLength(0)-1 do for j=0,customClass.array:GetLength(1)-1 do print(customClass.array:GetValue(i,j)) end end print("***********************") --特殊问题二：lua中空值nil和C#中空值null的比较 --往场景对象上添加一个脚本，存在就不加，不存在再加 GameObject = CS.UnityEngine.GameObject Rigidbody = CS.UnityEngine.Rigidbody local obj = GameObject("测试nil和null") local rigidbody = obj:GetComponent(typeof(Rigidbody)) print(rigidbody) --校验空值，看是否需要添加脚本 --nil和null并不相同，在lua中不能使用==进行判空，一定要使用Equals方法进行判断 --这里如果rigidbody为空，可能报错，所以可以自己提供一个判空函数进行判空 --这里为了笔记方便将函数定义在这里，这个全局函数最好定义在lua脚本启动的主函数Main中 function IsNull(obj) if obj == nil or obj:Equals(nil) then return true end return false end --使用自定义的判空函数进行判断 if IsNull(rigidbody) then rigidbody = obj:AddComponent(typeof(Rigidbody)) end print(rigidbody) print("***********************") --特殊问题三：让lua和系统类型能够相互访问 --对于自定义的类型，可以添加CSharpCallLua和LuaCallCSharp这两个特性使Lua和自定义类型能相互访问，但是对于系统类或第三方代码库，这种方式并不适用 --为系统类或者第三方代码库加上这两个特性的写法比较固定，详情见C#代码
/// <summary> /// 自定义类 /// </summary> public class CustomClass { public int[,] array = new int[2, 3] { { 1, 2, 3 }, { 4, 5, 6 } }; //实现为系统类添加[CSharpCallLua]和[LuaCallCSharp]特性 [CSharpCallLua] public static List<Type> csharpCallLuaList = new List<Type>() { //将需要添加特性的类放入list中 typeof(UnityAction<float>), }; [LuaCallCSharp] public static List<Type> luaCallCsharpList = new List<Type>() { typeof(GameObject), }; }
10.使用协程
--xlua提供了一个工具表，要使用协程必须先调用这个工具表 util = require("xlua.util") GameObject = CS.UnityEngine.GameObject WaitForSeconds = CS.UnityEngine.WaitForSeconds local obj = GameObject("Coroutine") local mono = obj:AddComponent(typeof(CS.LuaCallCSharp)) --被开启的协程函数 fun = function() local a = 1 while true do --lua中不能直接使用C#中的yield return返回 --使用lua中的协程返回方法 coroutine.yield(WaitForSeconds(1)) print(a) a = a + 1 if a>10 then --协程的关闭，必须要将开启的协程存储起来 mono:StopCoroutine(startedCoroutine) end end end --启动协程 --写法固定，必须使用固定表的cs_generate方法把xlua方法处理成mono能够使用的协程方法 startedCoroutine = mono:StartCoroutine(util.cs_generator(fun))
11.使用泛型函数
lua中没有泛型语法，对于C#中的泛型方法，可以直接传递参数（因为lua中不需要声明类型），但是这种写法并不是所有的泛型方法都支持，xlua只支持有约束且泛型作为参数的泛型函数，其他泛型函数不支持。如果要在lua中调用泛型函数，可以使用特定的语法。
local tank = CS.UnityEngine.GameObject.Find("Tank") --xlua提供了得到泛型函数的方法get_generic_method，参数第一个为类名，第二个为方法名 local addComponentFunc = xlua.get_generic_method(CS.UnityEngine.GameObject,"AddComponent") --接着调用这个泛型方法，参数为泛型的类，得到一个新方法 local addComponentFunc2 = addComponentFunc(CS.MonoForLua) --调用,第一个参数是调用的对象，如果有其他参数在后面传递 addComponentFunc2(tank)
使用限制：打包时如果使用mono打包，这种方式支持使用；如果使用il2cpp打包，泛型参数需要是引用类型或者是在C#中已经调用过的值类型。