C# 与 Lua 交互原理:以 xLua 为例,Vector3 为什么能变快
一、基础:Lua 虚拟栈
Lua 虚拟机是用 C 实现的,它对外只提供 C API。C# 无法直接操作 Lua 的数据,所有交互都通过 P/Invoke 调用 C API,并借助一个虚拟栈来传递数据:
C# 想调用 Lua 函数 Add(1, 2):
1. lua_getglobal(L, "Add") 把函数压栈 栈:[Add]2. lua_pushnumber(L, 1) 压入参数 栈:[Add, 1]3. lua_pushnumber(L, 2) 栈:[Add, 1, 2]4. lua_pcall(L, 2, 1, 0) 调用,1 个返回值 栈:[3]5. lua_tonumber(L, -1) 从栈顶读出结果 得到 36. lua_pop(L, 1) 清理栈可以看到,一次看似简单的调用,背后是多次跨越 C# 与原生代码边界的 P/Invoke 调用,每次都要做参数转换。这是 C# 与 Lua 交互开销的根源。
二、Lua 调用 C#
C# 方法如何被 Lua 调用
Lua 只能调用符合 lua_CFunction 签名的函数:int Func(IntPtr L),参数和返回值都通过栈传递。所以 xLua 会为每个要导出的 C# 方法准备一个包装函数:
// 以 Transform.SetParent 为例,生成的包装函数大致是这样的(简化)[MonoPInvokeCallback(typeof(lua_CSFunction))]static int _m_SetParent(IntPtr L){ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); var self = (Transform)translator.FastGetCSObj(L, 1); // 1. 从栈上取出 self(C# 对象) var parent = (Transform)translator.GetObject(L, 2, typeof(Transform)); // 2. 取出参数,检查类型 self.SetParent(parent); // 3. 调用真正的 C# 方法 return 0; // 4. 返回值个数(结果要压回栈上)}包装函数注册到 Lua 中后,Lua 端写 transform:SetParent(parent),就会调用到这个函数。
[MonoPInvokeCallback] 是 IL2CPP 的要求:被原生代码回调的 C# 方法必须是静态的并带有这个特性,才能生成对应的原生入口。
两种方式:反射与生成代码
| 反射 | 生成代码 | |
|---|---|---|
| 原理 | 运行时通过反射查找方法、调用 MethodInfo.Invoke | 编辑器中为指定的类型预先生成上面那样的包装代码 |
| 性能 | 慢:查找方法、参数装箱成 object[]、Invoke 本身都有开销和 GC | 快:直接调用,类型在编译期确定 |
| 维护 | 不需要额外操作 | 新增或修改导出的类型后要重新生成 |
| IL2CPP | 反射调用的方法可能被裁剪掉,需要配置 link.xml | 生成的代码直接引用了方法,不会被裁剪 |
xLua 的做法是:标记了 [LuaCallCSharp] 的类型生成代码,没有标记的自动退回反射。开发期不生成也能运行,发布前生成代码保证性能。常用的类型(Unity 的常用组件、项目中被 Lua 频繁调用的类型)都应该加入生成列表。
C# 对象如何进入 Lua
C# 对象不能直接放进 Lua,xLua 的做法是:
1. C# 端:ObjectTranslator 中有一个对象池(一个列表),把对象放进去,得到一个整数索引2. 向 Lua 压入一个 userdata,里面只存这个索引3. 给 userdata 设置这个 C# 类型对应的元表: __index → 访问方法、属性时,查找对应的包装函数 __newindex → 设置属性、字段 __gc → userdata 被 Lua 回收时,通知 C# 从对象池中移除这个对象Lua 端 C# 端userdata { index = 15 } ───────▶ ObjectTranslator.objects[15] = 某个 Transform └ 元表:Transform 的方法表- 对象池保证了 C# 对象不会被 C# 的 GC 回收:只要 Lua 还持有这个 userdata,对象就一直被对象池引用着。
- 同一个 C# 对象多次传入 Lua 时,xLua 会通过反向映射找到已有的索引,复用同一个 userdata,保证在 Lua 中
a == b的判断正确。 - 这也是跨语言循环引用、导致内存泄漏的根源(见 xLua 中的内存泄漏)。
三、C# 调用 Lua
| 方式 | 说明 |
|---|---|
LuaEnv.DoString | 执行一段 Lua 代码 |
LuaTable / LuaFunction | C# 端持有 Lua 的表或函数 |
| 映射到委托或接口 | 把 Lua 函数转成 C# 委托(需要标记 [CSharpCallLua] 并生成代码),把 Lua 表映射到 C# 接口 |
[CSharpCallLua]public delegate int AddFunc(int a, int b);
var add = luaEnv.Global.Get<AddFunc>("Add");int r = add(1, 2); // 像调用普通 C# 委托一样引用的生命周期:C# 持有 Lua 对象时,xLua 会在 Lua 的注册表中为它创建一个引用(luaL_ref),保证 Lua 的 GC 不会回收它。C# 端不再使用时,必须调用 Dispose(对应 luaL_unref),否则这个 Lua 对象永远不会被回收。
四、交互的性能热点
| 热点 | 原因 |
|---|---|
| 跨边界调用本身 | 每次调用都有多次 P/Invoke 往返,以及栈上的参数检查和转换 |
| 频繁的属性访问 | transform.position.x 在 Lua 中就是多次跨边界调用:取 position 一次,得到一个新的 Vector3,再取 x |
| 值类型传递 | 默认情况下,Vector3 这样的结构体传进 Lua 要装箱成对象,放进对象池,产生 GC;取回时还要拆箱 |
| 字符串 | Lua 字符串和 C# 字符串之间每次都要做编码转换,并分配新的字符串 |
| 反射调用 | 没有生成代码的类型走反射,又慢又产生 GC |
| Lua 表与 C# 集合互转 | 每次转换都要遍历和分配 |
五、xLua 为什么能让 Vector3 变快
问题
默认情况下,一个 Vector3 传给 Lua 的过程是:
装箱成 object → 放进 ObjectTranslator 的对象池 → 压一个带索引的 userdata每传递一次都会装箱(GC 分配),还要占用对象池的一个位置,Lua 端用完后要等 userdata 被回收才释放。在每帧都传递位置、方向的代码中,这会产生大量 GC。
GCOptimize:按值传递
xLua 的 [GCOptimize] 让结构体按值拷贝进 Lua:
不装箱、不进对象池:直接把 Vector3 的 x、y、z 三个 float 拷贝到一块 userdata 内存中Lua 端读取 .x 时,生成的代码直接从这块内存中读出 float传回 C# 时,再从内存中把三个 float 拷贝出来,组成一个新的 Vector3- 对于纯值类型的结构体(字段都是基础类型或其他纯值类型),xLua 会生成专门的打包(pack)和解包(unpack)代码,直接按字段读写内存。
- Unity 常用的
Vector2、Vector3、Vector4、Quaternion、Color等,xLua 已经内置了这种优化;项目自己的结构体需要标记[GCOptimize]并生成代码。 - 结果:传递结构体不再装箱,不占用对象池,也就不产生 GC。
另一种思路:在 Lua 中实现 Vector3
toLua 的做法是用纯 Lua 实现一套 Vector3(一个 Lua 表加上元方法),向量的加减、点乘、归一化等运算全部在 Lua 中完成,不需要跨边界调用 C#;只有在和 Unity 引擎交互时(比如设置 position),才把 x、y、z 三个数字传给 C#。
两种思路的出发点相同:避免为每个向量创建 C# 对象,并减少跨边界的次数。
六、减少交互开销的实践
1. 减少调用次数,合并成批量接口
-- 不好:设置位置要多次跨边界,还要创建 Vector3local pos = obj.transform.positionpos.x = pos.x + dxobj.transform.position = pos// 好:C# 端提供一个直接接收数字的方法,Lua 一次调用完成[LuaCallCSharp]public static class TransformHelper{ public static void Translate(Transform t, float dx, float dy, float dz) => t.position += new Vector3(dx, dy, dz); public static void GetPosition(Transform t, out float x, out float y, out float z) { var p = t.position; x = p.x; y = p.y; z = p.z; }}用 out 参数返回多个数字,Lua 端会收到多个返回值,避免创建 Vector3。
2. 缓存
-- 每帧都访问 CS.UnityEngine.Time.deltaTime,要经过多层表查找local Time = CS.UnityEngine.Time -- 缓存类型local transform = self.gameObject.transform -- 缓存组件,不要每帧获取3. 热点逻辑放在一边完成:每帧大量执行的计算(寻路、战斗数值、大量单位的移动),放在 C# 中实现,Lua 只负责调用一次;或者全部在 Lua 中完成,只在最后一步和引擎交互。
4. 用数字代替字符串:消息、事件、配置的标识用整数 ID,而不是字符串。
5. 生成代码:所有被 Lua 频繁调用的类型、所有需要传递的结构体,都加入生成列表;需要用委托接收 Lua 函数的,标记 [CSharpCallLua]。
6. 用 Profiler 定位:xLua 提供了 Lua 端的性能分析工具,可以统计各函数的耗时和调用次数,再结合 Unity Profiler 找到跨边界调用的热点。
七、xLua 的特点
| 特点 | 说明 |
|---|---|
| Hotfix | 在 C# 方法中注入代码,可以用 Lua 替换 C# 已有方法的实现,修复线上的 C# Bug(见 热更新) |
| 反射兜底 | 不生成代码也能运行,开发时方便 |
| GCOptimize | 结构体按值传递,零 GC |
| 委托与接口映射 | Lua 函数、Lua 表可以映射成强类型的 C# 委托和接口 |
| 生成代码可配置 | 通过特性或配置列表精确控制生成哪些类型,控制包体 |
常见追问
C# 和 Lua 是怎么交互的? 通过 P/Invoke 调用 Lua 的 C API,借助 Lua 虚拟栈传递参数和返回值。
Lua 调用 C# 方法时发生了什么? 调用到为这个方法注册的包装函数(lua_CFunction),它从栈上取出 self 和参数并转换成 C# 类型,调用真正的方法,再把返回值压回栈上。
C# 对象是怎么传到 Lua 的?
对象放进 ObjectTranslator 的对象池,Lua 中得到一个只存索引的 userdata,通过元表访问方法和属性,通过 __gc 在被回收时通知 C# 移除。
为什么要生成代码? 避免反射查找和调用的开销与 GC,同时避免 IL2CPP 裁剪掉通过反射调用的方法。
C# 与 Lua 交互的性能热点有哪些?怎么优化? 跨边界调用次数、值类型装箱、字符串转换、反射。优化方法:合并成批量接口、用 out 返回多个数字、缓存类型和组件、热点逻辑放在一边、用整数代替字符串、生成代码、结构体使用 GCOptimize。
xLua 做了什么让 Vector3 变快? GCOptimize:结构体不再装箱放进对象池,而是把字段按值直接拷贝到 userdata 内存中,通过生成的代码读写,零 GC。toLua 则是用纯 Lua 实现 Vector3,减少跨边界调用。
C# 持有的 LuaFunction 为什么要 Dispose? C# 持有 Lua 对象时,Lua 注册表中保存了一个引用,不调用 Dispose 释放,Lua 端就永远无法回收它。
文章分享
如果这篇文章对你有帮助,欢迎分享给更多人!