c#json字符串怎么转数组对象数组对象数组

C# 解析：JSON 字符串如何转换为对象数组与多维数组对象

在现代应用程序开发中，JSON（JavaScript Object Notation）已成为数据交换的事实标准，无论是调用 Web API、读取配置文件，还是处理 NoSQL 数据库，我们都需要在 C# 中处理 JSON 数据，将 JSON 字符串转换为 C# 对象是其中最核心的操作之一，本文将详细探讨如何使用 C# 将 JSON 字符串转换为对象数组，以及更复杂的多维数组对象,并提供清晰的代码示例和最佳实践。

我们将使用 .NET 平台内置的 System.Text.Json 命名空间，这是目前推荐使用的 JSON 处理库，因为它性能高、无依赖且与 .NET 生态无缝集成。

准备工作：定义 C# 模型类

在将 JSON 字符串转换为 C# 对象之前，我们必须先定义一个与 JSON 结构相匹配的 C# 类（或结构体），这个类作为“模板”,用于反序列化过程。

假设我们有以下 JSON 字符串,它表示一个用户列表：

[
  {
    "id": 1,
    "name": "张三",
    "email": "zhangsan@example.com",
    "isActive": true
  },
  {
    "id": 2,
    "name": "李四",
    "email": "lisi@example.com",
    "isActive": false
  }
]

我们需要创建一个 User 类来匹配这个结构：

// User.cs
public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
    public bool IsActive { get; set; }
}

核心要点：

• JSON 的键名（如 "id"）必须与 C# 类的属性名（如 Id）完全匹配（默认情况下不区分大小写，但最佳实践是保持一致）。
• JSON 的值类型会自动映射到 C# 的类型（数字 int/double，字符串 string，布尔值 bool，数组 List<T> 或 T[] 等）。

核心操作：将 JSON 字符串转为对象数组

将 JSON 数组字符串（以 [ 开头和结尾的字符串）转换为 C# 中的对象数组，主要使用 JsonSerializer.Deserialize<T>() 方法，这里的泛型类型 T 应该是对象的集合类型，List<User> 或 User[]。

示例 1：转为 List<T>

List<T> 是最常用、最灵活的集合类型。

using System;
using System.Collections.Generic;
using System.Text.Json;
public class Program
{
    public static void Main()
    {
        // 1. JSON 字符串
        string jsonString = @"
        [
            { ""id"": 1, ""name"": ""张三"", ""email"": ""zhangsan@example.com"", ""isActive"": true },
            { ""id"": 2, ""name"": ""李四"", ""email"": ""lisi@example.com"", ""isActive"": false }
        ]";
        try
        {
            // 2. 反序列化为 List<User>
            List<User> users = JsonSerializer.Deserialize<List<User>>(jsonString);
            // 3. 验证和遍历结果
            if (users != null)
            {
                Console.WriteLine("成功将 JSON 字符串转为 List<User>:");
                foreach (var user in users)
                {
                    Console.WriteLine($"ID: {user.Id}, 姓名: {user.Name}, 邮箱: {user.Email}, 活跃: {user.IsActive}");
                }
            }
        }
        catch (JsonException ex)
        {
            Console.WriteLine($"JSON 反序列化失败: {ex.Message}");
        }
    }
}
// User 类定义
public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
    public bool IsActive { get; set; }
}

输出：

成功将 JSON 字符串转为 List<User>:
ID: 1, 姓名: 张三, 邮箱: zhangsan@example.com, 活跃: True
ID: 2, 姓名: 李四, 邮箱: lisi@example.com, 活跃: False

示例 2：转为数组 T[]

如果你需要一个固定大小的数组，可以直接使用 User[]。

// ... (User 类和 jsonString 同上)
try
{
    // 反序列化为 User[]
    User[] userArray = JsonSerializer.Deserialize<User[]>(jsonString);
    if (userArray != null)
    {
        Console.WriteLine("\n成功将 JSON 字符串转为 User[]:");
        Console.WriteLine($"数组长度: {userArray.Length}");
        Console.WriteLine($"第一个用户: {userArray[0].Name}");
    }
}
catch (JsonException ex)
{
    Console.WriteLine($"JSON 反序列化失败: {ex.Message}");
}

进阶场景：处理多维数组对象

“多维数组对象”这个词可能有两种理解：

1. JSON 本身是一个多维数组（数组的数组）。
2. C# 对象的属性是一个数组或集合。

我们分别来看这两种情况。

场景 1：JSON 是多维数组

一个表示矩阵的 JSON：

[
  [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9]
]

我们可以将其反序列化为 int[,]（二维数组）或 int[][]（交错数组）。

using System;
using System.Text.Json;
public class Program
{
    public static void Main()
    {
        string matrixJson = @"
        [
            [1, 2, 3],
            [4, 5, 6],
            [7, 8, 9]
        ]";
        try
        {
            // 转换为二维数组 int[,]
            int[,] matrix2D = JsonSerializer.Deserialize<int[,]>(matrixJson);
            Console.WriteLine("成功转为二维数组 int[,]:");
            Console.WriteLine(matrix2D[0, 2]); // 输出 3
            // 转换为交错数组 int[][]
            int[][] matrixJagged = JsonSerializer.Deserialize<int[][]>(matrixJson);
            Console.WriteLine("\n成功转为交错数组 int[][]:");
            Console.WriteLine(matrixJagged[1][2]); // 输出 6
        }
        catch (JsonException ex)
        {
            Console.WriteLine($"JSON 反序列化失败: {ex.Message}");
        }
    }
}

场景 2：C# 对象包含数组属性

这是更常见的场景，一个 JSON 对象中,某个字段的值是一个数组。

一个订单对象,其中包含一个商品列表：

{
  "orderId": "ORD-12345",
  "customerName": "王五",
  "items": [
    { "productId": "A101", "productName": "键盘", "quantity": 1 },
    { "productId": "B202", "productName": "鼠标", "quantity": 2 }
  ]
}

我们需要定义 Order 和 Item 两个模型类。

// Item.cs
public class Item
{
    public string ProductId { get; set; }
    public string ProductName { get; set; }
    public int Quantity { get; set; }
}
// Order.cs
public class Order
{
    public string OrderId { get; set; }
    public string CustomerName { get; set; }
    public List<Item> Items { get; set; }
}

然后进行反序列化：

using System;
using System.Collections.Generic;
using System.Text.Json;
public class Program
{
    public static void Main()
    {
        string orderJson = @"
        {
            ""orderId"": ""ORD-12345"",
            ""customerName"": ""王五"",
            ""items"": [
                { ""productId"": ""A101"", ""productName"": ""键盘"", ""quantity"": 1 },
                { ""productId"": ""B202"", ""productName"": ""鼠标"", ""quantity"": 2 }
            ]
        }";
        try
        {
            // 反序列化为单个 Order 对象
            Order order = JsonSerializer.Deserialize<Order>(orderJson);
            if (order != null)
            {
                Console.WriteLine($"订单号: {order.OrderId}, 客户: {order.CustomerName}");
                Console.WriteLine("商品列表:");
                foreach (var item in order.Items)
                {
                    Console.WriteLine($"  - {item.ProductName} (ID: {item.ProductId}), 数量: {item.Quantity}");
                }
            }
        }
        catch (JsonException ex)
        {
            Console.WriteLine($"JSON 反序列化失败: {ex.Message}");
        }
    }
}

输出：

订单号: ORD-12345, 客户: 王五
商品列表:
  - 键盘 (ID: A101), 数量