最近在深入研究 TOON.NET 的時候，發現了一組非常有意思的基準測試數據。說實話，我對結果有點震驚——一個相對較新的格式，居然在多個主流 AI 大模型上的表現都遠超 JSON 和 YAML。今天就想和大家好好聊聊這個發現，以及它背后的意義。

什么是 TOON？為什么它如此特殊

在深入測試結果之前，咱們得先理解 TOON 到底是個啥。

TOON（Text-Oriented Object Notation） 是一種輕量級的數據序列化格式，它的設計理念就是為了在保持人類可讀性的同時，最大化地減少 token 消耗。相比 JSON 和 YAML 的冗長語法，TOON 采用了更加緊湊的表示方式：

• 元數據前置：通過 [size]{fields} 的方式聲明數組大小和對象字段，一次性告訴模型即將到來的數據結構
• 緊湊的值表示：避免了 JSON 中大量的引號、冒號、括號等符號
• 結構化的分隔：用冒號和縮進來表達層級關系，而不是嵌套的括號

這種設計對 AI 模型來說有個天然的好處——結構信息更清晰，需要的上下文窗口更小。但這只是我的推測，真正的驗證需要拿數據說話。

實戰測試：從本地部署到數據分析

我決定按照項目提供的方式，親自跑一遍完整的基準測試。過程其實不復雜，但需要一點點耐心。

環境準備

首先確保你的電腦裝了 .NET 10 SDK 和 VSCode。這是跑測試的基礎。然后克隆項目到本地：

git clone https://github.com/AIDotNet/Toon.NET

啟動基準測試

進入基準測試目錄：

cd benchmarks\AIDotNet.Toon.ModelBenchmarks

運行啟動腳本（這是我最喜歡的地方——直接一個 bat 腳本，省去了手動配置的麻煩）：

.\run-benchmark.bat 

腳本會交互式地詢問你的配置。我這次的參數設置是：

======================================================
  AIDotNet.Toon 模型基準測試 啟動腳本 (Windows .bat)
  該腳本將引導你輸入 API Key 和模型后啟動程序
======================================================

請輸入 OPENAI_API_KEY：[你的 API Key]

請輸入模型名稱（逗號分隔）：gpt-5-mini,gpt-4o-mini,gemini-2.5-flash,grok-code-fast-1,claude-haiku-4.5

可選：每個任務運行次數 BENCHMARK_RUNS：5

可選：模型級并發 BENCHMARK_MODEL_PARALLELISM：5

然后就是等待。測試會并行執行多個模型和格式組合，進度條會實時顯示：

數據揭露：TOON 的壓倒性優勢

等待大約 3 分多鐘后，測試完成了。輸出的匯總結果直接讓我眼前一亮：

正在啟動基準測試（首次運行將進行構建）...
模型格式準確性基準（.NET）
                 claude-haiku-4.5 總結
┌──────────────┬──────────┬─────────────┬─────────────┐
│ 格式         │ 準確率 % │ 提示 Tokens │ 生成 Tokens │
├──────────────┼──────────┼─────────────┼─────────────┤
│ JSON         │ 41.7     │ 150.2       │ 18.6        │
│ JSON compact │ 50.0     │ 115.2       │ 13.1        │
│ TOON         │ 91.7     │ 110.5       │ 6.8         │
│ YAML         │ 52.8     │ 120.3       │ 10.8        │
└──────────────┴──────────┴─────────────┴─────────────┘
                 gemini-2.5-flash 總結
┌──────────────┬──────────┬─────────────┬─────────────┐
│ 格式         │ 準確率 % │ 提示 Tokens │ 生成 Tokens │
├──────────────┼──────────┼─────────────┼─────────────┤
│ JSON         │ 72.2     │ 152.1       │ 150.8       │
│ JSON compact │ 75.0     │ 111.2       │ 199.3       │
│ TOON         │ 100.0    │ 106.2       │ 181.0       │
│ YAML         │ 88.9     │ 123.9       │ 173.4       │
└──────────────┴──────────┴─────────────┴─────────────┘
                   gpt-4o-mini 總結
┌──────────────┬──────────┬─────────────┬─────────────┐
│ 格式         │ 準確率 % │ 提示 Tokens │ 生成 Tokens │
├──────────────┼──────────┼─────────────┼─────────────┤
│ JSON         │ 41.7     │ 137.9       │ 9.4         │
│ JSON compact │ 36.1     │ 110.4       │ 8.3         │
│ TOON         │ 83.3     │ 107.0       │ 4.1         │
│ YAML         │ 50.0     │ 117.3       │ 9.5         │
└──────────────┴──────────┴─────────────┴─────────────┘
                    gpt-5-mini 總結
┌──────────────┬──────────┬─────────────┬─────────────┐
│ 格式         │ 準確率 % │ 提示 Tokens │ 生成 Tokens │
├──────────────┼──────────┼─────────────┼─────────────┤
│ JSON         │ 58.3     │ 134.8       │ 277.4       │
│ JSON compact │ 58.3     │ 108.4       │ 323.7       │
│ TOON         │ 83.3     │ 105.2       │ 152.8       │
│ YAML         │ 75.0     │ 114.9       │ 300.4       │
└──────────────┴──────────┴─────────────┴─────────────┘
                 grok-code-fast-1 總結
┌──────────────┬──────────┬─────────────┬─────────────┐
│ 格式         │ 準確率 % │ 提示 Tokens │ 生成 Tokens │
├──────────────┼──────────┼─────────────┼─────────────┤
│ JSON         │ 58.3     │ 330.0       │ 6.9         │
│ JSON compact │ 58.3     │ 301.9       │ 5.4         │
│ TOON         │ 97.2     │ 290.7       │ 3.4         │
│ YAML         │ 66.7     │ 301.3       │ 5.3         │
└──────────────┴──────────┴─────────────┴─────────────┘

關鍵數據洞察

1. 準確率：TOON 全面領先

看看準確率那一列，我覺得這是最能說明問題的地方：

• gemini-2.5-flash：TOON 達到了完美的 100% 準確率，其他格式最高也只有 88.9%（YAML）
• grok-code-fast-1：TOON 以 97.2% 擊敗其他所有格式，JSON 和 JSON compact 只有 58.3%
• claude-haiku-4.5：TOON 的 91.7% 遠超 JSON 的 41.7% 和 YAML 的 52.8%
• gpt-4o-mini：TOON 的 83.3% 高出第二名 YAML（50%）整整 33 個百分點
• gpt-5-mini：TOON 的 83.3% 同樣穩健領先

這不是偶然現象，而是一個在所有五個主流大模型上都能重現的規律。

2. Token 消耗：成本與效率的雙重勝利

這里更有意思。不僅準確率高，TOON 的 token 占用也是最低的：

看看提示 Token 和生成 Token 的平均消耗：

看到這組數據，我當時的反應就是——這簡直是在替開發者省錢。對于大規模數據傳輸的場景，token 消耗的降低直接轉化為 API 調用成本的下降。

為什么 TOON 會這么"聰明"？

說實話，這個問題我琢磨了一會兒。為什么 AI 模型對 TOON 格式的理解能力會這么強？

我的初步理解是：

1. 信息密度更高：TOON 的結構化表示讓模型能更快速地建立起"這是一個包含 N 個元素、每個元素有 M 個字段"的心智模型，而不需要逐個解析括號和引號。

2. 更少的干擾信息：JSON 的語法糖雖然對人類友好，但對模型來說是額外的認知負擔。TOON 則直奔主題。

3. 預測路徑更清晰：TOON 的規則性強，模型的 next-token 預測變得更有把握。這在 token 生成階段表現為更少的"糾結"，生成結果也更準確。

實際應用場景：什么時候該用 TOON？

基于這些數據，我的建議是：

• 大數據量場景：API 調用傳輸 MB 級別的數據時，TOON 的 token 節省會非常顯著
• 成本敏感項目：每一個 token 都算錢的時候，TOON 的優勢不可忽視
• 高準確率要求：需要模型準確理解和處理結構化數據時，TOON 是更好的選擇
• .NET 生態：如果你本身就是 .NET 棧，有現成的 SDK 支持，何樂而不為

C# 快速上手：用 TOON SDK 序列化數據

如果你是 .NET 開發者，我得好好介紹一下官方提供的 SDK，因為用起來真的很舒服。

安裝

通過 NuGet 一行命令搞定：

dotnet add package AIDotNet.Toon

序列化為 TOON

using Toon;

var options = new ToonSerializerOptions
{
    Indent = 2,                          // 用 2 個空格縮進
    Delimiter = ToonDelimiter.Comma,     // 用逗號分隔值
    Strict = true,                       // 嚴格模式
    LengthMarker = null                  // 不添加額外的長度標記
};

var data = new
{
    users = new[]
    {
        new { name = "alice", age = 30 },
        new { name = "bob", age = 25 }
    },
    tags = new[] { "a", "b", "c" },
    numbers = new[] { 1, 2, 3 }
};

string toonText = ToonSerializer.Serialize(data, options);
// 輸出結果是這樣的：
// users[2]{name,age}:
//   alice,30
//   bob,25
// tags[3]: a,b,c
// numbers[3]: 1,2,3

看看這個輸出格式，是不是特別清爽？沒有多余的符號，每一個數據都清清楚楚地擺在那里。

反序列化（當前支持原子值）

using Toon;

var s = ToonSerializer.Deserialize<string>("hello", options);   // "hello"
var n = ToonSerializer.Deserialize<double>("3.1415", options);  // 3.1415

總結：一個小格式的大潛力

這次測試讓我認識到，有時候看似"新奇"的技術方案，真的是在踏踏實實地解決實際問題。TOON 不是為了標新立異而標新立異，它的每一個設計決策都指向一個目標——讓 AI 模型理解得更快、更準，讓開發者的成本更低。

在 AI 時代，結構化數據的表示方式直接關系到應用的成本和體驗。如果你還在用 JSON 傳輸大量數據給 AI 模型，不妨試試 TOON，相信你會有驚喜的發現。

項目地址：https://github.com/AIDotNet/Toon.NET

官方地址：https://github.com/toon-format/toon

toon標準：https://github.com/toon-format/spec

如果這篇文章對你有幫助，請記得給項目一個 Star！每一個 Star 都是對開源作者的認可，也會激勵他們繼續打磨這個工具。