Unity JSON解析全攻略：JsonUtility、Newtonsoft.Json与ListJson实战详解

1. 项目概述：为什么Unity开发者绕不开JSON解析？

在Unity项目里，不管是处理从服务器拉取的玩家数据、读取本地配置文件，还是序列化游戏存档，JSON几乎是无处不在的“数据交换语言”。它轻量、易读、跨平台，是连接游戏逻辑与外部数据最常用的桥梁。然而，很多开发者，尤其是刚接触Unity不久的朋友，在面对JsonUtility、ListJson、Newtonsoft.Json（现在叫Json.NET）这几个选项时，往往会感到困惑：它们有什么区别？我该用哪个？为什么我的数据序列化出来是空的？

我自己在项目里踩过不少坑，从简单的玩家属性保存到复杂的嵌套数据结构同步，几乎把能遇到的JSON解析问题都经历了一遍。这篇文章，我就以一个一线开发者的视角，结合大量实战案例，为你彻底理清Unity中JSON解析的脉络。我会详细拆解JsonUtility、ListJson和Newtonsoft.Json这三驾马车的核心原理、适用场景、具体用法以及那些官方文档里不会写的“坑点”。无论你是想快速实现一个功能，还是为项目选择长期稳定的数据方案，这篇指南都能给你提供直接的、可复现的答案。

2. 核心工具选型：三驾马车，各司其职

选择正确的工具是成功的第一步。Unity生态里的这三个JSON处理方案，定位和能力差异巨大，用错了地方轻则效率低下，重则功能无法实现。

2.1 JsonUtility：Unity亲生的“轻量级选手”

JsonUtility是Unity引擎内置的序列化工具，它最大的特点就是“原生”和“轻量”。它的设计初衷是为了高效地序列化Unity的[Serializable]类（特别是MonoBehaviour和ScriptableObject的公共字段），以便于场景预制体、资源之间的数据交换。

它的核心优势在于：

• 零依赖：无需导入任何第三方DLL，开箱即用，最适合发布WebGL或对包体大小极其敏感的项目。
• 与Unity序列化深度集成：对Vector3、Color、Quaternion等Unity特有类型支持良好，序列化和反序列化这些类型时非常自然。
• 性能开销极低：由于是原生C++实现，且功能聚焦，在序列化简单数据结构时速度最快。

但它的局限性也非常明显：

• 不支持泛型集合（如List<T>、Dictionary<K, V>）的直接序列化：这是新手最常踩的坑。你不能直接把一个List<PlayerData>丢给JsonUtility.ToJson。
• 仅处理公共字段（public fields）：属性（Properties）、私有或受保护字段默认都会被忽略，除非配合[SerializeField]特性。
• 功能单一：不支持自定义日期格式、多态序列化、忽略空值等高级特性。

注意：JsonUtility不是全功能的JSON库。如果你的数据模型里充满了List和Dictionary，或者需要复杂的序列化控制，用它你会非常痛苦。它最适合的场景是序列化单个、结构相对固定的、包含Unity原生类型的配置类或状态类。

2.2 ListJson：社区智慧的“补丁方案”

严格来说，ListJson并不是一个独立的库，而是一种针对JsonUtility缺陷的通用解决方案或设计模式。因为JsonUtility不能直接处理List<T>，社区里就流行起一种“包装器”模式。

其核心思路是：创建一个可序列化的包装类，里面只包含一个List<T>类型的公共字段。让JsonUtility去序列化这个包装类，从而间接达到序列化列表的目的。

[System.Serializable] public class PlayerData { public string name; public int level; } // 包装类 [System.Serializable] public class PlayerDataList { public List<PlayerData> players; // JsonUtility 可以处理这个 } // 使用方式 PlayerDataList listWrapper = new PlayerDataList(); listWrapper.players = myPlayerList; string json = JsonUtility.ToJson(listWrapper, true); // 第二个参数prettyPrint用于美化输出 // 反序列化 PlayerDataList deserialized = JsonUtility.FromJson<PlayerDataList>(json); List<PlayerData> myNewList = deserialized.players;

这是一种“曲线救国”的方案，优点是简单直接，无需引入新库。但缺点也很突出：

• JSON结构被污染：生成的JSON会多一层嵌套（{"players":[...]}），如果和第三方服务交互，可能需要额外处理。
• 仅解决列表问题：对于Dictionary、复杂嵌套、多态等JsonUtility的其他短板，它无能为力。
• 不够优雅：需要为每种列表类型创建对应的包装类，增加了代码量。

2.3 Newtonsoft.Json (Json.NET)：功能强大的“瑞士军刀”

Newtonsoft.Json（在Unity中通常通过Json.NET或Newtonsoft.Json-for-Unity包导入）是.NET生态中事实上的JSON标准库。它功能全面、配置灵活、社区支持极好。

为什么在Unity中它也如此受欢迎？

• 功能极其强大：支持几乎所有你能想到的序列化场景——泛型集合、字典、多态继承、循环引用、自定义转换器、忽略空值、日期格式控制等等。
• 高度可配置：通过JsonSerializerSettings和一系列特性（如[JsonProperty]、[JsonIgnore]），你可以精细控制序列化的每一个环节。
• 良好的性能：虽然比JsonUtility序列化简单对象慢一些，但其算法经过高度优化，在处理复杂对象时表现依然出色，且通常远优于自己写的蹩脚解析器。
• 卓越的容错性：对JSON格式的容错能力更强，有时能处理一些不太规范的JSON数据。

当然，它也有代价：

• 需要额外导入：会增加项目体积（通常几百KB到1MB左右）。
• IL2CPP兼容性问题：在开启IL2CPP编译并启用代码裁剪（Code Stripping）时，如果使用动态或反射特性（如JObject），可能会被错误裁剪导致运行时错误。需要使用link.xml文件进行保留。
• 略微复杂：丰富的功能也带来了更多的API和概念，初学者可能需要一点时间上手。

选型决策速查表：

我个人在实际项目中的选择策略是：中小型项目，或者模块相对独立、数据结构简单的，我会优先考虑JsonUtility，保持纯净。一旦项目规模扩大，涉及网络通信、复杂配置管理，我会毫不犹豫地引入Newtonsoft.Json，其带来的开发效率提升远超过引入它的成本。ListJson则通常是我在原型阶段，或者修改一个遗留的、仅使用JsonUtility的旧模块时的临时手段。

3. 从零到一：三大工具的详细使用指南

理论说再多，不如一行代码。下面我们抛开概念，直接看每种工具具体怎么用，以及其中有哪些必须注意的细节。

3.1 JsonUtility 实战：精准操作避免踩坑

基础序列化与反序列化假设我们有一个简单的玩家数据类：

[System.Serializable] // 这个特性是必须的！ public class PlayerStats { public string playerName; public int health; public int score; public Vector3 lastPosition; // Unity原生类型，JsonUtility支持 // private int secretCode; // 不会被序列化 // public int Level { get; set; } // 属性，默认也不会被序列化 }

序列化过程非常简单：

PlayerStats stats = new PlayerStats(); stats.playerName = "Hero"; stats.health = 100; stats.lastPosition = new Vector3(1, 2, 3); string jsonString = JsonUtility.ToJson(stats); // 输出: {"playerName":"Hero","health":100,"score":0,"lastPosition":{"x":1.0,"y":2.0,"z":3.0}}

反序列化同样直接：

string incomingJson = "{\"playerName\":\"Villain\",\"health\":50}"; PlayerStats loadedStats = JsonUtility.FromJson<PlayerStats>(incomingJson); Debug.Log(loadedStats.playerName); // 输出: Villain Debug.Log(loadedStats.score); // 输出: 0 (JSON中不存在，使用默认值)

处理列表（ListJson模式）这是JsonUtility的必修课。如前所述，你需要一个包装类：

[System.Serializable] public class Item { public string id; public string name; } [System.Serializable] public class ItemListWrapper { public List<Item> items; } // 序列化一个列表 List<Item> myItems = new List<Item> { new Item { id = "1", name = "Sword" }, new Item { id = "2", name = "Shield" } }; ItemListWrapper wrapper = new ItemListWrapper { items = myItems }; string itemsJson = JsonUtility.ToJson(wrapper, true); // prettyPrint设为true，方便阅读 /* 输出: { "items": [ { "id": "1", "name": "Sword" }, { "id": "2", "name": "Shield" } ] } */ // 反序列化 ItemListWrapper deserializedWrapper = JsonUtility.FromJson<ItemListWrapper>(itemsJson); List<Item> retrievedItems = deserializedWrapper.items;

处理字典（Dictionary）JsonUtility完全不支持直接序列化Dictionary<K, V>。这是一个硬性限制。常见的变通方案有两种：

1. 转换为列表：将字典转换为一个List<KeyValuePair>或者自定义的SerializableKeyValuePair列表进行序列化。

   [System.Serializable] public class SerializableKeyValuePair { public string key; public int value; // 可以添加一个构造函数方便转换 public SerializableKeyValuePair(string k, int v) { key = k; value = v; } } [System.Serializable] public class DictionaryWrapper { public List<SerializableKeyValuePair> entries = new List<SerializableKeyValuePair>(); } // 使用示例 Dictionary<string, int> originalDict = new Dictionary<string, int> { { "A", 1 }, { "B", 2 } }; DictionaryWrapper wrapper = new DictionaryWrapper(); foreach (var kvp in originalDict) { wrapper.entries.Add(new SerializableKeyValuePair(kvp.Key, kvp.Value)); } string json = JsonUtility.ToJson(wrapper);

2. 使用两个平行的列表：一个存键（List<string>），一个存值（List<int>）。这种方法序列化后的结构更简单，但需要保证两个列表顺序严格对应，反序列化时再重建字典。

实操心得：对于JsonUtility，我的经验是“保持简单”。尽量让你的数据模型扁平化，避免复杂的嵌套和泛型集合。如果模型开始变得复杂，就是时候考虑升级到Newtonsoft.Json了。另外，JsonUtility.FromJson是覆盖式的，它会用JSON中的数据覆盖目标对象已有的字段值，缺失的字段则保持不变（使用对象当前值或默认值）。这与Newtonsoft.Json的默认行为不同。

3.2 Newtonsoft.Json 实战：释放灵活性的力量

首先，你需要通过Unity的Package Manager (UPM) 安装Newtonsoft.Json。推荐使用com.unity.nuget.newtonsoft-json这个官方维护的版本，IL2CPP兼容性更好。

基础使用Newtonsoft.Json默认使用属性（Property）进行序列化，这对C#开发者更友好。

using Newtonsoft.Json; // 引入命名空间 public class PlayerProfile { // 使用属性 public string Name { get; set; } public int Level { get; set; } // 可以使用特性控制 [JsonProperty("exp")] // 序列化后字段名为"exp" public long Experience { get; set; } [JsonIgnore] // 忽略此属性，不参与序列化 public string SessionToken { get; set; } // 直接支持复杂类型 public Dictionary<string, int> Attributes { get; set; } public List<string> Inventory { get; set; } public DateTime LastLogin { get; set; } // 直接支持DateTime } // 序列化 PlayerProfile profile = new PlayerProfile { Name = "Arthas", Level = 60, Experience = 999999, SessionToken = "secret", Attributes = new Dictionary<string, int> { { "Str", 100 }, { "Agi", 80 } }, Inventory = new List<string> { "Sword", "Potion" }, LastLogin = DateTime.Now }; string json = JsonConvert.SerializeObject(profile, Formatting.Indented); // 输出漂亮的格式化JSON，包含字典、列表和日期。 // 反序列化 PlayerProfile deserializedProfile = JsonConvert.DeserializeObject<PlayerProfile>(json);

高级配置通过JsonSerializerSettings，你可以实现高度定制。

JsonSerializerSettings settings = new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore, // 忽略null值 DefaultValueHandling = DefaultValueHandling.Ignore, // 忽略默认值 DateFormatString = "yyyy-MM-dd HH:mm:ss", // 自定义日期格式 ContractResolver = new CamelCasePropertyNamesContractResolver(), // 使用驼峰命名 // 处理循环引用 ReferenceLoopHandling = ReferenceLoopHandling.Serialize, PreserveReferencesHandling = PreserveReferencesHandling.Objects }; string customJson = JsonConvert.SerializeObject(profile, settings);

处理多态和继承这是Newtonsoft.Json的杀手锏之一。假设有一个基类和多个子类：

[JsonConverter(typeof(JsonSubtypes), "type")] // 使用JsonSubtypes库，或Newtonsoft内置的TypeNameHandling [JsonSubtypes.KnownSubType(typeof(EnemyData), "enemy")] [JsonSubtypes.KnownSubType(typeof(NpcData), "npc")] public abstract class EntityData { public string type; } public class EnemyData : EntityData { public int aggression; } public class NpcData : EntityData { public string dialogue; } // 序列化一个混合列表 List<EntityData> entities = new List<EntityData> { new EnemyData(), new NpcData() }; string polyJson = JsonConvert.SerializeObject(entities, new JsonSerializerSettings { TypeNameHandling = TypeNameHandling.Auto // 自动添加类型信息 }); // 反序列化时，能正确还原出EnemyData和NpcData对象。

注意：TypeNameHandling有安全风险，如果反序列化不可信的JSON源，可能导致恶意类型被实例化。对于网络API数据，更安全的做法是使用自定义的JsonConverter或像JsonSubtypes这样的库来基于一个确定的字段（如"type":"enemy"）进行类型判别。

IL2CPP与代码裁剪这是Unity项目使用Newtonsoft.Json必须注意的。如果你使用了动态特性（如JObject、JArray）或反射较多的功能，在发布时可能会因为代码裁剪而丢失。解决方案：在项目的Assets文件夹下创建一个link.xml文件，告诉IL2CPP链接器不要裁剪指定的类型或程序集。

<linker> <assembly fullname="Newtonsoft.Json" preserve="all"/> <!-- 或者更精确地保留特定类型 --> <!-- <assembly fullname="Newtonsoft.Json"> <type fullname="Newtonsoft.Json.Linq.JObject" preserve="all" /> <type fullname="Newtonsoft.Json.Linq.JArray" preserve="all" /> </assembly> --> </linker>

3.3 ListJson模式再深入：不仅仅是Wrapper

ListJson模式的核心思想可以扩展。例如，当你需要序列化一个包含多种类型对象的列表时（但又不想到Newtonsoft.Json的多态那么重），可以结合JsonUtility和接口或基类（但JsonUtility对多态支持很弱，通常需要额外处理）。

一种更实用的扩展是创建通用的包装器工具方法：

public static class JsonUtilityHelper { public static string ToJsonList<T>(List<T> list) where T : new() { var wrapper = Activator.CreateInstance<JsonListWrapper<T>>(); wrapper.items = list; return JsonUtility.ToJson(wrapper); } public static List<T> FromJsonList<T>(string json) where T : new() { var wrapper = JsonUtility.FromJson<JsonListWrapper<T>>(json); return wrapper?.items ?? new List<T>(); } [System.Serializable] private class JsonListWrapper<T> { public List<T> items; } } // 使用 List<Item> myList = ...; string json = JsonUtilityHelper.ToJsonList(myList); List<Item> newList = JsonUtilityHelper.FromJsonList<Item>(json);

这样可以在小范围内提供一些便利，但依然无法解决Dictionary和多态等根本问题。

4. 性能、内存与实战陷阱深度剖析

选择工具不能只看功能，性能、内存开销和实际开发中遇到的坑同样重要。

4.1 性能对比浅析

对于简单的小对象（字段少于20个），JsonUtility的序列化/反序列化速度通常比Newtonsoft.Json快数倍，因为它逻辑简单，且是原生代码。但随着对象复杂度上升（深度嵌套、大量集合），Newtonsoft.Json的优化算法优势会体现出来，差距缩小。

一个重要的性能陷阱是频繁序列化。例如，在每帧（Update）中都将一个庞大的游戏状态序列化成JSON发送，无论用哪个库都会成为性能瓶颈。正确的做法是：

1. 增量更新：只序列化发生变化的部分数据。
2. 节流：设置一个最小时间间隔（如0.1秒）才执行一次序列化和发送。
3. 使用更高效的二进制格式：对于实时性要求高的内部通信，考虑MessagePack或Protobuf。

内存方面，Newtonsoft.Json由于功能更多，其库本身会占用一些内存。而JsonUtility作为引擎一部分，没有额外的托管内存开销。但序列化过程中产生的临时字符串（JSON字符串）才是内存的大头，两者在这方面差异不大。关键是要避免在频繁调用的路径中创建巨大的JSON字符串，记得及时释放引用，对于网络返回的大JSON，考虑使用流式解析（JsonTextReader）。

4.2 常见问题排查与解决方案实录

这里记录了几个我踩过并且看到无数人踩过的“坑”。

问题1：使用JsonUtility序列化后，JSON字符串为空（“{}”）或数据缺失。

• 原因A：类没有标记[System.Serializable]。这是前提条件。
• 原因B：要序列化的字段不是public。JsonUtility默认只序列化公共字段。使用[SerializeField]可以让私有字段也被序列化。
• 原因C：序列化的是属性（Property）而不是字段（Field）。JsonUtility不处理属性。
• 原因D：字段类型不被支持。比如直接序列化一个Dictionary或接口类型的字段。
• 排查：首先检查类是否有[Serializable]，然后检查字段是否为public。对于MonoBehaviour，即使字段是public，如果它挂载在游戏对象上但未在Inspector中赋值（且没有默认值），序列化时也可能是默认值（如null, 0）。

问题2：Newtonsoft.Json在IL2CPP构建后运行时抛出JsonSerializationException或找不到方法。

• 原因：代码裁剪（Code Stripping）移除了序列化所需的类型信息或方法。常见于使用了dynamic、JObject、匿名类型，或通过反射访问的属性。
• 解决：
  1. 使用前文提到的link.xml文件保留Newtonsoft.Json程序集或特定类型。
  2. 尽量避免在IL2CPP构建中使用JObject解析不确定结构的JSON。如果必须，考虑使用强类型的DTO（数据传输对象）类进行反序列化。
  3. 在Player Settings中，尝试降低“Managed Stripping Level”（如从High改为Low），但这会增加包体。

问题3：反序列化后，数值是对的，但引用类型（如List）的内容是空的。

• 原因（针对JsonUtility）：JsonUtility.FromJson是覆盖式的。如果你反序列化到一个已存在的对象实例，并且JSON中某个字段（如一个List）不存在或为null，该字段不会被置为null或空列表，而是保持原实例的值。如果原实例为null，反序列化后它还是null。
• 解决：对于引用类型字段，在反序列化前，确保目标对象已经被正确实例化，或者理解并接受这种覆盖行为。更安全的做法是总是反序列化到一个全新的对象实例：var obj = JsonUtility.FromJson<MyClass>(json);。

问题4：日期时间（DateTime）序列化格式混乱，或者反序列化时出错。

• 原因：JSON标准没有日期类型，Newtonsoft.Json默认使用ISO 8601格式（如"2023-10-27T10:30:00Z"），而JsonUtility对DateTime的支持很弱（通常需要自己处理字符串）。不同服务器返回的日期格式也可能五花八门。
• 解决（Newtonsoft.Json）：

  // 方案1：全局设置 JsonConvert.DefaultSettings = () => new JsonSerializerSettings { DateFormatString = "yyyy-MM-dd HH:mm:ss" }; // 方案2：单次序列化设置 var settings = new JsonSerializerSettings { DateFormatString = "yyyy-MM-dd" }; string json = JsonConvert.SerializeObject(obj, settings); // 方案3：使用特性 public class MyClass { [JsonProperty(ItemConverterType = typeof(IsoDateTimeConverter))] public DateTime EventTime { get; set; } }

• 解决（JsonUtility）：通常将DateTime存储为long（时间戳）或格式化的string，手动进行转换。

问题5：处理从网络API或第三方获取的“不规范”JSON。

• 场景：JSON的键名有奇怪的字符、是C#关键字，或者结构动态变化。
• 解决（Newtonsoft.Json）：使用[JsonProperty]特性映射不同的键名。

  public class ApiResponse { [JsonProperty("class")] // JSON键是"class"，C#关键字 public string ClassName { get; set; } [JsonProperty("first-name")] public string FirstName { get; set; } }

  对于完全动态的JSON，使用JObject或JToken：

  string dynamicJson = "{\"user\": {\"id\": 123, \"name\": \"test\"}, \"extra\": [1,2,3]}"; JObject jObj = JObject.Parse(dynamicJson); int userId = (int)jObj["user"]["id"]; string name = (string)jObj["user"]["name"]; JArray extraArray = (JArray)jObj["extra"];

  再次警告：在IL2CPP下谨慎使用JObject，确保已配置link.xml。

问题6：序列化循环引用对象导致栈溢出。

• 场景：对象A引用B，B又引用A。
• 解决（Newtonsoft.Json）：配置ReferenceLoopHandling。

  var settings = new JsonSerializerSettings { ReferenceLoopHandling = ReferenceLoopHandling.Ignore // 忽略循环引用 // 或者 ReferenceLoopHandling = ReferenceLoopHandling.Serialize 配合 PreserveReferencesHandling }; string json = JsonConvert.SerializeObject(objWithCycle, settings);

• 解决（根本）：重新设计数据模型，避免循环引用，或者使用ID进行关联，在序列化时断开循环。

5. 进阶场景与最佳实践

掌握了基本用法和避坑技巧后，我们来看看如何在实际项目中优雅地使用这些工具。

5.1 设计可序列化的数据模型

良好的数据模型是基础。我的建议是：

• 为序列化专门创建DTO（Data Transfer Object）类：不要直接序列化你的MonoBehaviour业务逻辑类。创建只包含数据的纯C#类，这样更清晰，也避免了序列化不必要的引擎依赖字段。
• 使用属性而非公共字段（如果使用Newtonsoft.Json）：属性是C#的首选方式，能更好地封装数据。
• 为枚举使用字符串序列化：默认枚举被序列化为数字，这在JSON中可读性差且容易因枚举值顺序改变而出错。使用[JsonConverter(typeof(StringEnumConverter))]特性将其序列化为字符串。
• 考虑版本兼容性：为类添加[JsonProperty(DefaultValueHandling = DefaultValueHandling.Populate)]并配合[DefaultValue]特性，可以在反序列化时为新字段提供默认值，便于向后兼容。

5.2 与Unity特定类型协作

ScriptableObject 数据资产ScriptableObject是存储游戏配置、设计数据的绝佳选择。你可以轻松地将其序列化为JSON进行导出、导入或网络同步。

// 一个可序列化的ScriptableObject public class GameConfig : ScriptableObject { public string gameVersion; public List<LevelSetting> levels; } // 在编辑器扩展中，可以提供一个按钮来导出为JSON #if UNITY_EDITOR [CustomEditor(typeof(GameConfig))] public class GameConfigEditor : Editor { public override void OnInspectorGUI() { DrawDefaultInspector(); if (GUILayout.Button("Export as JSON")) { GameConfig config = (GameConfig)target; string json = JsonUtility.ToJson(config, true); // 或者用Newtonsoft.Json // 保存json到文件... } } } #endif

PlayerPrefs的替代方案PlayerPrefs适合存简单键值对，但存复杂结构很麻烦。可以用JSON结合文件存储来实现更灵活的本地存档。

using System.IO; using UnityEngine; public class JsonSaveSystem { private static string SavePath => Path.Combine(Application.persistentDataPath, "save.json"); public static void SaveGame(GameSaveData data) { string json = JsonConvert.SerializeObject(data, Formatting.Indented); // 使用Newtonsoft File.WriteAllText(SavePath, json); } public static GameSaveData LoadGame() { if (!File.Exists(SavePath)) return null; string json = File.ReadAllText(SavePath); return JsonConvert.DeserializeObject<GameSaveData>(json); } }

5.3 网络通信与异步解析

在现代Unity开发中，使用UnityWebRequest或HttpClient进行网络请求时，JSON解析是核心环节。

using System.Threading.Tasks; using UnityEngine.Networking; public async Task<PlayerData> FetchPlayerDataAsync(string playerId) { string url = $"https://api.example.com/player/{playerId}"; using (UnityWebRequest request = UnityWebRequest.Get(url)) { var operation = request.SendWebRequest(); while (!operation.isDone) await Task.Yield(); if (request.result != UnityWebRequest.Result.Success) { Debug.LogError($"Request failed: {request.error}"); return null; } string jsonText = request.downloadHandler.text; // 使用Newtonsoft.Json进行解析 PlayerData data = JsonConvert.DeserializeObject<PlayerData>(jsonText); return data; } }

注意：对于大JSON响应，可以考虑使用JsonTextReader进行流式读取，避免一次性将整个字符串加载到内存中。

5.4 调试与日志输出技巧

清晰的日志能极大提升调试效率。

• 美化输出：无论是JsonUtility.ToJson(obj, true)的prettyPrint参数，还是Newtonsoft.Json的Formatting.Indented，都能生成带缩进的JSON，在日志中一目了然。
• 部分序列化：调试时可能只想看对象的某个部分。可以创建一个只包含所需字段的匿名对象或专门用于调试的DTO。

  // 使用Newtonsoft.Json var debugInfo = new { player.Name, player.Level, InventoryCount = player.Inventory?.Count }; Debug.Log(JsonConvert.SerializeObject(debugInfo, Formatting.Indented));

• 验证JSON格式：在将字符串传给反序列化方法前，如果怀疑其格式，可以粘贴到在线的JSON格式化工具（如 jsonformatter.org）中进行验证。

最后，我个人在长期项目中的体会是：不要试图用一个工具解决所有问题。在项目初期就根据数据复杂度做出技术选型。对于纯粹Unity内部、简单的数据持久化（如编辑器工具配置），JsonUtility足矣。一旦涉及网络、复杂配置、或需要与后端深度交互，Newtonsoft.Json几乎是必然选择。而ListJson那种模式，知道其原理，在阅读或修改旧代码时能看懂就行，在新项目中尽量避免主动使用。保持代码的清晰和可维护性，比一时省事引入的怪异模式要重要得多。