【第三篇】C#调用lua文件
获取一个全局基本数据类型
使用LuaEnv.Global.Get<T>("name")就可以
1 var str = luaEnv.Global.Get<string>("str"); 2 var num1 = luaEnv.Global.Get<int>("num1");
访问一个全局table
方法1. 映射到普通class和sturct
1 -- table 2 gameLanguage={str1 = "C#语言", str2 = "lua语言", str3 = "C++语言"}
public class GameLanguage { public string str1; public string str2; public string str3; } private void CallLuaTableByClass() { GameLanguage gameLanguage = luaEnv.Global.Get<GameLanguage>("gameLanguage"); Debug.Log("[使用类映射]str1: " + gameLanguage.str1); Debug.Log("[使用类映射]str2: " + gameLanguage.str2); Debug.Log("[使用类映射]str3: " + gameLanguage.str3); gameLanguage.str1 = "我是修改后的内容"; luaEnv.DoString("print('修改后str1的值='..gameLanguage.str1)"); }
注释：
这个过程是值拷贝，如果class比较复杂代价会比较大（较消耗性能）。而且修改class字段值不会同步到table，反过来也不会。这种方式可以通过把类型添加到GCPotimize生成减低开销
方法2. 使用interface来进行映射【推荐】
gameUser = { name = "XC", age = 40, ID = "156156156", Speak = function() print("lua玩家在讨论中"); end, Walking = function() print("lua玩家在走路中"); end, Calulation = function(this, num1, num2) --说明：this这里命名可以任意，表示当前对象（即：gameUser） return this.age + num1 + num2; end, }
[CSharpCallLua] public interface IGameUser { string name { get; set; } int age { get; set; } string ID { get; set; } void Speak(); void Walking(); int Calulation(int num1, int num2); } private void CallLuaComplateTableByInterface() { IGameUser gameUser = luaEnv.Global.Get<IGameUser>("gameUser"); Debug.Log("[使用接口映射]name: " + gameUser.name); Debug.Log("[使用接口映射]age: " + gameUser.age); Debug.Log("[使用接口映射]ID: " + gameUser.ID); gameUser.Speak(); gameUser.Walking(); var result = gameUser.Calulation(2, 4); Debug.Log("经过lua计算，结果=" + result); gameUser.name = "XCC"; luaEnv.DoString("print('修改后name的值='..gameUser.name)"); }
注释：
这种方式依赖于生成代码（接口需要添加标签【CSharpCallLua】如果没生成代码会抛InvalidCastException异常）get对应table字段，set可以访问修改lua函数。这种方式为引用拷贝，适合用于复杂表
方法3. 使用Dictionary<key, value> 和 List<>映射简单表
gameLanguage = {str1 = "C#语言", str2 = "lua语言", str3 = "C++语言"}
gameLanguageList = {"C#语言", "lua语言", "C++语言"}
private void CallLuaTableByDictionary() { var dicGameLanguage = luaEnv.Global.Get<Dictionary<string, object>>("gameLanguage"); // 映射一个简单表 foreach (string key in dicGameLanguage.Keys) { Debug.Log("输出Dictionary中的所有语言" + dicGameLanguage[key]); } } private void CallLuaTableByList() { var list = luaEnv.Global.Get<List<object>>("gameLanguageList"); for (int i = 0; i < list.Count; i++) { Debug.Log("输出List中的所有语言" + list[i]); } }
注释：这种方式只能映射简单的表。优点是编写简单，效率高。
方法4. 使用LuaTable映射
private void CallLuaTableByLuaTable() { var gameUser = luaEnv.Global.Get<LuaTable>("gameUser"); Debug.Log("name = " + gameUser.Get<string>("name")); Debug.Log("age = " + gameUser.Get<int>("age")); Debug.Log("ID = " + gameUser.Get<string>("ID")); var speak = gameUser.Get<LuaFunction>("Speak"); speak.Call(); var walking = gameUser.Get<LuaFunction>("Walking"); walking.Call(); var calulation = gameUser.Get<LuaFunction>("Calulation"); var objArray = calulation.Call(gameUser, 2, 5); Debug.Log("输出结果 = " + objArray[0]); }
注释：
这种方式好处是不需要生成代码，但问题是比较慢（即：效率低）比interface方式慢一个数量级，比如没有类型检查
因为效率低，不推荐常用，适合用在一些很复杂但是使用频率很低的情况下，能不用就不用。
访问一个全局的function
方法1. 使用delegage访问
-- 定义单独的lua函数 function ProcMyFunc1() print("procMyFunc1 无参函数"); end function ProcMyFunc2(num1, num2) print("procMyFunc2 两个函数 num1+num2="..num1+num2); end function ProcMyFunc3(num1, num2) print("procMyFunc3 具备返回值的函数"); return num1+num2; end function ProcMyFunc4(num1, num2, num3) print("procMyFunc4 三个函数 num1+num2+num3="..num1+num2+num3); end function ProcMyFunc5(num1, num2) local result = num1+num2; print("procMyFunc4 具备多个返回值的函数"); return num1,num2,result; end
// 自定义委托 public delegate void delegateAdding(int num1, int num2); private void CallLuaFunctionByDelegage() { // 使用action直接获取没有参数的函数 var action1 = luaEnv.Global.Get<Action>("ProcMyFunc1"); action1(); // 使用自定义委托调用具备两个输入参数的函数 var action2 = luaEnv.Global.Get<delegateAdding>("ProcMyFunc2"); action2(10, 20); }
多返回值处理方法
定义全局的delegate
[CSharpCallLua]
public delegate void delegateAddingMultiReturn(int num1, int num2, out int res1, out int res2, out int res3);
[CSharpCallLua]
public delegate void delegateAddingMultiReturnRef(ref int num1, ref int num2, out int res3);
// 使用delegate访问多返回值得luafunction private void CallLuaFunctionByDelegateMultiReturn() { // 得到lua中的具有多个返回值的函数（通过委托out关键字来进行映射） act1 = luaEnv.Global.Get<delegateAddingMultiReturn>("ProcMyFunc5"); // 得到lua中的具有多个返回值的函数（通过委托ref关键字来进行映射） act2 = luaEnv.Global.Get<delegateAddingMultiReturnRef>("ProcMyFunc5"); // 输出返回结果 int intOutRes1 = 0; int intOutRes2 = 0; int intOutRes3 = 0; act1(100, 200, out intOutRes1, out intOutRes2, out intOutRes3); Debug.Log(string.Format("res1={0}, res2={1}, res3={2}", intOutRes1, intOutRes2, intOutRes3)); int intResult = 0; int intRef1 = 10; int intRef2 = 20; act2(ref intRef1, ref intRef2, out intResult); Debug.Log(string.Format("输入1={0}, 输入2={1}, 输出={2}", intRef1, intRef2, intResult)); }
注释：
优点：官方推荐方式，性能好，类型安全
缺点：（含有out与ref关键字delegate）要生成代码（如果没有生成会抛InvalidCastException异常）
注意：
1. 含有out与ref关键字委托也需要添加标签[CSharpCallLua]
2. 委托引用后，退出luaEnv前，需要释放委托引用，否则会报错
3. 对于Unity与C#中复杂类型API，必须加入xLua的配置文件，经过生成代码后才能正确使用。例如：Action<int, int, int> 、Func<int, int, int>等
方法2. 使用LuaFunction实现
private void CallLuaFunctionByLuaFunction() { var luaFunc1 = luaEnv.Global.Get<LuaFunction>("ProcMyFunc1"); var luaFunc2 = luaEnv.Global.Get<LuaFunction>("ProcMyFunc2"); var luaFunc3 = luaEnv.Global.Get<LuaFunction>("ProcMyFunc3"); // 调用具有多返回数值 var luaFunc5 = luaEnv.Global.Get<LuaFunction>("ProcMyFunc5"); luaFunc1.Call(); luaFunc2.Call(10, 20); var result = luaFunc3.Call(10, 20); Debug.Log("调用ProcMyFunc3, 结果为：" + result[0]); var result5 = luaFunc5.Call(10, 20); Debug.Log(string.Format("测试多返回数值 res1={0}, res2={1}, res3={2}", result5[0], result5[1], result5[2])); }
注释：
优点：无需生成代码
缺点：性能不高，不推荐
这种方式使用起来很简单，LuaFcuntion上有个变参的Call函数，可以传任意类型，任意个数的参数，返回值是object的数组，对应于lua的多返回值
官方使用建议：
1. 访问lua全局数据，特别是table以及function，代价比较大，建议尽量少做，比如在初始化时把要调用的lua functio获取一次（映射到delegate）后，保存下来，后续直接调用该delegate即可。table也类似。
2. 如果lua实现的部分都以delegate和interface的方式提供，使用方可以完全和xLua解耦，由一个专门的模块负责xLua的初始化以及delegate、interface的映射，然后把这些delegate和interface设置到要用到他们的地方
