XLua中lua读写cs对象的原理

LuaCallCS

1. 传递C#对象到Lua

XLua在C#维护了两个数据结构，ObjectPool和ReverseMap。

首次传递一个C#对象obj到Lua时，对象被加入到ObjectPool中，并为它创建一个唯一标识objId，建立obj和objId的双向映射。

ObjectPool: objId->obj ReverseMap: obj->objId

如果该对象的类型是第一次传到Lua，还会为类型创建一个元表typeMetatable。

typeMetatable：包含类成员的访问方法。

把typeMetatable注册到Lua的全局表中,这样就不会被lua gc掉。

LUA_REGISTRY: typeFullName->typeMetatable

创建一个userdata对象放到C#和Lua交互的栈上，userdata的值设为objId，userdata的元表设为typeMetatable。这样userdata就可以通过value找到C#对应的对象，通过元表找到类成员的访问方法。

userdata: value = objId, metatable = typeMetatable

至此，完成了C#对象到Lua的传递，lua从栈上拿到这个userdata对象。

对于引用类型，还会把这个userdata记录到Lua的全局表cache_ref。

cache_ref:objId->userdata

下次再传递同一个对象时，通过obj在ReverseMap里找到objId，通过objId去cache_ref里找到userdata，放到lua栈上。

cache_ref表的value是弱引用，userdata没有其他引用后，gc时会把cache_ref里的键值对删除。

2. 对象释放

对象的释放有两种方式。

Lua gc

在userdata的元表里，设置了__gc方法

 typeMetatable{  __gc = LuaGC,  }

当一个userdata被gc时，触发LuaGC方法。从userdata上拿到objId, 从ObjectPool和ReverseMap中移除对应的C#对象。cache_ref里的userdata是弱引用，会被gc清理掉。

Destroy UnityEngine.Object

XLua可以定期检查ObjectPool里的UnityEngine.Object对象，如果已经被Destroy，则主动从ObjectPool和ReverseMap中删除，C#对象可以被GC。userdata对象等待lua gc再释放。

3. Lua访问C#成员

一个C#对象在Lua中有一个对应的userdata对象。比如一个GameObject对象go，访问它的transform成员。

  local transform = go.transform

go的元表是GameObject的typeMetatable，XLua为GameObject生成了一个*g*get_transform C#函数，并注册到typeMetatable中，

这部分比较复杂，可以简单的认为类的元表中生成了类成员的访问方法，通过成员变量的名字可以查询到对应的方法。

GameObject_metatable{
    __index = function(key)
        field = {
            transform = _g_get_transform,
            ...
        },
        ...
        if fields[key] ~= nil then            return fields[key]
        end        ...
    end,
    __newIndex同理。
}

访问字段transform会触发__index方法，查询到gget_transform，这是xlua生成的一段C#函数，该函数通过userdata拿到objId，从而在ObjectPool中拿到C#对象go，将go.transform传给lua。

4. Struct对象的传递

默认情况下，将一个Struct对象传递给Lua，首先会装箱成一个Object对象，记录到ObjectPool中，生成objId，再创建一个userdata给lua，userdata中记录着objId。跟引用类型不同，值类型的userdata不会存到cache_ref中。 所以lua每读取一个struct，都会创建一个C#对象和一个userdata。XLua提供了一个优化方案：GCOptimize。

5. GCOptimize

可以对指定的Struct类型加上GCOptimize标签，XLua会为其生成专门的Push,Get,Update代码。

以Vector3为例。

Push

local pos = transform.position

C#传递一个Vector3到Lua时，创建一个userdata并设置它的元表。

userdata申请的value申请12个字节(Vector3有3个float)，把Vector3对象的xyz的值依次复制到userdata的三个float上。userdata不再记录objId，而是直接存储struct的值。

通过GCOptimize的方式，省掉了C#的gc消耗，不过每次push一个vector3对象还会创建一个userdata。

Get

transform.positon = pos

XLua支持两种从lua传值对象到C#。

第一种是传userdata，即这个对象本来就是从C#传到lua的，lua再传回去。这时会直接把userdata里的值取出来，赋给C#的Vector3对象。没有gc，性能比较好。

第二种是构建一个字段相同的table传给C#，transform.positon = {x=0,y=0,z=0}。xlua会查询table里同名的字段，复制值给c#的成员变量。由于根据变量名字的字符串去查表，这个性能没有第一种好。

Update

pos.x = 1

lua修改一个GCOptimize的userdata。

先Get，上文讲了，会创建一个Vector3对象，复制userdata的值。然后在C#修改它的值x。

接下来Update操作，拿到栈顶的userdata，把Vector3对象的值复制到userdata。

6. 在Lua中读写transform position

修改transform的position是一个很常见的需求，看看下面这段lua代码正确吗：

transform.position.x = 1

这段代码可以执行，但并没有效果，transform的position不会被改变。

如果这段代码用c#写，会直接编译器报错。来看看Transform里的position源码：

public Vector3 position
{
    get    {
        Vector3 ret;
        this.get_position_Injected(out ret);
        return ret;
    }
    set => this.set_position_Injected(ref value);
}

position并不是一个变量，而是一个属性。所以在C#中，transform.position是一个返回值，C#不允许修改一个返回值，因为修改一个临时变量并没有意义。所以在C#中你得这么写：

var pos = transform.position;
pos.x = 1;
transform.position = pos;

再回头看看那句lua代码 transform.position.x = 1 ，它不过是把get出来的值修改了，要想把位置修改，只能通过position的set访问器。

local pos = transform.position;
pos.x = 1;
transform.position = pos;

看起来很繁琐？但这不是lua的问题，在c#里就这么繁琐。

再来分下这段代码的性能，对Vector3开启GCOptimize,

local pos = transform.position; --transform Get position: Push Vector3，有一个userdata gc
pos.x = 1; --Vector3 set x: 1.Get Vector3，复制userdata的值到Vector3，2.修改Vector3的x，3.Update Vector3,把Vector3的值复制回userdata
transform.position = pos; --transform Set position: Get Vector3,复制userdata的值给Vector3，这个性能不差。

接下来，介绍一种性能比较好的方式。

7. 不带来GC的值类型传递方式

可以看到，引入GCOptimize之后，除了Push操作有lua GC，Get和Update是没有GC的。

传递一个userdata到C#比传递table效率更高，因为传递table会通过字符串查表。

修改一个table的值比修改一个userdata的值效率更高(看起来，但没测过)，因为每修改userdata的一个成员，就会拷贝两次Vector3，而修改一个table只用一次查表。

常见的一个需求是，在lua维护一个位置信息，lua会更新这个位置数据，并设置到c#对象上。如果创建一个Vector3的userdata对象，传值给C#比较快，但更新它的值比较低效。如果创建一个table对象，更新它的值比较高效，但传给C#的时候会有3次查表。

综上所述，推荐最简单的方案，在C#封装一些Util函数，把对象的成员变量通过参数的方式进行传递，在lua维护x,y,z。

public static void GetPosition(Transform t, out float x, out float y, out float z) {
    Vector3 v = t.position;
    x = v.x;
    y = v.y;
    z = v.z;
}
public static void SetPosition(Transform t, float x, float y, float z) {
    t.position = new Vector3(x, y, z);
}

CSCallLua

1.传递Lua函数到c#

首先在lua全局表注册lua函数，避免被GC

LUA_REGISTRY: luaReference->luaFunction

创建DelegateBridgeBase对象，记住luaReference

bridge:
    luaReference

bridge对象里根据类型创建Delegate，一个lua函数可能在C#侧被用作不同类型的Delegate

bridge:
    luaReference
    <DelegateType,Delegate>

Delegate 的实例是生成的C#代码，通过luaReference访问lua函数，这里面有对bridge的引用，所以持有这个delegate对象就不会释放bridge对象。

最后返回Delegate给使用者持有。bridge是局部变量，没有被其他对象引用。

2. DelegateBridge gc过程

c#侧释放对delegate对象，delegate对象释放后，bridge的引用计数归零，被GC，在gc方法中，从lua全局注册表清理luaReference，对应的lua函数引用计数减一。

交互总结

无论是cs call lua还是lua call cs，原理是一样的。

从A环境传递一个对象a到B环境，会先在A环境的全局存储这个对象并建立一个a_id，保证这个对象不被GC，把a_id传递到B环境并构建一个包装对象a_wrapper，包含a_id，这样a_wrapper可以通过a_id访问到a。a_wrapper的GC方法里，需要把A全局表里的a清除掉，这样就能触发a的GC。

对于引用对象，还会记录到一个弱引用表，<a_id,a_wrapper>，下次传递a对象时，就能找到a_wrapper不用再创建。

globalReg: a_id-a

[a_wrapper{a_id,GC={delete in globalReg}}]

weaktable:<aid,a_wrapper>

两个GC系统的延迟GC问题

一个C#对象被lua持有着引用，当lua释放引用时，c#对象不会直接gc，需要等lua gc，lua gc可能会很慢触发，但它背后的引用的c#对象可能占用着较大的内存。

解决方案是lua对象释放的时候，手动调用一下c#对象的释放，把较大的内存释放掉，比如RawFileAsset对象中的byte数组data，lua释放这个对象时，手动把data置null，这样data就可以及时被GC，不用等lua gc。