首页 前端知识 在C#中使用JSON

在C#中使用JSON

2024-11-04 10:11:05 前端知识 前端哥 880 684 我要收藏

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。这部分数据不能再包含其他子元素。

这很重要:因为充分分析这三种元素自身以及他们之间的关系是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>() 是 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"]。这种方式比较简洁,但是如果类型不匹配或值不存在,会抛出异常。

总结

Value<T>() 方法:提供了安全的类型转换方式,不会抛出异常,适合处理简单的数据访问场景,代码简洁。

 

ToObject<T>() 方法:适合将 JSON 直接转换为 C# 对象,特别是对于复杂的 JSON 结构,能够减少手动提取每个字段的工作量。

 

TryGetValue<T>() 方法:提供一种安全的方式来获取 JSON 数据中的值,适合在不确定数据结构或类型的情况下使用,防止异常的发生。

 

转载请注明出处或者链接地址:https://www.qianduange.cn//article/19959.html
标签
评论
发布的文章

在C#中使用JSON

2024-11-04 10:11:05

JSON串

2024-11-04 10:11:57

JSON教程(非常详细)

2024-05-08 10:05:36

大家推荐的文章
会员中心 联系我 留言建议 回顶部
复制成功!