被第三方库坑了二十多年,我把二十多个 .NET 轮子全造了一遍
从 .NET 1.0 写到现在,二十多年攒下二十多个自研库,准备逐个推出。这篇写清楚它长什么样、为什么长成这样、哪块还没长好。有几个包已经能 dotnet add package,其余排队。
关键词:.NET、Native AOT、开源、架构、性能优化、Arrow、Parquet、ORM
一、开场:二十多年都干了什么
2002 年前后,我在 Visual Studio 里编译出人生第一个 .NET Framework 1.0 程序。那会儿 WinForms 拖控件,WebForms 拖 DataGrid,数据库访问靠一个叫 SqlHelper 的类拼字符串。谁会写 SqlHelper,在项目组里就很有地位。
再往后是 .NET 2.0 的泛型、3.5 的 LINQ、WCF 的契约优先、Remoting 的透明代理,然后 .NET Core、.NET 8、.NET 10,一路走到 Native AOT。
项目做了不少,别人的库也用了一堆。用得越多,心里那本账越清楚:
- 每个第三方依赖都是一笔迟早要还的债。它升级,你先跟;它不维护了,你的技术栈就原地冻结。
- 每个全家桶早晚会挡一下路。一个程序集塞进二十几个命名空间,我只想用一份 DEFLATE,结果被迫把 Win32 API、调度器、消息总线一起拖进来。
- 热路径上的每个
object,最后都会变成一次 GC。100 万行数据,每个值装一次箱,就是 100 万个对象排队等回收。
于是我把每天要用的底层能力,自己写了一遍。
一半为了快,一半为了不被依赖牵着走。我信不过别人的升级节奏,信不过接口哪天会不会改,也信不过它在我最忙的时候报一个我修不了的错。
这就是 Vane,一个工具箱:二十多把螺丝刀,每把只管一种螺丝。这篇详写其中 13 条主线。缺哪把拿哪把,不用把整个工具箱背走。写到今天,我其实是在给自己修一条能走二十多年的路。
成分先交代清楚:
| 阶段 | 底座从哪来 | 我在项目里的位置 |
|---|---|---|
| 入行头两年 | 用别人的框架、现成的商业库 | 会用,也被坑过;学着看懂别人的设计 |
| 第三年起直到现在 | 全部自研,每个项目开工先搭主干和核心架构,再往上盖业务 | 每个项目的主干、核心架构都是我搭的 |
这些库都由项目需求逼出来。日志是把前公司跑了十多年、内存和 CPU 都比同期主流低的那套组件经验搬过来,用零分配、零依赖重新实现;序列化是为了一堆写死的老接口;ORM 是为了不再手写 31 种方言的 SQL;Parquet 是为了一次差点把内存打爆的导入。每个库背后,都站着至少一个真实上线、真实挨过骂的系统。
二、这堆东西到底解决什么问题
正经一点的定义:纯 C#、零第三方依赖、为 AOT 与流式而生的 .NET 基础设施库,覆盖通信与分发、列式格式、计算引擎、数据访问与表格四条能力带,外加一组薄基座。
说直白些,它负责那些又脏又累、每个项目都得干一遍的活:怎么把字节从 A 送到 B、怎么把 100 万行数据不爆内存地读进来、怎么把 LINQ 翻译成 31 种数据库的 SQL、怎么打日志而不把 GC 打成筛子。
很多人一听平台就以为要装一整套。这里说明它刻意避开了什么:
- 没有统一框架。没有 Vane 全家桶启动器,没有全局
ServiceLocator。容器、日志、网络全是可选件,不用也能活。 - 没有跨语言内核。Arrow 不做 Flight,也不做 IPC 加密;Parquet 核心不 P/Invoke native 库。
- 不承诺热插拔。
Vane.Container只做组件导出和 DI,不做 Bundle 生命周期,也不做版本隔离。装插件那套是另一个物种,我有三个老项目专门干这个,没并进来,第九节解释原因。
四条公理
| 公理 | 大白话 | 落地证据 |
|---|---|---|
| 零第三方依赖 | 核心只认 BCL。真要第三方,另开一个 adapter 包,别污染核心 | Arrow / Parquet / Flow 核心零 PackageReference;Zstd/LZ4 塞在 Vane.Parquet.Compression 里 |
| 微内核 · 一包一责 | 一个包只讲一件事。不做上帝类 Options,不做统一门面 |
Vane.Dispatch 只依赖一个 ServiceResolver 委托;Vane.NET 内核不依赖 Rpc/Dispatch |
| 批是唯一数据单元 · 流式 | 数据一批一批走,别整表读进内存。内存和文件大小脱钩 | Parquet 的读批就是行组缓冲上的一个行区间视图;Sheet 滑窗档 RSS 恒定 |
| 值语义 · 零装箱 | 热路径上不许产生托管对象。行值、标量、日志条目全是结构体 | PqValue(32 字节)、CellValue、Scalar、LogEntry、StrView |
三条产品线加一条基座
| 线 | 库 | 对外价值 |
|---|---|---|
| 列式数据栈 | Vane.Arrow → Vane.Parquet → Vane.Flow |
内存列式表示 → 磁盘列式文件 → 表达式/计划/算子 |
| 数据访问栈 | ELinq → Voltcore(加 VoltServer / VoltClient) |
ORM 内核加关系库:内存、文件、网络三种形态,另带六种数据库协议仿真 |
| 通信与分发栈 | Vane.NET → Vane.Rpc / Vane.Mqtt、Vane.Dispatch |
一套宿主覆盖 8 种介质,进程内和跨进程同一套契约外观 |
| 基座 | Container / Pack / Logging / MiniMapper / ManagedLibDeflate | DI、schema 序列化、零分配日志、对象映射、托管 DEFLATE |
这里详写的是 13 条能力主线(Vane.Rpc / Vane.Mqtt / Vane.Rpc.Mqtt 并进 Vane.NET 算一条)。往上数,储物间里还有 3 个插件框架(OSGi.NET / GAF / Modular,都在 ACL 那边);再往前,ACL 那一代另有 12 个自有项目,6 个已被 Vane 取代、6 个保留未收编,更早还有一批没进文档的老轮子。造过的轮子保守说也有几十个,这篇只挑还在用的写,退役的只提不展开。
性能、内存、易用性这三件事,每个库我都按开源界第一梯队的标准去做。做不到的、没测的,正文里写明未测和欠一点。文中那些 ns、MB、倍数都是账。
三、一张图看懂:五层楼,外加一间储物间
给看不了图的朋友,文字版楼层表:
L4 数据访问与表格 ELinq · Voltcore(+VoltServer/Client) · Vane.Sheet
L3 计算引擎 Vane.Flow
L2 列式格式 Vane.Arrow · Vane.Parquet
L1 通信与分发 Vane.NET(+Rpc/Mqtt/Rpc.Mqtt) · Vane.Dispatch
L0 基座 Vane.Container · Vane.Pack · Vane.Logging · MiniMapper · ManagedLibDeflate
─── 虚线储物间 ─── OSGi.NET · GAF · Modular
| 层 | 干嘛的 | 住客 | 进门门槛 |
|---|---|---|---|
| L0 基座 | DI、序列化、日志、映射、压缩 | Container / Pack / Logging / MiniMapper / ManagedLibDeflate | 只许依赖 BCL,不许引用楼上任何一层 |
| L1 通信与分发 | 字节怎么送到对面;一次调用怎么被路由 | Vane.NET(加 Rpc/Mqtt)、Vane.Dispatch | 可依赖 L0;传输入口只许有一个门(Host) |
| L2 列式格式 | 列式数据在内存和文件里长什么样 | Vane.Arrow、Vane.Parquet | 核心零依赖;格式库不许懂查询,不许引用 L3 |
| L3 计算引擎 | 表达式、计划、优化、算子 | Vane.Flow | 只许依赖格式的数据形状,不许抓住人家的实现 API |
| L4 数据访问与表格 | 用户真正伸手取数的地方:SQL/ORM、表格文件 | ELinq、Voltcore、Vane.Sheet | 可依赖 L0 到 L3 |
| 储物间(保留区) | 没接住、也不能算重复的能力 | OSGi.NET、GAF、Modular | 不进主线,单独挂个牌子 |
四条硬规矩:
- 只许向下依赖。任何指向上层的
ProjectReference都算违规,必须记账。 - 实线真,虚线虚。虚线是设计依赖或语义桥,没接就是没接。
- 一个门进出。RPC 就是挂在
Host上的插件(UseRpc/MapRpc)。 - 要第三方就另开包(
.Compression/.Mel/.VanePack/.AspNetCore),核心包永不破例。
四、L0 基座:先把那个全家桶拆了
第一代代码是标准的 net48 时代产物:Acl.Core 3.5.5,一个程序集装下 23 个命名空间:Collections、Configuration、Data、IO、Log、Mapping、MessageBus、Scheduler、Security、Serialization、Win32API……听着很全,用起来很痛。想用一份 DEFLATE?连 Win32 API 一起拖走吧。想做 AOT?想都别想,反射撒得到处都是。
第二代第一件事就是拆家:一个 Core 拆成六个库,一个个搬出去住。
| 库 | 家底 | 它管什么 | 本机实测 |
|---|---|---|---|
Vane.Container 1.0.0 |
net8/net10(csproj 还留着 net11)· 3 包加 SourceGen | DI 加 MEF 形态组件导出:生命周期、keyed、集合解析、作用域、AOP、装饰器 | 无依赖瞬态 7.2 ns / 24 B;两依赖 34.9 ns;Singleton 7.0 ns |
Vane.Pack 0.1.0 |
net10 独占 · 121 文件 / 18.4k 行 | schema 驱动的二进制序列化,线格式控制权归调用方,专门伺候写死的老系统(C 结构体、Pascal 记录、COBOL 报文) | 16 个用例 15 个打得过 MessagePack(1.22 倍到 4.15 倍);Guid 16 B 对 38 B |
Vane.Logging 1.0.0 GA |
net8/net10 · 178 文件 / 15.1k 行 | 零分配日志:LogEntry 值语义加栈缓冲渲染加源生成零装箱派发;9 种 Appender、8 种过滤器、11×7 滚动(目录/文件/时间三轴可叠容量上限) |
单条端到端 41.83 µs;NLog 慢 432 倍、log4net 慢 466 倍、Serilog 慢 24.6 倍 |
MiniMapper |
net8/net10 · 43 文件 / 8.5k 行 | 对象映射,运行期映射加编译期源生成两条路,AOT 走生成器 | 类到类 Map 6.007 ns / 40 B |
ManagedLibDeflate |
net8/net10 · 19 文件 / 5.8k 行 | libdeflate 的纯托管实现,给不许引 native 的场合用 |
解压 1.85 µs,跟 native 打平(1.01 倍);压缩 10.6 µs,落后 2.4 倍 |
日志这个库得单拎出来说一段。前公司有个项目,大数据高吞吐场景,一台日志服务器同时只能接 2 个客户端写日志,再多内存和 CPU 就顶不住。我接手改造时翻了一遍旧代码,又问了几位老同事,瓶颈在数据量:一百多台机器密集写入,那会儿的常规开源日志组件接不住。我硬着头皮自己做滚动策略,在多线程、异步、内存和性能上死磕。最后做成目录、文件、时间三个维度各自可以叠容量上限、自由组合,运维不用天天盯磁盘。排障最狠的一条是出错时只凭年、月、日、时就能径直翻到对应那本历史日志,不用 grep 半个 TB。
我把这套理念搬过来,用零分配、零依赖的现代 .NET 重新落地,这就是 MiniLog,后来改名 Vane.Logging。它的血统来自十来年的产线打磨,加上一套今天才写得出来的实现方式。顺带一说,当年那套设计里的一些思路,Serilog 反复迭代十来年才在部分问题上慢慢靠过来。这份底气来自产线上十多年的真实日志量。
有个取舍是在坑里蹲过才想明白的:
Vane.Pack故意不做 per-value tag,按 schema 裸编码。好处是省,Guid 省 58%,对象省 15%;坏处是 null 和数据共用同一片编码空间,靠协议约定躲碰撞。这是给对接老系统交的保护费。
五、L1 通信与分发:一个门,八条路
| 库 | 家底 | 定位 |
|---|---|---|
Vane.NET |
net10/net11 · 147 文件 / 18.1k 行(含 rpc/) |
平台唯一的传输入口,纯托管、零第三方依赖,交付就一个 Vane.NET.dll |
Vane.Rpc |
同上 | 它是 Vane.Dispatch 的跨进程搬运工 |
Vane.Mqtt / Vane.Rpc.Mqtt |
同上 | MQTT 协议栈(Client/Server/Broker)加把 RPC 架到 MQTT 上 |
Vane.Dispatch |
net8/net10 · 74 文件 / 6.1k 行 | 容器无关、AOT 友好的分发微内核。前身叫 Ndf,在内部项目里被我折磨了好几年才敢开源 |
Vane.NET 最得意的一点:一套 Host / ClientBuilder 覆盖 TCP、UDS、NamedPipe、InProcess、HTTP、WebSocket、QUIC、UDP 八种介质。介质差异全塞进 Transport 抽象,业务代码只看见 PipeReader / PipeWriter。帧层是插件化的,帧边界由业务自己定,内核不规定协议,一旦规定,就总有人要改它。内核里也不含 Rpc 和 Dispatch,它们是叠在上面的插件。
Vane.Rpc 的帧结构是 4 字节长度加 20 字节帧头加 JSON 元数据加原始正文,八条路共用一套;单连接按 requestId 多路复用;TLS 归传输层,消息层绝不碰 SslStream(早年我干过每层都加密一次的蠢事,TLS 握手三次,排查了三天)。内容协商交给 Dispatch 的 FormatterSelector,415 / 406 的语义跟进程内一模一样。
Vane.Dispatch 提供特性路由、五类值提供器(Body/Route/Header/Query/Services)、三态恒运行的过滤器、CreateProxy<T>() 把接口变进程内客户端,Map / MapGet / MapPost 对标 Minimal API。热路径用表达式编译的调用器,不用反射;IsAotCompatible / IsTrimmable 全开,反射相关 API 老实打上 [RequiresUnreferencedCode] 标记。
性能:并发 1 时 40.13 µs / 5 KB,并发 64 时 1.52 ms / 313 KB。对手是 gRPC(65.33 µs / 669 KB)和 MagicOnion(67.53 µs / 765 KB)。TLS 同安全级 47.01 µs,gRPC 是 65.33 µs。
这组数字是 Dispatch + 编解码 + TCP 的组合读数,算不上分发内核单独的成绩。Vane.Dispatch 和 Vane.Rpc 都还没有独立基准,我在各自的库条目里照实写了,这里不单开一节摊账。
六、L2 列式格式:它们不懂 SQL,这是故意的
这一层只有一条铁律:格式库不认识查询。它们只把列式数据摆成正确的形状,怎么算是楼上 L3 的事。也因为这条铁律,Vane.Flow → Vane.Parquet 到现在还是虚线。没接线就是没接线,我不给它画实线充胖子。
Vane.Arrow:C# 里的 Arrow 微内核
| 项 | 值 |
|---|---|
| 家底 | net8 · 25 文件 / 7.2k 行 |
| 验证 | 482 例(480 通过,2 例是 zstd Huffman 的已知缺陷);与 pyarrow 26.0.1 双向互通 |
| 打法 | 数据直接写进页式 Arena(64 字节对齐),列只是一组地址;读写都是一次遍历加整段拷贝,热路径不产生托管对象 |
类型覆盖很全:Null、全部定长类型(Decimal128 / Date/Time/Timestamp / Duration / Interval)、Bool、Utf8、Binary、FixedSizeBinary、Struct、List、LargeList、Map、Union、RunEndEncoded、Utf8View、BinaryView。
读取侧有四个省法,都是一点点抠出来的:null_count=0 时干脆省略有效性位图;Slice 只改偏移不动数据;MappedArena 走 mmap 零拷贝;列裁剪不解码没选的列。IPC 写 V5、读 V4 加 V5,Schema / DictionaryBatch / RecordBatch / EOS / Footer 全手写,连 FlatBuffers 都用手写的读写器。没用官方 CodeGen,因为那套生成器在 AOT 下太重。
性能:原始读 mmap 只要 41.15 µs,官方 Apache.Arrow 是 125.1 ms(这个差距我反复跑了三遍才敢写);端到端含消费 63.38 ms / 21.7 KB,堆副本方案要 90.55 ms / 298.9 MB,四个数量级的分配差。这才是零装箱真正值钱的地方。
明确不做的:delta 字典批、Flight、Parquet、IPC 加密。做不完的就写明不做,省得别人来问。
Vane.Parquet:纯托管列式文件引擎
| 项 | 值 |
|---|---|
| 家底 | net10 · 37 文件 / 12.4k 行 · 版本 0.1.0-alpha(1.0 之前 API 还可能动) |
| 验证 | 单测 1756 通过 / 12 skip;479 份第三方语料 467 通过;duckdb / parquet-dotnet / Plank / carquet 四路交叉,文件大小跟 carquet 逐位一致(差 ≤0.1%) |
最得意的一手是变长列的表示:整列只有 Blob 加 Offs 两个数组,每行一个对象那套彻底丢掉。效果是读 100 万行字符串的托管分配从 47 到 94 MiB 掉到约 2 KiB。这背后是批才是唯一数据单元在这层的具体含义。
另外几处细节:布尔列用 Vector256 提位拼 64 位字;RLE / bit-packed 用位累加器替掉逐位循环;BYTE_STREAM_SPLIT 的 8×8 分组让压缩率再涨一档。
性能:写 5M 行 × 5 列 261.7 ms,parquet-dotnet 要 1441.3 ms(快 5.5 倍),分配 320 MB 对 815 MB,文件还小 37%;读侧领先 2.08 倍到 4.90 倍(String 18.67 倍、Int8 20.85 倍、Bytes 12.55 倍);池化读 Pooled=true 后分配降到 4.9 MB/轮(降 98%)、峰值 158.8 MB,耗时基本不变。
七、L3 计算引擎:Vane.Flow,唯一还没接上电的
| 项 | 值 |
|---|---|
| 家底 | net10 · 105 文件 / 32.2k 行 · 零 PackageReference |
| 文档 | polars/docs/工程结构.md,那份文档本身就是结构契约 |
结构上是 Frame 门面加 Core(MemPool/MemBlock、NativeBuffer、ColumnarBatch、ColumnOps、Scalar 标签联合、SimdKernel 三层分派)加 Expressions 加 Plans(逻辑计划、Optimizer 加 OptimizationReport)加 Operators(Pull 模型)。
三个关键取舍:用 Pull 不用 Push(算子按需拉,天生支持短路和流式);优化过程透明(OptimizationReport 会把改写了什么摊开给你看);内存池自己管(MemPool,不指望 GC)。
这层的实话:跟格式栈还没接线,要等阶段三才接 Parquet 解码,当前 IO 只有 CSV / NDJSON 这类文本入口;包名收口也没做完(G-05)。性能一个字都没测,没有基准工程。这块目前图纸画好了,电还没通。
八、L4 数据访问与表格:ORM、嵌入式库、表格
ELinq:零依赖 ORM 内核
| 项 | 值 |
|---|---|
| 家底 | net8/net10 · 227 文件 / 51,630 行 / 435 个 public 类型 |
| 方言面 | 31 个具体方言(加 3 个族/基类)· DbProviderType 35 个值 · 能力矩阵 34 条 · 98 个函数键(70 通用加 23 时序加 5 空间) |
| 测试面 | 24 个逐后端工程加 Shared 基座:MySQL、MySqlConnector、Oracle、PostgreSQL、SQLServer、SQLite、MsSqlite、MsSqlServer、Access、Firebird、GBase、Kingbase、Xugu、TDengine、QuestDb、DuckDb、Dameng、Voltcore、CSV、Excel、Text、ODBC、OdbcOracle、OdbcQuestDb |
| 实测 | Voltcore 套件 3391 通过 / 0 失败 / 4 跳过 / 46 秒;SQLite 套件 2884 通过 / 0 失败 / 7 跳过 / 74 秒 |
它把 LINQ 表达式树翻译成多方言 SQL,顺带管 schema 生成、真实 savepoint、批量、分片、缓存和 AOT 双 Tier。
跟老东家 Acl.Data 比,后者 633 文件 / 69,785 行 / 192 个公共类型 / 11 个方言。ELinq 用少 26% 的行数,做出约 3 倍的方言面,savepoint 还是真嵌套(老的是引用计数式假嵌套)。这个差距没必要谦虚。
跟市面上比,方言覆盖、函数键密度、能力矩阵可导出、AOT 双 Tier 这四项我认为是领先的;对 SqlSugar 还是欠一点,缺 MongoDB、缺 Sybase,生态和真机验证深度也不如人家。这些数字都来自实测。
欠账也列清楚:Db2 / HANA / ClickHouse 本机没实例也没连接串,24 个后端工程没全跑(P0 阻塞);不提供变更跟踪、不提供延迟加载、没有 TransactionScope 环境事务;性能没测(有基准工程,没出报告)。
Voltcore:一副引擎,三种形态
| 项 | 值 |
|---|---|
| 家底 | net8/net10 · 187 文件 / 45.7k 行 · 1.0(文件格式 v1) |
| 形态 | 内存(不配 Data Source,全在托管堆,MVCC 多版本)/ 文件(Data Source=path.volt,连续 WAL,崩了从段重放)/ 网络(Server=host:port,RESP 协议) |
| 入口 | ADO.NET(VoltConnection / VoltCommand / VoltDataReader,用法跟 SqlConnection 一样)/ 引擎 API(VoltEngine.Execute / ExecuteScalar / QueryEntities<T> / ExecuteStream)/ C ABI(Voltcore.Native,给 C、C++、Python、Rust、Go 做 P/Invoke) |
| 工程 | Voltcore、.Native、.Network2、.Arrow、.SourceGenerators、VoltServer、VoltClient、VoltModel、SqliteBridge(加 Cli/Gui) |
纯托管、进程内,最初冲着 SQLite 去。SQL 能力不算寒酸:多类 JOIN、子查询、CTE、聚合、窗口函数、DISTINCT、UPSERT、RETURNING、EXPLAIN、TOP n;可编程性也有,CREATE PROCEDURE 加 EXEC、CREATE TRIGGER(BEFORE/AFTER,带 NEW/OLD 伪表、SET NEW、RAISE)、CREATE VIEW、CREATE FUNCTION(SQL 体或 C# 委托 UDF),COLLATE 可配。类型系统照着 SQL Server 抄:decimal(p,s)、datetime2、uniqueidentifier、nvarchar;方言模式 6 种可切(None / MySql / Postgre / Oracle / SqlServer / Sqlite),切过去连函数别名和操作符都跟着走。
底下有真东西:MVCC 快照隔离加 OCC 写写冲突检测(先提交者赢);行存、列存、STORAGE DISK 能按表指定;持久化是整体 Checkpoint(明文 CRC32,或者 AES-256-GCM 加密)加连续 WAL 增量,Durability 分三档。
它有三副面孔:不配文件名就是内存库;配 Data Source=path.volt 就是文件库(默认连续 WAL,崩了从段重放,不做整体重写);写 Server=host:port 就是网络库(RESP 协议)。同一套 SQL、同一套事务语义,换个连接串换了个身份。
顺手还能查文件:.csv / .tsv(分隔符可配)/ .json(数组和 NDJSON 两种布局都认)/ .jsonl / .ndjson 直接当表 SELECT,也能写回(统一落 NDJSON,未知扩展名回退 CSV),扫描是流式的、边扫边推类型;.arrow 由 Voltcore.Arrow 在宿主初始化时往 ScanSourceRegistry 注册一行接入,核心执行路径一行没动;.xlsx / .xlsm 的直查已经在 voltcore-feature-wip 的 Voltcore.Excel 里跑通,主树还没合入,这里照实标注。拿 SQL 统计一堆表格文件这件事,不用先导库。
最有意思的一段是数据库仿真:一个宿主同时立起 PostgreSQL / MySQL / SQL Server(TDS) / Oracle(TNS+TTC) / 达梦(DM) / 虚谷(Xugu) 六个数据库端点,另加自家 RESP、HTTP、TCP-RPC、QUIC、WebSocket、NamedPipe 六路接入。对端不用改代码,拿 Npgsql、MySqlConnector、Microsoft.Data.SqlClient、ODP.NET 这些原生 .NET 驱动,按各自正常的连接串连上来就能读写;GetSchema 和全类型都对过一遍,驱动完全不知道对面是另一套实现(真驱动往返在 ServerTest.Postgres / MySql / SqlServer / Oracle 和 Voltcore.Network2.Tests 里跑着)。第一次用 SSMS 连上自己写的引擎时,我确实乐了一会儿;也顺手验证了一件事:协议兼容比功能兼容难得多,报错码、字符集、握手协商,一个不对就只回你一句连接失败。
远程这块跟通信层是接起来的:宿主用 AddPg / AddMySql / AddSql / AddOracle / AddDm / AddXugu 挂数据库端点,用 AddVolt / AddHttp / AddTcpRpc / AddQuic / AddWebSocket / AddNamedPipe 挂自家接入;连接和帧交给 Vane.NET 加 Vane.Rpc 加 Vane.Dispatch,协议原语在 Voltcore.Network\Protocols\*。它是这套平台的一个后端,并没有关起门来自己玩。
性能(对 SQLite :memory:),先挑好看的:主键点查 4.1 倍、SUM 2218 倍、8 线程并发 COUNT 12.3 倍、8 读加 1 写混合 169 倍、decimal SUM 2129 倍、空库创建 5.4 倍。
想省事也行:让它当 ELinq 的一个 provider,用 ORM 的方式增删改查,底下的 SQL 引擎照样是这一套。
Vane.Sheet:表格
| 项 | 值 |
|---|---|
| 家底 | net8/net10 · 268 文件 / 38.8k 行 · 尚未发布(没 git 远程、没发 NuGet,RepositoryUrl 还指着旧名字,G-09) |
| 打法 | 格式无关的 SheetFile / Workbook,游标式读取;三档读策略(Fast / SlidingWindow / Standard) |
性能这块得说明白:这组数是前身 Vane.Excel 时代跑的,Vane.Sheet 还没自己重跑。100 万行 × 10 列,写 268 ms、读 TModel 1275 ms;MiniExcel 分别是 2890 ms 和 15770 ms(慢 10.8 倍 / 12.4 倍)。DynamicRow 读分配 0.11 MB、DbDataReader 读分配 0.06 MB,分配跟行数无关,这是游标式的功劳。
这个库的定位就是文件再大也照开,而且真跑过:一个 22.5 亿行 / 100.45 GiB / 2146 个 sheet 的工作簿,写 38 分 59 秒(96.2 万行/秒;1 亿行档 117.8 万行/秒),读回 1 时 39 分 35 秒(37.6 万行/秒,缺格 0.000095%),写读两阶段峰值 RSS 194.2 MB、全程几乎不动。32GB 的机器写读 100GB 数据,内存跟文件大小彻底脱钩。每秒百万条在 1 亿行档是实测的,恒定内存是 194.2 MB 实测的,都不是估出来的。报告躺在仓库里(Sheet/src/Vane.Sheet.Stress/压力测试汇报_22.5亿行.md,另有 5 亿行、直通模式两份),谁都可以自己再跑一遍。唯一要说明的:这批数还是 Vane.Excel 时期跑的,Vane.Sheet 欠自己一次重跑,旧账先认,新数等它跑完再补。
九、储物间:三个看着重复其实不重复的老项目
这三个项目是同一族能力:让外部写好的代码在运行时被安装、解析、启动、卸载。它们不进主线,因为 Vane.Container 管的是启动期(注册表到容器),它们管的是运行期(安装包到解析到激活到卸载)。这俩是两回事。
| 项目 | 家底(实测) | 工程面 | 能力 |
|---|---|---|---|
OSGi.NET |
core 137 文件 / 18,659 行 / 51 公共类型(2012 年产出,产线稳定运行十余年,老东家项目至今在用),TFM net452;net48;net6.0;net8.0 |
19 个工程 | Bundle 六态生命周期、服务注册与追踪、版本区间匹配、起始级别、扩展点、类加载隔离、LDAP 过滤器、Preferences |
GAF |
core 50 文件 / 4,246 行 / 13 公共类型,net8.0(对标 OSGi.NET 而写,C/S 加 B/S 双支持) |
9 个工程 | Addin 仓库加 12 态生命周期加四类激活器加三档类加载器加目录/zip 两种包格式加全局程序集缓存加非托管库装载 |
Modular |
16 文件 / 647 行,net452;net48;net8.0(小项目用的轻量插件框架,能力已整合进 GAF) |
1 个工程 | UseModular / AddModulesFromAssembly 的最小模块约定 |
OSGi.NET 是按 OSGi 规范落地的运行时框架:ServiceRegistry(502 行)、ServiceTracker(784 行)、LDAP 式 SimpleFilter(597 行)、VersionRange(500 行)、FrameworkStartLevelImpl(469 行)、Bundle 级 ClassLoader(793 行)。GAF 比 OSGi 轻、比反射调个方法重,生命周期分段更细(多了 Configuring / Configured / Matching / Matched 四段,可以装好但不启动)。
OSGi.NET 是 2012 年写的。那会儿我还在 .NET 4.x 的世界里打滚,OSGi 这套包级生命周期加服务注册表加上类加载隔离在 Java 圈是标配,在 .NET 圈基本没人这么干。我一头扎进去写了很久,写完就往产线上扔,结果它在公司里稳定跑了十几年,直到今天,老东家那边的项目还在用它。
这也是我没把它判重复然后删掉的原因。一个跑了十几年的东西,收编它需要时间,它在别人的机器上还活着,还在替人挡故障。我能做的只是把它挂在储物间,牌子写清楚:能力不重复,我没接住。
GAF 的出身是另一回事,它就是冲着对标 OSGi.NET 去的。当年 OSGi.NET 在 C/S 模式下顺得像刀切黄油,客户端装个包、解析、跑起来、用完卸掉,一套流程清清楚楚。可一到 B/S 就水土不服:面对新式 Web 框架(AspNetCore 那一套、MEL 的 DI 与配置),它基本对不上榫头,宿主集成这块只能自己另起炉灶。
于是就写了 GAF:把 OSGi 好用的那部分(包、仓库、状态机、隔离类加载器)吸收进来,然后做轻、做现代,net8.0、直接吃 Microsoft.Extensions.*、自带 Gaf.AspNetCore 宿主集成,C/S 和 B/S 一起支持;生命周期还从 OSGi 的 6 态细化到 12 态(多出配置与匹配两段,可以装好但不启动);类加载给了隔离、共享、轻量三档。
一句话:OSGi.NET 是当年 C/S 的好答案,GAF 是我为 B/S 重写的那一版。这两个是构建大项目时的必备插件框架,项目一大,模块一多,没有装、解析、启、卸这套机制,最后一定退化成一堆手工拼装的 if。
Modular 的定位又不一样,它是给小项目准备的。十几个人、一两个月的项目,上 OSGi.NET 那套包加仓库加状态机加隔离类加载器,属于拿高射炮打蚊子;它真正需要的只是按约定把模块扫出来、注册进去、按顺序启动。Modular 就是这个最小约定:16 文件 / 647 行,UseModular 加 AddModulesFromAssembly 一句话接上,能跑就行,别搞复杂。
后来这套轻量能力被整合进 GAF 了:GAF 里那条免打包、轻量加载的 Lite 路线(LiteGafDemo / LiteActivatorDescriptor / LiteClassLoader),就是 Modular 那套思路吸收进去之后的形态。
这三个其实是一条产品线的三代:OSGi.NET 管大 C/S,GAF 管 C/S 加 B/S 并顺手把轻量路线收了进来,Modular 是它曾经最轻的那一版。
十、三条数据流:记住动词,就记住了架构
图回答谁依赖谁,数据流回答数据怎么走。
10.1 列式读写流(格式栈加引擎)
表格 / 文本 列式文件
SheetFile.读取 ──► SheetRow/Workbook ─┐
CSV / NDJSON ────────────────────────┤
▼
Vane.Flow:DataFrame / LazyFrame
表达式 → 逻辑计划 → Optimizer → 物理计划 → Pull 算子
│
▼
Vane.Arrow:Arena 列式批(64B 对齐页)
│ Ipc.OpenWriteFile → IpcWriter → Finish
▼
Vane.Parquet:SegmentSink 按行组 append
▼
.parquet
回读就反着走:ParquetFileReader.Open(...) 到 ReadNextAsync 到 PqTable(行组上的行区间视图),需要 Arrow 就走语义桥,再 Ipc.OpenReadFile 到 IpcFileReader.ReadNextAsync(可切批、可跨块、可复用)。
这条流有三个性质:一批一批走(没有 ReadAll 这种整表 API,我不给这种偷懒机会)、能不拷贝就不拷贝(PqTable 不复制行组缓冲,Slice 只改偏移)、元数据只解一次(footer 和 schema 全文件解析一遍,批次共享)。
10.2 数据访问流(ORM 加嵌入式库)
业务代码
│ ELinq:LINQ → 表达式树 → 方言能力(IProviderDescriptor / ICapabilityMatrix)
│ → CommandFactory 建命令 → DbConnection
▼
外部数据库(SqlServer / MySql / Postgre / Oracle / Sqlite …)
│
└─ 或者目标库就是嵌入式引擎:
VoltConnection / VoltCommand / VoltDataReader(ADO.NET 外观)
或 VoltEngine.Execute / QueryEntities<T> / ExecuteStream(引擎外观)
要点只有一个:同一套消费者 API,面对两种后端。Voltcore 既是 ELinq 的一个 provider,也能被业务代码直接当 SQLite 用。
10.3 通信与远程流(宿主加契约)
服务端 客户端
Host.CreateDefault() RpcClient.Create()
Listen(addr) │
StartAsync(conn => Transport.Input/Output) │
UseRpc(engine) ← IDispatchEngine(同一份契约)
MapRpc(endpoint) │
│ 帧 = 4B 长度 + 20B 帧头 + JSON 元数据 + 原始正文
└───────────── requestId 多路复用 ─────────────┘
│
进程内:Dispatch.CreateProxy<T>() ← 同一套 IDispatchEngine,不出进程
同构点:进程内调用和跨进程调用的外观一模一样,同一个 IDispatchEngine、同一个契约名 calc/Add、同一套 415/406 语义。差别只有一条:帧要不要过网线。
十一、开源状态:哪些能马上装,哪些还得等,nuget 上的elinq 还是10几年前的版本,一直没有更新过,说来惭愧,新版将来会改名,Vane.Data.
| 状态 | 库 | 说明 |
|---|---|---|
| 已上 NuGet | Vane.Container 1.0.0、Vane.Dispatch 1.1.0、ELinq 0.6.2.5、ManagedLibDeflate 0.1.0-alpha |
现在就能 dotnet add package;ELinq 线上还是 0.6.x,仓库收口 1.0 之后重发 |
| 已上 NuGet(ACL 时代的老包) | Acl.OSGi 1.2.1、Acl.Data 3.3.6、Acl.Excel 4.0.1、Acl.Modular 3.2.0、MiniLog 1.0.1、GAFi 1.0.2 |
老项目还在引用;Acl.Excel 是 Vane.Excel 的前身,MiniLog 是 Vane.Logging 的前身。GAF 的包名是 GAFi,GAF 这个 id 早被别人的遗传算法框架占了 |
| 已开源(gitee,未上 NuGet) | Vane.Logging、MiniMapper、Voltcore |
源码能拉能看,包还没推;Voltcore 1.0 |
| 即将开源(本地 git,收尾中) | Vane.Pack、Vane.NET(加 Rpc/Mqtt)、Vane.Arrow、Vane.Parquet(0.1.0-alpha)、Vane.Flow |
仓库已成型,还差 README、示例与发布流程 |
| 未发布 | Vane.Sheet |
没有 git 远程、没发 NuGet,RepositoryUrl 还指着旧名字(G-09) |
我不打算一次性把所有包都推到 NuGet 上然后消失。一个一个来,每个都带文档和示例。我见过太多发完就跑的仓库,不想加入那个行列。
想先试一口,四行就够(版本写死,免得装到半成品):
dotnet add package Vane.Container --version 1.0.0
dotnet add package Vane.Dispatch --version 1.1.0
dotnet add package ELinq --version 0.6.2.5
dotnet add package ManagedLibDeflate --version 0.1.0-alpha
ACL 时代那批老包同理,名字得写对:Acl.OSGi 1.2.1、Acl.Data 3.3.6、Acl.Excel 4.0.1、Acl.Modular 3.2.0、MiniLog 1.0.1、GAFi 1.0.2。别搜 GAF,搜出来是别人的遗传算法框架,我第一次搜到时还愣了一下,以为自己的包被下架了。
十二、写在最后:二十多年,为什么还在造轮子
有人问过我:你都写了二十多年了,为什么不用现成的?.NET 生态什么都有,日志有 Serilog,序列化有 MessagePack,Parquet 有 parquet-dotnet,ORM 有 EF Core 和 SqlSugar,你图什么?
我想了想,大概三个原因:
- 穷过。早年项目预算紧,商业库买不起,只能自己写。写着写着发现,自己写的还更好改。
- 怂。被依赖升级坑过太多次。半夜爬起来修一个上游改了个默认值的问题,那种滋味会改变一个人的技术观。
- 轴。我就是受不了一个包塞二十个命名空间。这毛病不好,但它逼着我学会了分层、学会了记账、学会了给每条线找证据。
还有一个原因说不清算体面还是高尚:这二十多年里我待过的每一个项目,主干和核心架构都是这套自研的东西在扛。除了入行头两年用别人的框架,之后每次开工都是同一套流程,先画主干、定分层、搭底座,再往里填业务。这套流程跑过太多次,跑到我已经不习惯等社区给我一个方案。它一直在工地上干活,只是现在工地的名字换成了 gitee。
日志这一支有来历。前公司那套组件在产线上连续跑了十多年,大数据量下内存和 CPU 都比同期主流开源方案低,只凭年、月、日、时就能定位历史日志。我把这套被年复一年验证过的理念搬进 MiniLog,用零分配、零依赖重写;十多年后,Serilog 在某些方面才慢慢靠了过来。这话我只在家里说过,写进博客算是留个证据,顺便提醒自己,当年判断是对的,那就别在开源这件事上怂。
二十多年下来,代码之外还攒下一套能自证的规矩:线必须能从 csproj 里查到,性能必须有原始报告,没测就写没测,缺口必须编号挂账。这套规矩比任何库都值钱,它让我在五十岁的时候还敢说这块我没做好。
新包我会按第十一节的顺序一个一个整理干净推出去:补 README、补示例、补基准报告,再发 NuGet。已经上去的那几个先躺着,Vane.Container、Vane.Dispatch、ELinq、ManagedLibDeflate,还有 ACL 时代那一批老包。不承诺时间表,承诺不烂尾。
如果你也在写 .NET,或者也在给自己造轮子,欢迎来看、来骂、来提 issue。二十多年的经验告诉我:一个人闷头造的轮子,得有人来踹两脚,才知道圆不圆。

浙公网安备 33010602011771号