初识xLua(一)

通过xLua运行Lua程序

导入网上下载的 xLua 包，其中也包涵示例代码和场景。

using XLua;

    private LuaEnv luaenv;

    void Start () {
        
        //构建Lua虚拟机
        luaenv = new LuaEnv();
        
        //通过 Lua 语法(执行一个字符串)输出 Hello world
        //luaenv.DoString("print('Hello world!')"); 
        
        //通过 Lua 调用 C# 语法输出 Hello world
        luaenv.DoString(" CS.UnityEngine.Debug.Log('Hello world') ");

	}

    private void OnDestroy()
    {
        
        luaenv.Dispose();
    }
}

加载运行lua源文件

这里要注意一点该文件的全名(包括后缀)为：helloworld.lua.txt

        TextAsset ta = Resources.Load<TextAsset>("helloworld.lua"); 

        LuaEnv env = new LuaEnv();
        
        env.DoString(ta.text);

        env.Dispose();

通过内置的 Loader 方法加载，比如，DoString(" require ‘byfile’ ")

        LuaEnv env = new LuaEnv();

        env.DoString("require 'helloworld'");
        
        env.Dispose();

添加自定义的Loader方法

涉及到一个接口：

public delegate byte[] CustomLoader(ref string filepath);
public void LuaEnv.AddLoader(CustomLoader loader)

示例：

void Start () {
         LuaEnv env = new LuaEnv();

        env.AddLoader(MyLoader);

        env.DoString("require 'test'");

        env.Dispose();
	}
	
    private byte[] MyLoader(ref string filePath)
    {
        string absPath = Application.streamingAssetsPath + "/" + filePath + ".lua.txt";
        return System.Text.Encoding.UTF8.GetBytes(File.ReadAllText(absPath));
    }

C#访问Lua

全局变量

要注意，获取的变量类型一定要对

        LuaEnv luaEnv = new LuaEnv();
        luaEnv.DoString("require 'CSharpCallLua'");
        
        int a = luaEnv.Global.Get<int>("a");//获取到lua里面的全局变量 a
        print(a);
        string str = luaEnv.Global.Get<string>("str");//获取到lua里面的全局变量 str
        print(str);
        bool isDie = luaEnv.Global.Get<bool>("isDie");//获取到lua里面的全局变量 isDie
        print(isDie);

        luaEnv.Dispose();

Table

table 的名字为 person

person = { name="MoGu",age=100 }

把访问到的 table 映射到 class

class Person
    {
        public string name;
        public int age;
    }

        LuaEnv luaEnv = new LuaEnv();
        luaEnv.DoString("require 'CSharpCallLua'");
        
        Person p = luaEnv.Global.Get<Person>("person");
        print(p.name+"-"+ p.age);

        luaEnv.Dispose();

用这种方式访问到 table 后，对类中的值修改，是不会影响原来的 table 的。

把访问到的 table 映射到 interface

person = {
	name="MoGu",age=100 ,
	
	eat=function(self,a,b)
		print(a+b)
	end
}

需要给接口添加一个特性 [CSharpCallLua]

可以通过 interface 的方法访问 Lua 的函数

   [CSharpCallLua]
   interface IPerson
    {
        string name { get; set; }
        int age { get; set; }
        void eat(int a,int b);
    }

        LuaEnv luaEnv = new LuaEnv();
        luaEnv.DoString("require 'CSharpCallLua'");
        
        IPerson p = luaEnv.Global.Get<IPerson>("person");
        print(p.name+"-"+p.age);
        p.eat(12,34);

        luaEnv.Dispose();

用这种方式访问到 table 后，对值修改，是会影响原来的 table 的。

把访问到的 table 映射到 Dictionary<>，List<>

给原来的 table 添加几个数据

person = {
	name="MoGu",age=100 ,12,2,2,2,2,true,3.3,
	
	eat=function(self,a,b)
		print(a+b)
	end
}

        LuaEnv luaEnv = new LuaEnv();
        luaEnv.DoString("require 'CSharpCallLua'");
        
        Dictionary<string, object> dict = luaEnv.Global.Get<Dictionary<string, object>>("person");
        foreach(string key in dict.Keys)
        {
           print(key + "-" + dict[key]);
        }
        
        List<int> list = luaEnv.Global.Get<List<int>>("person");
        foreach (object o in list)
        {
           print(o);
        }

        luaEnv.Dispose();

把访问到的 table 映射到 LuaTable 类

优点是不需要生成代码，缺点是慢

        LuaEnv luaEnv = new LuaEnv();
        luaEnv.DoString("require 'CSharpCallLua'");
        
        LuaTable tab= luaEnv.Global.Get<LuaTable>("person");
        print(tab.Get<string>("name"));
        print(tab.Get<int>("age"));
        print(tab.Length);
        
        luaEnv.Dispose();

全局function

先定义一个全局 function

function add(a,b)
	print(a+b)
	return a+b,a,b
end

方式一，映射到delegate
优点，性能好，类型安全；缺点，要生成代码

    [CSharpCallLua]
    delegate int Add(int a, int b,out int resa,out int resb); 

        LuaEnv luaEnv = new LuaEnv();
        luaEnv.DoString("require 'CSharpCallLua'");
        
        Add add = luaEnv.Global.Get<Add>("add");
        int resa = 0; int res b= 0;
        int res = add(34, 78,out resa,out resb);
        print(res);
        print(resa);
        print(resb);
        
        add = null;        
        luaEnv.Dispose();

方式二，映射到 LuaFunction
优缺点和第一种相反

        LuaEnv luaEnv = new LuaEnv();
        luaEnv.DoString("require 'CSharpCallLua'");
        
        LuaFunction func = luaEnv.Global.Get<LuaFunction>("add");
        object[] os= func.Call(1, 2);
        foreach(object o in os)
        {
            print(o);
        }
        
        luaEnv.Dispose();

Lua调用C#常用方式

创建C#对象

在 lua 脚本中

--构造游戏物体，new对象
CS.UnityEngine.GameObject("new by lua")

在 Unity 中调用

        LuaEnv luaEnv = new LuaEnv();
   
        luaEnv.DoString("require 'LuaCallCSharp'");

        luaEnv.Dispose();

访问静态属性和方法

local gameObject = CS.UnityEngine.GameObject

local camera = gameObject.Find("Main Camera")

camera.name = "update by lua"

访问成员属性和方法

注意:
lua 中使用冒号，表示成员方法的调用。它自动完成把当前对象作为一个参数，传入方法。
lua 中使用点，则表示静态属性与方法调用。它需要手工往方法中传递当前对象。

local cameraCom= camera.GetComponent(camera,"Camera")

gameObject.Destroy(cameraCom)

访问父类(子类)属性和方法

定义一个C#父类

namespace XluaPro
{
	public class IsInvoked_Father
	{
        public string FatherClassName = "父类字段";

        public IsInvoked_Father()
        {
            Debug.Log("IsInvoked_Father 父类构造函数");
        }

        public void ShowFatherInfo()
        {
            Debug.Log("IsInvoked_Father.cs 父类的方法 ShowFatherInfo（）");
        }
    }
}

再写一个子类

namespace XluaPro
{
	public class IsInvokedClass:IsInvoked_Father
	{
        public string ChildClassName= "子类字段";

       public IsInvokedClass()
        {
            Debug.Log("IsInvokedClass 子类构造函数");
        }

        public void Mehtod1()
        {
            Debug.Log("IsInvokedClass.cs/Mehtod1 方法");
        }
    }
}

在 lua 文件中调用

local IsInvoked = CS.XluaPro.IsInvokedClass
local classObj = IsInvoked()   --自动调用父类与子类的构造函数

--调用普通方法
classObj:Mehtod1()					--ok
--classObj.Mehtod1()			        --语法报错！
classObj.Mehtod1(classObj)		    --语法OK

--调用父类的字段与方法
classObj:ShowFatherInfo();              --调用父类的方法
print(classObj.FatherClassName)         --调用父类的公共字段
print(classObj.ChildClassName)          --调用子类的公共字段

Lua调用C#的方法重载现象

/*  定义方法重载  */

        public void Method2(int num1, int num2)
        {
            Debug.Log(GetType() + "/Method2()/ 重载方法/int浮点型/num1=" + num1 + " num2=" + num2);
        }

        public void Method2(float num1,float num2)
        {
            Debug.Log(GetType()+ "/Method2()/ 重载方法/float浮点型/num1="+ num1+" num2="+num2);
        }

        public void Method2(string str1, string str2)
        {
            Debug.Log(GetType() + "/Method2()/ 重载方法/字符串类型/str1=" + str1 + " str2=" + str2);
        }

lua 中去调用

--测试调用C#方法重载
classObj:Method2(10,20)
classObj:Method2("abc","def")

这里发现 xlua 是支持方法重载的，但为“有限重载”。可以直接通过不同的参数类型进行重载函数的访问，例如：
testobj：TestFunc(100)
testobj：TestFunc(‘hello’)
将分别访问整数参数的 TestFunc 和字符串参数的 TestFunc。

但是，xlua 只一定程度上支持重载函数的调用，因为 lua 的类型远远不如C#丰富，存在一对多的情况，比如C#的int，float，double都对应于 lua 的 number，上面的例子中 TestFunc 如果有这些重载参数，第一行将无法区分开来，只能调用到其中一个（生成代码中排在前面的那个）

Lua调用C#中带参方法

C#中可变参数方法，Parmms关键字

//定义带有返回数值，有参数的方法,且有params 关键字
        public int Method3(int num1, int num2, params string[] strArray)
        {
            Debug.Log(GetType() + "/Method3()/ 带有params关键字的方法/");
            foreach (string item in strArray)
            {
                Debug.Log("输入的字符串内容："+item);
            }
            return num1 + num2;
        }

在 lua 中

--测试C#中带有params 关键字的方法
local intResult=classObj:Method3(20,70,"Hello ","World","EveryOne")
print("调用parmas关键字的方法，返回数值= "..intResult)

C#结构体参数

lua 使用一个表，来映射C#的结构体

//定义结构体(建议结构体成员为小写)
    public struct MyStruct
    {
        public string x;
        public string y;
    }

//带有结构体参数的方法
        public void Method4(MyStruct p)
        {
            Debug.Log("测试lua调用结构体方法");
            Debug.Log("p.x="+ p.x);
            Debug.Log("p.y="+ p.y);
        }

在 lua 中

--测试lua调用C#中带有结构体参数的方法
--定义一个表
myStructTable={x="C#语言",y="lua语言"}
classObj:Method4(myStructTable)

C#接口参数

注意：接口需要加入标记: [CSharpCallLua]
lua 使用一个表，来映射C#的接口

//定义接口
    [XLua.CSharpCallLua]
    public interface MyInterface
    {
        int x { get; set; }
        int y { get; set; }
        void Speak();
    }


        //方法具有接口为参数的
        public void Method5(MyInterface p)
        {
            Debug.Log("测试lua调用具有接口为参数的方法");
            Debug.Log("p.x=" + p.x);
            Debug.Log("p.y=" + p.y);
            p.Speak();
        }

在 lua 中

--测试lua调用C#中带有接口参数的方法
--定义一个表
myInterfaceTable=
{
	x=1000,
	y=300,

	Speak=function()
		print("lua中 Speak 方法被调用!")
	end
}
classObj:Method5(myInterfaceTable)

C#委托参数

委托需要加入标记: [CSharpCallLua]
lua 使用一个函数，来映射C#的委托

//定义委托
    [XLua.CSharpCallLua]
    public delegate void MyDelegate(int num);

        //方法具有委托为参数
        public void Method6(MyDelegate p)
        {
            Debug.Log(GetType()+"/Method6()/委托参数:");
            //调用
            p.Invoke(88);
        }

在 lua 中

--定义lua调用C#中带有委托参数的方法
--定义函数
myDelegate=function(num)
	print("lua 中对应委托方法。参数num="..num)
end

classObj:Method6(myDelegate)

Lua接收C#方法返回的多个结果数值

基本规则: 参数的输入输出属性（out，ref）

A: C#的普通参数算一个输入形参，ref修饰的算一个输入形参，out不算，然后从左往右对应lua 调用的实参列表。
B: Lua调用返回值处理规则：C#函数的返回值（如果有的话）算一个返回值，out算一个返回值，ref算一个返回值，然后从左往右对应lua的多返回值。

        //定义一个具有多返回数值的方法
        public int Method7(int num1,out int num2,ref int num3)
        {
            Debug.Log(GetType()+"/Method7()/测试lua接收C#的多返回数值");
            num2 = 3000;
            num3 = 999;
            return num1 + 100;
        }

在 lua 中

--接收C#多返回数值
local num1=10
local num2=20
local res1,res2,res3=classObj:Method7(num1,num2)
print("res1="..res1)  --输出结果： 110
print("res2="..res2)  --输出结果： 3000
print("res3="..res3)  --输出结果： 999

Lua如何调用C#泛型方法

基本规则：lua 不直接支持 C# 的泛型方法，但可以通过扩展方法功能进行封装后调用。

使用 Extension methods (扩展方法)技术就是 C# 中在不改变原始类的基础上，使用一种机制可以无限扩展这个类功能的机制。

原始类为： A
扩展类为： Ext_A

注意： Ext_A 必须是一个静态类，且扩展方法也必须是静态的。方法的参数中必须要有被扩展类作为其中一个参数，此参数前面必须有this 关键字修饰。

        //定义一个具有泛型方法为参数的。
        public void Method8(List<string> strArray)
        {
            Debug.Log(GetType() + "/Method8()/这是一个具有泛型方法为参数的方法");
            foreach (string item in strArray)
            {
                Debug.Log("泛型集合中的内容="+item);
            }
        }

在 lua 中

--lua中可以直接调用具有泛型为参数的方法
myTable8={"lua语言","C#语言","C++语言"}
classObj:Method8(myTable8);

另外一种就是

自定义泛型类

namespace XluaPro
{
    [XLua.LuaCallCSharp]
	public class MyGengerric
	{
        public T GetMax<T>(T num1, T num2) where T : IComparable
        {
            if (num1.CompareTo(num2)<0)
            {
                return num2;
            }
            else {
                return num1;
            }
        }		
	}
}

//C#方法中，调用我们自定义的泛型方法
        public void Method_InvokeGenger()
        {
            //int maxNum = 0;
            //int num1 = 100;
            //int num2 = 200;

            //MyGengerric obj = new MyGengerric();
            //maxNum = obj.GetMax<int>(num1, num2);
            //Debug.Log("C#中比较两个数字大小： "+maxNum);

            //测试字符串的比较
            string maxStr = string.Empty;
            string str1 = "xd";
            string str2 = "kb";

            MyGengerric obj = new MyGengerric();
            maxStr = obj.GetMax<string>(str1, str2);
            Debug.Log("C#中比较两个字符串大小： " + maxStr);


        }

在 lua 中，只能让上述方法跑起来

--让C#方法运行起来。
classObj:Method_InvokeGenger()

如果要这样，去调用那个自定义泛型方法，会有错误

--lua中直接调用C#中定义的泛型方法
local maxNum=CS.XluaPro.MyGengerric:GetMax<int>(20,30)  --报语法错误
print("maxNum="..maxNum)

那么怎么办，就有了扩展方法

这个类是一个“扩展方法”，本类的功能是扩展原有“MyGengerric”类的功能。
注意：
扩展方法有两大注意事项：
A: 扩展方法类，必须是静态类。
B: 定义的扩展方法的参数，第一个参数必须是this ，然后跟需要扩展的类名称全称。

namespace XluaPro
{
    [XLua.LuaCallCSharp]
    public static class Extension_MyGengerric
	{
        /// <summary>
        /// 定义扩展方法
        /// </summary>
        /// <param name="gen"></param>
        /// <param name="num1"></param>
        /// <param name="num2"></param>
        /// <returns></returns>
        public static int ExtGetMax(this XluaPro.MyGengerric gen, int num1, int num2)
        {
            if (num1<num2)
            {
                return num2;
            }
            else {
                return num1;
            }
        }	
	}
}

在 C# 中调用这个扩展方法

        //在C#中学习调用C#的扩展方法
        public void Test8_InvokeExtensionMethod()
        {
            int maxNum = 0;
            int num1 = 800;
            int num2 = 200;

            MyGengerric obj = new MyGengerric();
            maxNum=obj.ExtGetMax(num1, num2);
            Debug.Log("[应用扩展方法] C#中得到最大数值="+maxNum);
        }

那如果是在 lua 中调用这个扩展方法

--在lua中通过调用"扩展方法"，来间接完成对C#“泛型方法”功能的实现。
local maxNum=CS.XluaPro.MyGengerric():ExtGetMax(888,66)
print("[在lua中扩展方法调用] maxNum="..maxNum)

其他知识点

参数带默认值的方法
与C#调用有默认值参数的函数一样，如果所给的实参少于形参，则会用默认值补上。

枚举类型
枚举值就像枚举类型下的静态属性一样。

testobj:EnumTestFunc(CS.Tutorial.TestEnum.E1)

上面的 EnumTestFunc 函数参数是 Tutorial.TestEnum 类型的。

委托与事件
delegate 属性可以用一个 luaFunction 来赋值
比如 testobj 里头有个事件定义是这样：public event Action TestEvent;

增加事件回调
testobj:TestEvent(’+’, lua_event_callback)

移除事件回调
testobj:TestEvent(’-’, lua_event_callback)

Lua调用C#经验小结

1。lua 调用C#，需要在 Xlua 中生成“适配代码”，并在这个类打入一个 [LuaCallCSharp] 的标签。

2。如果lua调用C#的系统API ，则无法拿到源代码，无法打入标签。则使用“静态列表”方式解决。

public static List<Type> mymodule_LuaCallCS_List = new List<Type>()
  {
          typeof(GameObject),
          typeof(Dictionary<string,int>),
  };

然后把以上代码放入一个静态类中即可。

3。实际开发过程中，lua 调用 C# 用的比较多。xlua 的优点体现在没有必要每次修改的时候，都要生成代码。主要原理是依赖于编译器环境下，利用反射来动态生成代码接口。

4。在标有 “[XLua.LuaCallCSharp]” 的 C# 类中，添加新的方法后，如果是生成了代码类，则必须重新生成或者删除，否则 Xlua 还是用以前生成的代码进行注册查询，会出现 lua 异常：“试图访问一个nil 的方法”。

目录

通过xLua运行Lua程序

加载运行lua源文件

添加自定义的Loader方法

C#访问Lua

全局变量

Table

全局function

Lua调用C#常用方式

创建C#对象

访问静态属性和方法

访问成员属性和方法

访问父类(子类)属性和方法

Lua调用C#的方法重载现象

Lua调用C#中带参方法

C#中可变参数方法，Parmms关键字

C#结构体参数

C#接口参数

C#委托参数

Lua接收C#方法返回的多个结果数值

Lua如何调用C#泛型方法

其他知识点

Lua调用C#经验小结

猜你喜欢