在C#中如何使用JSON_开发_开发者_运维开发者技术经验分享

JSON简介

1. 什么是 JSON？

JSON（JavaScript Object Notation）是一种轻量级的数据交换格式。它的语法基于 javascript 对象表示法，简单、易读，同时被许多编程语言支持。尽管它来源于 JavaScript，但它并不依赖于 JavaScript，许多语言（如 python、Java、C#、php 等）都能够解析和生成 JSON。

常见用途：

API 数据交互：在客户端和服务器之间传递数据时，JSON 是常用格式，特别是前后端交互时.

配置文件：许多应用程序使用 JSON 来保存配置文件（例如 .json 文件）。

数据持久化：在数据库或文件系统中使用 JSON 来存储结构化数据。

2. JSON 的基本语法结构

JSON 的数据结构非常简单，主要包括以下两种类型：

对象（Object）：由花括号 {} 包围的一组键值对，键是字符串，值可以是任何合法的 JSON 数据类型。

数组（Array）：由方括号 [] 包围的一组值，值可以是任意 JSON 类型。

示例：

{
  "name": "John",
  "age": 30,
  "isStudent": false,
  "courses": ["Math", "Science"],
  "address": {
    "city": "New York",
    "zipcode": "10001"
  }
}

JSON 的基本元素：

字符串：用双引号包裹，如 "name": "John"

数字：可以是整数或浮点数，如 "age": 30

布尔值：true 或 false

数组：一个有序的值列表，用方括号 [] 包裹

对象：一个无序的键值对集合，用花括号 {} 包裹

空值：null

你不难看出JSON 本质上由三种主要元素构成：

对象（Object）：键值对的集合，类似于字典。JSON 对象用 {} 表示，包含键值对（key-value pairs），键必须是字符串，值可以是任意合法的 JSON 元素（如数组、对象或基本值）。

数组（Array）：有序的元素集合，类似于列表或数组(不代表C#的数组,只是体现一个有序集合)。JSON 数组用 [] 表示，数组中的每个元素可以是任意合法的 JSON 元素（如对象、数组或基本值）。

基本值（Value）：JSON 的最基础元素，可以是字符串、数字、布尔值或 null。这部分数据不能再包含其他子元素。

这很重要:因为充分分析这三种元素自身以及他Pqwfqli们之间的关系是JSON处理的关键.很多JSON库也是考虑了这三种概念实现的.

3. JSON 的优势(作用)

JSON 之所以成为数据交换的首选格式，离不开它的诸多优势：

轻量级：相比于 XML 等格式，JSON 占用的体积更小，结构更为简洁。

可读性好：人类易读，同时解析程序也易于编写。

编程客栈

支持数据类型丰富：可以直接表示对象、数组、字符串、数字、布尔值等常见的数据结构。

广泛支持：几乎所有编程语言都提供了用于解析和生成 JSON 的库或内置函数。

标准化格式：JSON 的格式有明确的标准，确保了跨语言、跨平台的兼容性。

灵活性高：可以嵌套任意复杂的对象和数组，适合复杂的数据结构。

4. JSON 的常见使用场景

API 通信

在现代 Web 开发中，前后端的通信常常依赖于 JSON。客户端发送 HTTP 请求时，通常使用 JSON 格式来传递数据，服务器也通过 JSON 格式返回数据。下面是一个简单的例子：

请求体（客户端向服务器发送的数据）：

{
  "username": "john_doe",
  "password": "123456"
}

响应体（服务器返回的数据）：

{
  "status": "success",
  "message": "Login successful",
  "token": "abcdef123456"
}

配置文件

JSON 格式经常用于存储配置数据，因为它易于阅读和修改。例如，一个应用程序的配置文件可能如下：

{
  "app_name": "MyApp",
  "version": "1.0.0",
  "settings": {
    "theme": "dark",
    "language": "en"
  }
}

本地数据存储

前端开发中，JSON 常被用来在本地存储数据（如浏览器的 localStorage 或 sessionStorage）。

数据序列化

当将对象或数据结构保存到文件或数据库时，通常需要将其序列化为字符串格式，JSON 就是常用的序列化格式之一。

5.JSON和C#类型之间的映射关系

在 C# 中，JSON 的基本元素与相应的数据类型有直接的对应关系。

1. 字符串

JSON：字符串用双引号包裹，表示文本数据。

示例："name": "John"

C# 对应类型：string

在 C# 中，JSON 的字符串类型直接映射为 string 类型。

示例：

string name = "John";

2. 数字

JSON：数字可以是整数或浮点数，表示数值类型的数据。

示例："age": 30

C# 对应类型：int、float、double

在 C# 中，整数可以映射为 int，浮点数可以映射为 float 或 double，根据具体需要选择类型。

示例：

int age = 30;
float price = 29.99f;
double pi = 3.14159;

3. 布尔值

JSON：布尔值表示为 true 或 false。

示例："isStudent": false

C# 对应类型：bool

在 C# 中，布尔值映射为 bool 类型。

示例：

bool isStudent = false;

4. 数组

JSON：数组是一个有序的值列表，用方括号 [] 包裹，数组中的每个元素可以是任意 JSON 类型。

示例："courses": ["Math", "Science"]

C# 对应类型：List<T> 或数组 T[]

在 C# 中，JSON 数组可以映射为 List<T>（泛型列表）或者普通数组 T[]，其中 T 是数组中元素的类型。

示例：

List<string> courses = new List<string> { "Math", "Science" };
// 或者
string[] coursesArray = { "Math", "Science" };

5. 对象

JSON：对象是一个无序的键值对集合，用花括号 {} 包裹，每个键必须是字符串，值可以是任意 JSON 类型。

示例："address": { "city": "New York", "zipcode": "10001" }

C# 对应类型：自定义类或 Dictionary<string, T>

在 C# 中，JSON 对象可以映射为自定义类，类中的属性对应 JSON 对象中的键值对。也可以使用 Dictionary<string, T> 来表示键值对集合，其中 T 表示值的类型。

示例（使用自定义类）：

class Address
{
    public string City { get; set; }
    public string Zipcode { get; set; }
}
Address address = new Address { City = "New York", Zipcode = "10001" };

示例（使用字典）：

Dictionary<string, string> address = new Dictionary<string, string>
{
    { "city", "New York" },
    { "zipcode", "10001" }
};

6. 空值

JSON：空值表示为 null。

示例："middleName": null

C# 对应类型：null

在 C# 中，JSON 的 null 对应 C# 中的 null 值。它可以应用于任何可空类型（如引用类型和 Nullable<T>）。

在 C# 中，JSON 的基本元素可以映射为相应的 C# 数据类型。这种映射使得我们可以轻松处理 JSON 数据，并与 C# 中的对象和类型进行交互。

6. 如何处理 JSON 数据

什么是序列化/反序列化

我们首先要先铺垫一下什么是序列化/反序列化

序列化和反序列化是将对象和数据在不同格式之间转换的过程，主要用于数据持久化、网络传输等场景.在C#中我们的数据一般以对象形式存储在内存中,但是内存数据不能持久保存,你关机后或者程序关闭时数据就没了,那我们怎么把数据保存下来呢?

答案就是序列化,我们常用的就是将对象序列化为JSON(当然不止JSON,只是JSON更常用),这样我们再将其(这个其说的更清晰点就是字符串,JSON绝大多数情况是以字符串形式出现的,只不过你可以理解为是一种有一定格式或一定规则的字符串)保存在磁盘或者通过网络传递给其他人都很方便.

理所当然的JSON转换为内存中的对象就是反序列化,常见的情景就是读取JSON格式的配置文件,先从磁盘读取出来再反序列化为对象,我们就可以十分方便的操作这个对象了.

怎么做?

大多数编程语言都提供了用于解析（反序列化）和生成（序列化）JSON 数据的库或内置函数。

C# 提供了 System.Text.Json 和 Newtonsoft.Json（第三方库）来处理 JSON。

我建议使用Newtonsoft.Json(NuGet Gallery | Newtonsoft.Json 13.0.3),这可以说是C#环境里最流行,最强大的一个库,经过二十年左右的发展支持绝大多数.net环境,目前在所有nuget包中下载量中排名第一.

常见用法

1. 使用 JsonConvert.SerializeObject 方法可以将 C# 对象转换为 JSON 字符串。

using Newtonsoft.Json;
public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    public bool IsStudent { get; set; }
}
Person person = new Person { Name = "John", Age = 30, IsStudent = false };
// 序列化为 JSON
string json = JsonConvert.SerializeObject(person);
Console.WriteLine(json);

得到(这就是一个字符串,包括首尾的花括号在内,前面提到{}代表一个对象,里面是无序的键值对)

{"Name":"John","Age":30,"IsStudent":false}

2. 使用 JsonConvert.DeserializeObject<T> 可以将 JSON 字符串反序列化为 C# 对象。

//这里的\是转义符,不是字符串自身的内容
string json = "{\"Name\":\"John\",\"Age\":30,\"IsStudent\":false}";
// 反序列化为对象
Person person = JsonConvert.DeserializeObject<Person>(json);
Console.WriteLine(person.Name);  // 输出 "John"
Console.WriteLine(person.Age);   // 输出 30

3. 将 JSON 数组转换为 C# 集合（如 List<T>）。

string jsonArray = "[{\"Name\":\"John\",\"Age\":30},{\"Name\":\"Jane\",\"Age\":25}]";
// 反序列化为 List<Person>
List<Person> people = JsonConvert.DeserializeObject<List<Person>>(jsonArray);
foreach (var person in people)
{
    Console.WriteLine($"{person.Name}, {person.Age}");
}

John, 30
Jane, 25

4. 处理嵌套对象

如果 JSON 中包含嵌套对象，Newtonsoft.Json 可以自动反序列化嵌套结构。

public class Address
{
    public string City { get; set; }
    public string Zipcode { get; set; }
}
public class Person
{
    public string Name { get; set; }
    public Address Address { get; set; }
}
string nestedJson = "{\"Name\":\"John\",\"Address\":{\"City\":\"New York\",\"Zipcode\":\"10001\"}}";
// 反序列化嵌套的 JSON
Person person = JsonConvert.DeserializeObject<Person>(nestedJson);
Console.WriteLine($"{person.Name} lives in {person.Address.City}, {person.Address.Zipcode}");

5.JToken,JObject,JArray,JValue

上面提到JSON的基本组成元素:对象,数组,基本值,这对应看newtonjson提供的JObject,JArray,JValue三种类型,编程哪还有一个JToken,这个JToken是三种类型抽象类型,后三者继承自前者.

为什么提到这些类呢?因为更灵活!

你注意上面例子,我们处理一个JSON需要先声明一个类型,有的时候我们声明了这个类型可能极少使用,那么这个时候我们声明一个类型似乎就有些没必要了.

或者这个JSON数据的结构不是固定的,或是动态的的情况下.所以我们使用上面的类型.

string jsonString = "{\"name\": \"Alice\", \"age\": 25}";
// 使用 JObject 解析
JObject obj = JObject.Parse(jsonString);
// 动态访问字段
string name = (string)obj["name"];
int age = (int)obj["age"];
Console.WriteLine($"Name: {name}, Age: {age}");

请看JSON代表一个对象,如果不常用这个类型,那么我们直接认为它是一个JObject类型.这样我们转为JObject类型,再使用索引器直接拿到我们需要的数据.

上述我们知道这是一个对象,所以我们使用JObject类型,那么我们连这个也不知道呢?无妨!掏出我们的JToken类型,这个类型是三个子类的父类,包含所有子类的行为,能够代表所有的JSON概念,无论它是对象,数组,还是基本值.

        
using Newtonsoft.Json.Linq;
string jsonString = @"{
    'person': {
        'name': 'Alice',
        'age': 25,
        'address': {
            'city': 'Wonderland',
            'zipcode': '12345'
        },
        'phones': ['123-456-7890', '987-654-3210']
    }
}";
// 解析为 JToken
JToken token = JToken.Parse(jsonString);
// 动态访问嵌套字段
string name = (string)token["person"]["name"];
string city = (string)token["person"]["address"]["city"];
string phone = (string)token["person"]["phones"][0];
Console.WriteLine($"Name: {name}, City: {city}, First Phone: {phone}");

using Newtonsoft.Json.Linq;
string jsonString = @"{
    'name': 'Alice',
    'age': 25,
    'address': {
        'city': 'Wonderland',
        'zipcode': '12345'
    },
    'hobbies': ['reading', 'chess', 'running']
}";
// 使用 JToken 解析
JToken token = JToken.Parse(jsonString);
// 动态访问对象中的字段
string name = (string)token["name"];
int age = (int)token["age"];
// 动态访问嵌套对象
string city = (string)token["address"]["city"];
string zipcode = (string)token["address"]["zipcode"];
// 动态访问数组中的元素
string firstHobby = (string)token["hobbies"][0];
string secondHobby = (string)token["hobbies"][1];
// 输出结果
Console.WriteLine($"Name: {name}, Age: {age}");
Console.WriteLine($"City: {city}, Zipcode: {zipcode}");
Console.WriteLine($"First Hobby: {firstHobby}, Second Hobby: {secondHobby}");

类型转换(对于JToken或它的子类)

Newtonsoft.Json 不仅支持通过类型强制转换访问 JSON 数据，还提供了更加便捷的方法来进行类型转换。这些方法能够避免类型强制转换时潜在的异常风险，并提供更清晰的代码表达。

Newtonsoft.Json 提供了以下常用的类型转换方法

1.Value<T>() 方法(适用于基本类型)

Value<T&javascriptgt;() 是 JToken 提供的一个泛型方法，能够安全地将 JToken 的值转换为指定的类型。如果类型转换失败，它不会抛出异常，而是返回类型的默认值。

适用于想要避免显式的类型强制转换，并且希望代码更简洁、安全的场景。

JToken token = JToken.Parse(@"{ 'name': 'Alice', 'age': 25 }");
string name = token["name"].Value<string>(); // 安全的类型转换
int age = token["age"].Value<int>(); // 转换为 int
Console.WriteLine($"Name: {name}, Age: {age}");

使用 Value<T>() 进行转换时，如果值不存在或者转换失败，它会返回类型的默认值（如 string 会返回 null，int 会返回 0），不会像类型强制转换那样抛出异常。

2.ToObject<T>() 方法

ToObject<T>() 是另一个常用的方法，允许将 JToken 转换为一个具体的对象或类型。它适用于你希望将 JSON 数据反序列化为 C# 的具体类型（如类或结构体）的场景。

ToObject<T>() 方法通过反序列化来进行转换，因此适合用于复杂的数据结构转换。

// 定义一个类与 JSON 数据对应
public class Person
{
public string Name { get; set; }
public int Age { get; set; }
}
JToken token = JToken.Parse(@"{ 'name': 'Alice', 'age': 25 }");
// 将 JToken 反序列化为具体的 Person 对象
Person person = token.ToObject<Person>();
Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");

适合处理复杂的 JSON 数据结构，能够将整个 JSON 结构直接转换为一个 C# 对象。

它的灵活性使得你可以轻松地从 JSON 数据中创建 C# 类对象，而不用手动提取每一个字段。

3.TryGetValue<T>(out T result) 方法

这是一个较为安全的访问方式，TryGetValue 尝试从 JToken 中获取指定类型的值，并通过返回布尔值来指示是否成功获取。

它适合在不确定 JSON 数据结构或类型时，安全地进行转换操作，避免抛出异常。

JToken token = JToken.Parse(@"{ 'name': 'Alice', 'age': 'not an integer' }");
// 尝试安全获取值
int age;
bool success = token["age"].TryGetValue<int>(out age);
if (success)
{
Console.WriteLine($"Age: {age}");
}
else
{
Console.WriteLine("Failed to get a valid integer for age.");
}

安全的类型转换方式，适合在 JSON 数据不可靠或结构复杂时使用。

它通过 out 参数来返回结果，能够避免异常。

强制类型转换 vs 提供的方法

强制类型转换（Explicit Casting）

允许直接进行强制类型转换，比如 (string)token["name"] 或 (int)token["age"]。这种方式比较简洁，但是如果类型不匹配或值不存在，会抛出异常。