C#中Json的序列化与反序列化使用

前言

在我们开发应用程序的过中，或多或不的需要记录一些配置信息；使用Json可以快速将我们程序中的对象信息保存在文件中，程序启动后又可以快速通过文件恢复原来的配置信息；当然了，我们也可以使用INI文件，但这个配置方式的文件读写是没有Json方便的。

一、效果展示

1、序列化对至Json

2、字符串转对象

3、读取文件并转换对象

4、读取Json文件

5、通过Json创建字符串

二、代码展示

1、创建对象

        public static Inventory GetInventoryObject() =>
            new Inventory
            {
                InventoryItems = new Product[]
                {
                    new Product
                    {
                        ProductID=100,
                        ProductName="Product Thing",
                        SupplierID=10000,
                        CategoryID=99,
                         Discount=98,
                         QuantityPerUnit="个",
                         UnitInStock=10
                    },
                    new BookProduct
                    {
                        ProductID = 101,
                        ProductName = "How To Use Your New Product Thing",
                        SupplierID = 20000,
                        CategoryID=100,
                        Discount=95,
                         QuantityPerUnit="本",
                         UnitInStock=100,

                        ISBN = "1234567890"
                    }
                }
            };

2、序列化对至Json

      public static void SerializeJson()
      {
          using (StreamWriter writer = File.CreateText(InventoryFileName))
          {
              JsonSerializer serializer = JsonSerializer.Create(new JsonSerializerSettings { Formatting = Formatting.Indented });
              serializer.Serialize(writer, GetInventoryObject());
          }
      }

3、字符串转对象

 public static void ConvertObject()
 {
     Inventory inventory = GetInventoryObject();
     string json = JsonConvert.SerializeObject(inventory, Formatting.Indented);
     Console.WriteLine(json);
     Console.WriteLine();
     Inventory newinventory = JsonConvert.DeserializeObject<Inventory>(json);
     foreach (var item in newinventory.InventoryItems)
     {
         Console.WriteLine(item.ProductName);
     }
 }

4、读取文件并转换对象

    public static void DeserializeJson()
    {
        using (StreamReader reader = File.OpenText(InventoryFileName))
        {
            JsonSerializer serializer = JsonSerializer.Create();
            var inventory = serializer.Deserialize(reader, typeof(Inventory)) as Inventory;
            foreach (var item in inventory.InventoryItems)
            {
                Console.WriteLine(item.ProductName);
            }
        }
    }

5、读取Json文件

 public static void ReaderSample()
 {
     StreamReader reader = File.OpenText(InventoryFileName);
     using (JsonTextReader jsonReader = new JsonTextReader(reader) { CloseInput = true })
     {
         while (jsonReader.Read())
         {
             Console.WriteLine($"token: {jsonReader.TokenType}");
             if (!string.IsNullOrEmpty(jsonReader.Path))
             {
                 Console.WriteLine($"path: {jsonReader.Path}");
             }
             if (!string.IsNullOrEmpty(jsonReader.Value?.ToString()))
             {
                 Console.WriteLine($"value: {jsonReader.Value}");
             }
             Console.WriteLine();
         }
     }
 }

6、通过Json创建字符串

private static void CreateJson()
{
    var book1 = new JObject();
    book1["title"] = "Professional C# 7 and .NET Core 2.0";
    book1["publisher"] = "Wrox Press";
    var book2 = new JObject();
    book2["title"] = "Professional C# 6 and .NET Core 1.0";
    book2["publisher"] = "Wrox Press";
    var books = new JArray();
    books.Add(book1);
    books.Add(book2);

    var json = new JObject();
    json["books"] = books;
    Console.WriteLine(json);
}

7、重要函数

/// <summary>
/// 将指定的 System.IO.TextReader 包含的 JSON 结构反序列化为指定类型的实例。
/// </summary>
  public object? Deserialize(TextReader reader, Type objectType)
  {
      return Deserialize(new JsonTextReader(reader), objectType);
  }

/// <summary>
/// 序列化指定的 System.Object 并使用指定的 System.IO.TextWriter 编写 JSON 结构。
/// </summary>
public void Serialize(TextWriter textWriter, object? value)
{
    Serialize(new JsonTextWriter(textWriter), value);
}

当然这两个函数有一些重载，可以根据使用场景灵活选择。