Xlua分析：Lua调用C#
在之前的博客Lua与C#交互初析-CSDN博客中讲了有关lua和c#交互的比较浅层的概念，即C#侧注册[LuaCallCSharp]和[CSharpCallLua]的标签后，即可实现双侧沟通。但是还是没有讲明白里面的一些具体内容包括参数传递、xlua栈调用，甚至是C#如何调用lua都没研究。本篇主题是lua如何调用C#的补充。
xLua交互知识
参考官方文档《programming in lua》的第24章开头，里面很详细地阐述了Lua和C++是如何实现交互的：栈操作。Lua API用一个抽象的栈在Lua与C之间交换值。栈中的每一条记录都可以保存任何 Lua 值。如果想要从Lua请求一个值（比如一个全局变量的值）则调用Lua，被请求的值将会被压入栈；如果想要传递一个值给 Lua，首先将这个值压入栈，然后调用 Lua（这个值就会被弹 出）。几乎所有的 API函数都用到了栈。而C#显而易见也可以和C++一侧进行交互，由此即可得出lua和C#可以通过C/C++这一层来进行通信，主要方法即是lua的堆栈操作。
C#对象如何传递给Lua
如果是int、float、bool这种C和C#互通的数据类型，实际上就直接走以上说的Lua API形式即可，直接栈操作就能实现数据交互，但是C#这边的对象则很难进行这样的操作，所以需要更多的步骤。参考Xlua ObjectTranslator.cs的Push操作：
public void Push(RealStatePtr L, object o)
{
int index = -1;
Type type = o.GetType();
#if !UNITY_WSA || UNITY_EDITOR
bool is_enum = type.IsEnum;
bool is_valuetype = type.IsValueType;
#else
bool is_enum = type.GetTypeInfo().IsEnum;
bool is_valuetype = type.GetTypeInfo().IsValueType;
#endif
bool needcache = !is_valuetype || is_enum;
if (needcache && (is_enum ? enumMap.TryGetValue(o, out index) : reverseMap.TryGetValue(o, out index)))
{
if (LuaAPI.xlua_tryget_cachedud(L, index, cacheRef) == 1)
{
return;
}
//这里实在太经典了，weaktable先删除，然后GC会延迟调用，当index会循环利用的时候，不注释这行将会导致重复释放
//collectObject(index);
}
bool is_first;
int type_id = getTypeId(L, type, out is_first);
//如果一个type的定义含本身静态readonly实例时，getTypeId会push一个实例，这时候应该用这个实例
if (is_first && needcache && (is_enum ? enumMap.TryGetValue(o, out index) : reverseMap.TryGetValue(o, out index)))
{
if (LuaAPI.xlua_tryget_cachedud(L, index, cacheRef) == 1)
{
return;
}
}
index = addObject(o, is_valuetype, is_enum);
LuaAPI.xlua_pushcsobj(L, index, type_id, needcache, cacheRef);
}首先push一个object的时候会判断这个object是否有相关缓存，有的话就不用继续了，没有的话就还是需要addObject的操作的。
int addObject(object obj, bool is_valuetype, bool is_enum)
{
int index = objects.Add(obj);
if (is_enum)
{
enumMap[obj] = index;
}
else if (!is_valuetype)
{
reverseMap[obj] = index;
}
return index;
}首先会把object存进一个object list里，获得一个index，然后根据类型存进相应的map中，如果是引用（注意代码!is_valuetype指的就是非值类型，即引用类型）则存入引用map，如果是枚举则存入枚举map。
最后调用LuaAPI.xlua_pushcsobj(L, index, type_id, needcache, cacheRef)这个操作来进行压栈并且创建一个userdata并设置metatable来供lua侧调用。如果需要缓存，则存入缓存表中。从上方的C#代码中可以很明显的看到如果是引用或者枚举则都需要缓存。
LUA_API void xlua_pushcsobj(lua_State *L, int key, int meta_ref, int need_cache, int cache_ref) {
int* pointer = (int*)lua_newuserdata(L, sizeof(int));
*pointer = key;
if (need_cache) cacheud(L, key, cache_ref); // Lua侧缓存
lua_rawgeti(L, LUA_REGISTRYINDEX, meta_ref);
lua_setmetatable(L, -2); // 为userdata设置元表
}
// 将 key = userdata 存入缓存表
static void cacheud(lua_State *L, int key, int cache_ref) {
lua_rawgeti(L, LUA_REGISTRYINDEX, cache_ref);
lua_pushvalue(L, -2);
lua_rawseti(L, -2, key);
lua_pop(L, 1);
}C#对象具体信息
如果仅仅是以上描述的这个流程，那么创建一个userdata时元表的信息还远远不够，我们依然无法直到为什么lua侧可以调用go:SetActive(false)。
在Push函数内有一行需要注意：int type_id = getTypeId(L, type, out is_first);在内部就执行了Xlua Wrap相关操作：
internal int getTypeId(RealStatePtr L, Type type, out bool is_first, LOGLEVEL log_level = LOGLEVEL.WARN)
{
......
LuaAPI.luaL_getmetatable(L, alias_type == null ? type.FullName : alias_type.FullName);
if (LuaAPI.lua_isnil(L, -1)) //no meta yet, try to use reflection meta
{
LuaAPI.lua_pop(L, 1);
if (TryDelayWrapLoader(L, alias_type == null ? type : alias_type))
{
LuaAPI.luaL_getmetatable(L, alias_type == null ? type.FullName : alias_type.FullName);
}
else
{
throw new Exception("Fatal: can not load metatable of type:" + type);
}
}
......
}此处代码即是首先用type中寻找类对应的元表，如果没有则采用TryDelayWrapLoader生成。参考上一篇将xlua wrap生成的文章：Xlua Wrap-CSDN博客
总的来说，xlua会为C#类这边生成一个wrap文件，里面对于方法生成了对应的函数，对于属性值则会生成getter和setter方法来供xlua“调用”。
比如：
[LuaCallCSharp]
public class TestXLua
{
public string Name;
public void Test1(int a){
}
public static void Test2(int a, bool b, string c)
{
}
}生成wrap之后的代码：
public class TestXLuaWrap
{
public static void __Register(RealStatePtr L)
{
ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
System.Type type = typeof(TestXLua);
Utils.BeginObjectRegister(type, L, translator, 0, 1, 1, 1);
Utils.RegisterFunc(L, Utils.METHOD_IDX, "Test1", _m_Test1);
Utils.RegisterFunc(L, Utils.GETTER_IDX, "Name", _g_get_Name);
Utils.RegisterFunc(L, Utils.SETTER_IDX, "Name", _s_set_Name);
Utils.EndObjectRegister(type, L, translator, null, null,
null, null, null);
Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0);
Utils.RegisterFunc(L, Utils.CLS_IDX, "Test2", _m_Test2_xlua_st_);
Utils.EndClassRegister(type, L, translator);
}
[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
static int __CreateInstance(RealStatePtr L)
{
try {
ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
if(LuaAPI.lua_gettop(L) == 1)
{
TestXLua gen_ret = new TestXLua();
translator.Push(L, gen_ret);
return 1;
}
}
catch(System.Exception gen_e) {
return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
}
return LuaAPI.luaL_error(L, "invalid arguments to TestXLua constructor!");
}
[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
static int _m_Test1(RealStatePtr L)
{
try {
ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
TestXLua gen_to_be_invoked = (TestXLua)translator.FastGetCSObj(L, 1);
{
int _a = LuaAPI.xlua_tointeger(L, 2);
gen_to_be_invoked.Test1( _a );
return 0;
}
} catch(System.Exception gen_e) {
return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
}
}
[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
static int _m_Test2_xlua_st_(RealStatePtr L)
{
try {
{
int _a = LuaAPI.xlua_tointeger(L, 1);
bool _b = LuaAPI.lua_toboolean(L, 2);
string _c = LuaAPI.lua_tostring(L, 3);
TestXLua.Test2( _a, _b, _c );
return 0;
}
} catch(System.Exception gen_e) {
return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
}
}
[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
static int _g_get_Name(RealStatePtr L)
{
try {
ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
TestXLua gen_to_be_invoked = (TestXLua)translator.FastGetCSObj(L, 1);
LuaAPI.lua_pushstring(L, gen_to_be_invoked.Name);
} catch(System.Exception gen_e) {
return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
}
return 1;
}
[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
static int _s_set_Name(RealStatePtr L)
{
try {
ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
TestXLua gen_to_be_invoked = (TestXLua)translator.FastGetCSObj(L, 1);
gen_to_be_invoked.Name = LuaAPI.lua_tostring(L, 2);
} catch(System.Exception gen_e) {
return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
}
return 0;
}
}里面都直接是对lua栈进行操作。
Xlua cache表
xlua和C#相互都有独立的GC系统，但是中间建立了一层cache表用来存储所有的userdata。这层cache表是采用弱引用的方式实现的。在lua不需要用到相关userdata 的时候，这层cache表会自动清除这个userdata；在最初创建userdata的时候，还会为userdata 的元表添加__gc方法，用以在被gc的时候直接自动调用函数来清理C#这边的管理池：
if ((type == null || !translator.HasCustomOp(type)) && type != typeof(decimal))
{
LuaAPI.xlua_pushasciistring(L, "__gc");
LuaAPI.lua_pushstdcallcfunction(L, translator.metaFunctions.GcMeta);
LuaAPI.lua_rawset(L, -3); // 为元表设置__gc方法
}[MonoPInvokeCallback(typeof(LuaCSFunction))]
public static int LuaGC(RealStatePtr L)
{
try
{
int udata = LuaAPI.xlua_tocsobj_safe(L, 1);
if (udata != -1)
{
ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
if ( translator != null )
{
translator.collectObject(udata);
}
}
return 0;
}
catch (Exception e)
{
return LuaAPI.luaL_error(L, "c# exception in LuaGC:" + e);
}
}而这个translator.collectObject实际上就是在清理之前创建时候添加进list和map的object数据了：
internal void collectObject(int obj_index_to_collect)
{
object o;
if (objects.TryGetValue(obj_index_to_collect, out o))
{
objects.Remove(obj_index_to_collect);
if (o != null)
{
int obj_index;
//lua gc是先把weak table移除后再调用__gc，这期间同一个对象可能再次push到lua，关联到新的index
bool is_enum = o.GetType().IsEnum();
if ((is_enum ? enumMap.TryGetValue(o, out obj_index) : reverseMap.TryGetValue(o, out obj_index))
&& obj_index == obj_index_to_collect)
{
if (is_enum)
{
enumMap.Remove(o);
}
else
{
reverseMap.Remove(o);
}
}
}
}
}