Unity Json 数据解析

老规矩，直接上代码：

远古方法

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using UnityEngine;

/// <summary>
/// Json 数据解析
/// </summary>

public class JsonAnalysis_ZH : MonoBehaviour
{
    //Json 数据 所存在的路径 
    private string _JsonPath;

    private void Start()
    {

         //_JsonPath = Application.streamingAssetsPath + "/Json.json";

        //_JsonPath=Resources.Load("Json.json")
        //StartCoroutine(WriteJson());
        StartCoroutine(ReadJson());
    }

    /// <summary>
    /// Json 写入
    /// </summary>
    public IEnumerator WriteJson()
    {
        //如果当前路径不存在
        if (!File.Exists(_JsonPath))
        {
            //就及进行创建
            File.Create(_JsonPath);
        }
        //Json 数据类创建
        JsonData _JsonData = new JsonData();
        //Json 数据信息
        _JsonData._MessageData = new List<MessageData>();

        //存储 相关数据信息
        for (int i = 0; i < 100; i++)
        {
            MessageData _PlayerData = new MessageData();
            _PlayerData._Number = i;
            _PlayerData._Message = i.ToString();
            _PlayerData._Precision = i + 100;

            //存储 Json 数组数据
            _JsonData._MessageData.Add(_PlayerData);

        }

        //Json 数据转换
        string _Json = JsonUtility.ToJson(_JsonData, true);
        //写入 Json 文件
        File.WriteAllText(_JsonPath, _Json);

        //开启 Json 读取 协程
        //StartCoroutine(ReadJson());

        yield return 0;
    }

    /// <summary>
    /// Json 读取
    /// </summary>
    public IEnumerator ReadJson()
    {
        //延迟执行协程
        yield return new WaitForSeconds(2);

        // 读取 Json 文件 转换为 Strin 字符串
        string _Json = File.ReadAllText(_JsonPath);

        //Json 数据类 创建
        JsonData _JsonData = new JsonData();
        //Json 数据 转换
        _JsonData = JsonUtility.FromJson<JsonData>(_Json);


        _JsonData = JsonUtility.FromJson<JsonData>(File.ReadAllText(JsonUtility.ToJson(Resources.Load("Json"))));
        //print();
        //读取存储 相关信息 
        for (int i = 0; i < _JsonData._MessageData.Count; i++)
        {
            print(_JsonData._MessageData[i]._Number);
            print(_JsonData._MessageData[i]._Message);
            print(_JsonData._MessageData[i]._Precision);
        }


        //Json 数据WebGL 数据加载
        //Json 数据类 创建
        JsonData _JsonDataWeb = new JsonData();
        _JsonDataWeb = JsonUtility.FromJson<JsonData>(Resources.Load<TextAsset>("Json").ToString());
        //读取存储 相关信息 
        for (int i = 0; i < _JsonDataWeb._MessageData.Count; i++)
        {
            print(_JsonDataWeb._MessageData[i]._Number);
            print(_JsonDataWeb._MessageData[i]._Message);
            print(_JsonDataWeb._MessageData[i]._Precision);
        }
    }
}

/// <summary>
/// 序列化
/// </summary>
// 数据存储类
[Serializable]
public class MessageData
{

    public int _Number;         //数量
    public string _Message;     //信息
    public float _Precision;    //精度


}

//Json  数据类
[Serializable]
public class JsonData
{
    public List<MessageData> _MessageData;
}

不那么远古的方法

Json  数据操作：读、写、删除

using System.Collections;
using System.Collections.Generic;
using System.IO;
using UnityEngine;

/// <summary>
/// Json  数据操作
/// </summary>
public class JsonData_ZH
{

    /// <summary>
    /// 数据写入
    /// </summary>
    /// <param 文件存储名字="_SaveFileName"></param>
    /// <param 存储数据="_Data"></param>
    public static void SaveByJson(string _SaveFileName, object _Data)
    {
        //数据转换为Json 格式
        var _Json = JsonUtility.ToJson(_Data);
        //填写相对路径以及 文件名字
        var _Path = Path.Combine(Application.persistentDataPath, _SaveFileName);


        //异常捕获
        try
        {
            //数据文件写入
            File.WriteAllText(_Path, _Json);

            Debug.Log($"数据保存到{_Path}成功。");
        }
        catch (System.Exception _Exception)
        {

#if UNITY_EDITOR
            Debug.LogError($"数据保存到{_Path}失败。\n{_Exception}");
#endif

        }
    }

    /// <summary>
    /// Json数据加载
    /// </summary>
    /// <typeparam 加载文件类型="T"></typeparam>
    /// <param 数据加载名字="_SaveFileName"></param>
    /// <returns></returns>
    public static T LoadFromJson<T>(string _SaveFileName)
    {
        //填写相对路径以及 文件名字
        var _Path = Path.Combine(Application.persistentDataPath, _SaveFileName);

        try
        {
            //地址读取
            var _Json = File.ReadAllText(_Path);
            //数据加载
            var _Data = JsonUtility.FromJson<T>(_Json);
            //数据返回
            return _Data;
        }
        catch (System.Exception _Exception)
        {

#if UNITY_EDITOR
            Debug.LogError($"数据从{_Path}加载失败。\n{_Exception}");
#endif

            return default;
        }
    }

    /// <summary>
    /// 数据删除
    /// </summary>
    /// <param 数据名称="_SaveFileName"></param>
    public static void DeleteSaveFile(string _SaveFileName)
    {
        //填写相对路径以及 文件名字
        var _Path = Path.Combine(Application.persistentDataPath, _SaveFileName);



        try
        {

            File.Delete(_Path);
        }
        catch (System.Exception _Exception)
        {

#if UNITY_EDITOR
            Debug.LogError($"无法删除{_Path}数据。\n{_Exception}");
#endif

        }
    }


}

数据 操作 应用

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class PlayerData_ZH : MonoBehaviour
{

    //数据文件名称
    private const string PLAYER_DATA_FILE_NAME = "PlayerDataName.sav";

    //需要存储的变量
    private Transform _Tra;
    private string _Name;
    private int _Value;
    private float _Float;
    private Vector3 _Vector3;

    private void Update()
    {
        if (Input.GetKeyDown(KeyCode.Q))
        {
            //保存 Json 数据
            JsonData_ZH.SaveByJson(PLAYER_DATA_FILE_NAME, SavingData());

            //加载Json 数据
            var _SaveJson= JsonData_ZH.LoadFromJson<PlayerJson>(PLAYER_DATA_FILE_NAME);

            LoadeData();

            //删除Json数据存档
            JsonData_ZH.DeleteSaveFile(PLAYER_DATA_FILE_NAME);

        }
    }

    //本地数据存储
    public PlayerJson SavingData()
    {
        var _PlayerJson = new PlayerJson();

        _PlayerJson._Tra = _Tra;
        _PlayerJson._Name = _Name;
        _PlayerJson._Value = _Value;
        _PlayerJson._Float = _Float;
        _PlayerJson._Vector3 = _Vector3;

        return _PlayerJson;
    }

    //本地数据加载
    public PlayerJson LoadeData()
    {
        var _PlayerJson = new PlayerJson();

        _Tra = _PlayerJson._Tra;
        _Name = _PlayerJson._Name;
        _Value = _PlayerJson._Value;
        _Float = _PlayerJson._Float;
        _Vector3 = _PlayerJson._Vector3;

        return _PlayerJson;
    }

}



/// <summary>
/// Json  数据
/// </summary>
[System.Serializable]
public  class  PlayerJson
{
    public Transform _Tra;

    public string _Name;

    public int _Value;

    public float _Float;

    public Vector3 _Vector3;

}

暂时先这样吧，如果实在看不明白就留言，看到我会回复的。
路长远兮，与君共勉。