C# 与 Lua 交互原理:以 xLua 为例,Vector3 为什么能变快

2592 字
13 分钟
C# 与 Lua 交互原理:以 xLua 为例,Vector3 为什么能变快

Lua 语言本身的知识见 Lua 核心知识,xLua 在热更新方案中的位置见 热更新。

一、基础: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) 从栈顶读出结果 得到 3
6. 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 / LuaFunctionC# 端持有 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. 减少调用次数,合并成批量接口

-- 不好:设置位置要多次跨边界,还要创建 Vector3
local pos = obj.transform.position
pos.x = pos.x + dx
obj.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 端就永远无法回收它。

文章分享

如果这篇文章对你有帮助,欢迎分享给更多人!

C# 与 Lua 交互原理:以 xLua 为例,Vector3 为什么能变快
https://xslab.cloud/posts/lua/xlua-interop/
作者
LuxFire
发布于
2026-10-14
许可协议
CC BY-NC-SA 4.0
相关文章 智能推荐
1
Lua 核心知识:元表与元方法、面向对象、GC、弱表与全局表保护
Lua Unity 热更新中常用的 Lua 知识整理:基础类型与 table;元表与全部常用元方法,__index 的查找过程;用元表实现类、继承与多态;__gc 终结器;Lua 的增量三色标记 GC 与各种 GC 算法的对比(含引用计数的使用场景);弱表的 k、v、kv 模式;如何保护全局表;以及 xLua 中 C# 与 Lua 交互的开销与内存泄漏。
2
AssetBundle 原理与打包策略:文件结构、压缩、加载、依赖与冗余
Unity底层/资源与内存 AssetBundle 的文件里有什么;LZMA、LZ4、不压缩三种方式在大小、速度、内存上的差异;LoadFromFile、LoadFromMemory、LoadFromStream 等加载方式的区别;依赖的加载顺序与卸载;打包粒度、公共资源、Shader 与图集的打包策略和冗余检测;构建管线与哈希变化;以及常见面试题。
3
Unity 性能优化总览:从定位问题到 C#、引擎与渲染
Unity性能优化 Unity 常见性能优化点的总览。先讲怎么定位瓶颈,再按 C# 代码、Unity 对象与 API、渲染、UI、内存与加载分类整理,复杂主题链接到专题文章。
4
UGUI 性能优化:Canvas 重建、合批与过度绘制
Unity性能优化 UGUI 的性能问题来自哪里:Canvas 的 Rebuild 与 Rebatch、UI 合批规则、过度绘制和射线检测。以及动静分离、图集、Mask 选择、显隐方式、长列表等常用优化手段。
5
Unity 热更新:主流方案、原理设计与 HybridCLR + YooAsset 实践
项目设计/架构 为什么 Unity 需要专门的热更新方案;Lua、ILRuntime、PuerTS、HybridCLR 等代码热更方案的原理与对比;AssetBundle、Addressables、YooAsset 等资源热更方案;热更新的整体流程与架构设计;以及 HybridCLR 和 YooAsset 的原理、使用流程与注意事项。
随机文章 随机推荐
Profile Image of the Author
LuxFire
Hello, I'm LuxFire.
公告
欢迎来到我的博客!这是一则示例公告。
音乐
封面

音乐

暂未播放

0:00 0:00
暂无歌词
分类
标签
站点统计
文章
60
分类
6
标签
164
总字数
171,869
运行时长
0 天
最后活动
0 天前

文章目录