前言

• 关于用litjson来解析json格式的文件，我看过两个教程，第一个并没有讲json的语法原理，只讲了怎么使用。第二个很清晰明了说了数组和对象这个概念
• 但凡是有数组的地方，都可以用list来进行替换
• JSON跟XML一样是一种是数据格式，都是文本文件

Json语法格式

• JSON 使用 JavaScript 语法来描述数据对象，但是 JSON 仍然独立于语言和平台。JSON 解析器和 JSON 库支持许多不同的编程语言。
  • 数据在键值对中
  • 数据由逗号分隔
  • 花括号保存对象
  • 方括号保存数组
• Json由键/值对构成
• 值的类型如下
  JSON 值可以是：
  • 数字（整数或浮点数）
  • 字符串（在双引号中）
  • 逻辑值（true 或 false）
  • 数组（在方括号中）
  • 对象（在花括号中）
  • null
• 简单来说，Json就是对象和数组两种结构，通过不同的组合可以表示很多信息
• 通过键来取值或者赋值
• Json里面的属性名需要和对象的相一致
• Json的根要么是一个数组或者一个对象

JsonData 转化为Json格式字符串

JsonData jd = new JsonData();
jd["Name"] = "myname";
jd["Damage"] = 15;
//打印出来就是Json格式字符串

将Json文本文件转换为list集合【根为数组】

• 第一种方式 直接转换

  List<Weapon> list = JsonMapper.ToObject<List<Weapon>>(File.ReadAllText("WEAPONAll.txt"));

• 第二种方式 先获取JsonData数组对象，然后遍历，取键值对，给对象赋值，最后将对象加入到集合中

  JsonData jsond = JsonMapper.ToObject(File.ReadAllText("WEAPONAll.txt"));

            List<Weapon> list = new List<Weapon>();

            for (int i = 0; i < jsond.Count; i++)
            {
                Weapon weapon = new Weapon();
                weapon.Name = jsond[i]["Name"].ToString();
                weapon.Damage = int.Parse(jsond[i]["Damage"].ToString());
                weapon.Duration = int.Parse(jsond[i]["Duration"].ToString());
                list.Add(weapon);
            }

• 第三种方式 先获得JsonData对象，然后遍历对象数组，将JsonData对象直接转化为相应实体类对象

 JsonData jsond = JsonMapper.ToObject(File.ReadAllText("WEAPONAll.txt"));
            List<Weapon> list = new List<Weapon>();
            for (int i = 0; i < jsond.Count; i++)
            {
                Weapon weapon = JsonMapper.ToObject<Weapon>(jsond[i].ToJson()); //注意这里是转换为Json字符串格式
                list.Add(weapon);
            }

将Json文本文件转换为list集合【 当根是对象时】

   class Weapon
    {

        private List<Weapon> enemy = new List<Weapon>();
        public string Name { set; get; }
        public int Damage { set; get; }
        public int Duration { set; get; }
        public List<Weapon> Enemy { get => enemy; set => enemy = value; }

        public Weapon(string name, int damage, int duration, List<Weapon> list)
        {
            this.Name = name;
            this.Damage = damage;
            this.Duration = duration;
            this.enemy = list;
        }

        public Weapon() { }
        public override string ToString()
        {
            return string.Format("name:{0}-damage{1}-duration{2},listCount{3}", Name, Damage, Duration,Enemy.Count);
        }
    }

• Json字符串

{
  "Name":"jueshi",
"Damage":21,
"Duration":15,
"Enemy":[{"Name":"rifle","Damage":20,"Duration":10},{"Name":"GongJian","Damage":10,"Duration":10},{"Name":"good","Damage":20,"Duration":10}]
}

• 转换步骤

 Weapon wea = JsonMapper.ToObject<Weapon>( File.ReadAllText("WEAPONAll.txt"));
            Console.WriteLine(wea.ToString());
            Console.ReadKey(); //输出结果可以注意到List的count为3

转换为Json格式字符串

• 这个很简单

 string data = JsonMapper.ToJson(weapons);

其它几个例子

• 嵌套的数组

[
    {
        "Type": [
            {
				"ItemID":1,
                "ItemName": "地基"
            },
            {
				"ItemID":2,
                "ItemName": "墙壁"
            },
            {
				"ItemID":3,
                "ItemName": "门"
            },
            {
				"ItemID":4,
                "ItemName": "窗户"
            }
        ]
    },
	{
        "Type": [
            {
				"ItemID":11,
                "ItemName": "弓箭"
            },
            {
				"ItemID":12,
                "ItemName": "长矛"
            }
        ]
    }
]

• 一种解析方法

 public List<List<CraftingContentItem>> ByNameGetJsonData(string name)
    {
        List<List<CraftingContentItem>> temp = new List<List<CraftingContentItem>>();
        string jsonStr = Resources.Load<TextAsset>("JsonData/" + name).text;

        JsonData jsonData = JsonMapper.ToObject(jsonStr);
        for (int i = 0; i < jsonData.Count; i++)
        {
            List<CraftingContentItem> tempList = new List<CraftingContentItem>();
            JsonData jd = jsonData[i]["Type"];
            for (int j = 0; j < jd.Count; j++)
            {
                tempList.Add(JsonMapper.ToObject<CraftingContentItem>(jd[j].ToJson()));
            }
            temp.Add(tempList); //一个数组里面包含对象，每个对象又包含一个数组
        }
        return temp;
    }

• 如果对象里面的某个字符串属性要进行分割

[
    {
        "MapId": 11,
        "MapContents":"0,1,1,1,2,0,0,1,2,1,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0",
		"MapName":"Wooden Bow"
    },
    {
        "MapId": 12,
        "MapContents":"0,0,0,1,2,0,0,0,1,1,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0",
		"MapName":"Wooden Spear"
    }
]

• 一种解析方式

 private Dictionary<int, CraftingMapItem> LoadMapContents(string name)
    {
        Dictionary<int, CraftingMapItem> temp = new Dictionary<int, CraftingMapItem>();
        string jsonStr = Resources.Load<TextAsset>("JsonData/" + name).text;
        JsonData jsonData = JsonMapper.ToObject(jsonStr);
        for (int i = 0; i < jsonData.Count; i++)
        {
           //取临时数据.
           int mapId = int.Parse(jsonData[i]["MapId"].ToString());
           string tempStr = jsonData[i]["MapContents"].ToString();
           string[] mapContents = tempStr.Split(',');
           string mapName = jsonData[i]["MapName"].ToString();
           //构造对象.
           CraftingMapItem item = new CraftingMapItem(mapId, mapContents, mapName);
           temp.Add(mapId, item);
        }
        return temp;
    }

• 最平常的解析方式

[
    {
        "ItemName": "Arrow",
        "ItemNum": 64
    },
    {
        "ItemName": "Torch",
        "ItemNum": 1
    },
    {
        "ItemName": "Axe",
        "ItemNum": 1
    }
]

 public List<InventoryItem> GetJsonList(string fileName)
    {
        List<InventoryItem> tempList = new List<InventoryItem>();
        string tempJsonStr = Resources.Load<TextAsset>("JsonData/" + fileName).text;

        //解析JSON.
        JsonData jsonData = JsonMapper.ToObject(tempJsonStr);
        for (int i = 0; i < jsonData.Count; i++)
        {
            InventoryItem ii = JsonMapper.ToObject<InventoryItem>(jsonData[i].ToJson());
            tempList.Add(ii);
        }

        return tempList;
    }