c# 解析json，对对象进行序列化和反序列化

1.使用System.Runtime.Serialization.Json

（1）

using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;
using System.Text;

[DataContract]
public class Person
{
    [DataMember(Name = "name")]
    public string Name { get; set; }

    [DataMember(Name = "age")]
    public int Age { get; set; }

    [DataMember(Name = "isStudent")]
    public bool IsStudent { get; set; }

    [DataMember(Name = "courses")]
    public List<string> Courses { get; set; }
}

class Program
{
    static void Main()
    {
        Person person = new Person
        {
            Name = "张三",
            Age = 30,
            IsStudent = false,
            Courses = new List<string> { "语文", "数学", "英语" }
        };

        // 序列化
        string jsonString = SerializeToJson(person);
        Console.WriteLine("序列化后的JSON字符串： " + jsonString);

        // 反序列化
        Person deserializedPerson = DeserializeFromJson<Person>(jsonString);
        Console.WriteLine($"姓名： {deserializedPerson.Name}, 年龄： {deserializedPerson.Age}, 是否为学生： {deserializedPerson.IsStudent}, 课程： {string.Join(", ", deserializedPerson.Courses)}");
    }

    static string SerializeToJson(object obj)
    {
        MemoryStream stream = new MemoryStream();
        DataContractJsonSerializer serializer = new DataContractJsonSerializer(obj.GetType());
        serializer.WriteObject(stream, obj);
        stream.Position = 0;
        StreamReader reader = new StreamReader(stream);
        return reader.ReadToEnd();
    }

    static T DeserializeFromJson<T>(string jsonString)
    {
        MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(jsonString));
        DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(T));
        return (T)serializer.ReadObject(stream);
    }
}

序列化后的JSON字符串： {"age":30,"courses":["语文","数学","英语"],"isStudent":false,"name":"张三"}
姓名： 张三, 年龄： 30, 是否为学生： False, 课程： 语文, 数学, 英语

在这个例子中，我们定义了一个Person类，并使用DataContract和DataMember特性来标记需要序列化和反序列化的属性。然后，我们创建了一个Person对象，并使用SerializeToJson方法将其序列化为JSON字符串。接着，我们使用DeserializeFromJson方法将JSON字符串反序列化为Person对象。最后，我们输出反序列化后的数据。

（2）

在C#中，虽然System.Runtime.Serialization.Json命名空间通常与WCF（Windows Communication Foundation）紧密相关，并且主要用于在WCF服务中处理JSON数据，但你也可以在非WCF环境中使用它来进行JSON的序列化和反序列化。然而，需要注意的是，System.Runtime.Serialization.Json的API并不像Newtonsoft.Json（也称作Json.NET）那样广泛被使用或具有灵活的API。

如果你决定使用System.Runtime.Serialization.Json来进行序列化和反序列化，以下是一个基本的示例来说明如何实现这一点。

using System;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;
using System.IO;
using System.Runtime.Serialization.Json;
using System.Text;

namespace Test
{
    //定义一个可序列化的类，确保类标记为[DataContract]，并且想要序列化的每个属性都标记为[DataMember]
    [DataContract]
    public class Person
    {
        [DataMember]
        public string Name { get; set; }

        [DataMember]
        public int Age { get; set; }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Person person = new Person { Name = "John Doe", Age = 30 };
            string json = SerializeToJson(person);
            Console.WriteLine(json);
            Person deserializedPerson = DeserializeFromJson(json);
            Console.WriteLine($"Name: {deserializedPerson.Name}, Age: {deserializedPerson.Age}");
        }

        //反序列化
        public static Person DeserializeFromJson(string json)
        {
            DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(Person));
            using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(json)))
            {
                return (Person)serializer.ReadObject(ms);
            }
        }

        //序列化
        public static string SerializeToJson(Person person)
        {
            DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(Person));
            using (MemoryStream ms = new MemoryStream())
            {
                serializer.WriteObject(ms, person);
                ms.Position = 0;
                using (StreamReader reader = new StreamReader(ms))
                {
                    return reader.ReadToEnd();
                }
            }
        }
    }
}

{"Age":30,"Name":"John Doe"}
Name: John Doe, Age: 30

注意事项

• 使用System.Runtime.Serialization.Json时，你的类必须标记为[DataContract]，并且所有要序列化的属性都必须标记为[DataMember]。
• 相对于Newtonsoft.Json，System.Runtime.Serialization.Json的API较为有限，可能不支持一些高级特性，如自定义序列化逻辑、动态类型处理等。
• 如果你在一个大型项目或需要灵活处理JSON的场景中，建议使用Newtonsoft.Json或.NET Core内置的System.Text.Json。

总的来说，System.Runtime.Serialization.Json虽然可以在C#中用于JSON的序列化和反序列化，但在大多数情况下，更推荐使用Newtonsoft.Json或.NET Core的System.Text.Json。

2.使用System.Text.Json

在C#中，System.Text.Json 是一个高性能的JSON库，它是从.NET Core 3.0开始引入的，并在.NET 5及更高版本中得到了进一步的改进和增强。与Newtonsoft.Json（Json.NET）相比，System.Text.Json提供了更快的性能和更低的内存占用，同时它是.NET Core和.NET 5/6/7等较新版本中推荐使用的JSON处理库。

如果你的项目是基于 .NET Core 或 .NET 5/6/7（或更高版本），那么 System.Text.Json 应该已经作为框架的一部分被包含在内了。但是，如果你的项目是基于 .NET Framework，你可能需要手动添加 System.Text.Json 的 NuGet 包

首先，你需要一个可序列化的类。不过，与System.Runtime.Serialization.Json不同，System.Text.Json不需要特别的属性标记（如[DataContract]和[DataMember]），但它会依赖于公共属性和字段的可见性来进行序列化。

using System.Text.Json;
using System.Text.Json.Serialization;

namespace Test
{
    //创建一个可序列化的类，按照公共属性和字段的可见性来进行序列化。
    public class Person
    {
        public string Name { get; set; }
        public int Age { get; set; }
    }
    public class Test
    {
        public static void Main(string[] args)
        {
            //序列化
            Person person = new Person { Name = "John Doe", Age = 30 };
            string jsonString = JsonSerializer.Serialize(person);
            Console.WriteLine(jsonString);

            // 反序列化
            //调用JsonSerializer.Deserialize方法，并指定要反序列化的JSON字符串和目标类型
            Person deserializedPerson = JsonSerializer.Deserialize<Person>(jsonString);
            Console.WriteLine($"Name: {deserializedPerson.Name}, Age: {deserializedPerson.Age}");
        }

        //在序列化时，如果你想要忽略所有空值（null）的属性，可以使用JsonSerializerOptions。
        //var options = new JsonSerializerOptions
        //{
        //    IgnoreNullValues = true
        //};
        //string jsonString = JsonSerializer.Serialize(person, options);

        //为了更易于阅读，你可能想要以缩进的格式输出JSON。
        //var options = new JsonSerializerOptions
        //{
        //    WriteIndented = true
        //};
        //string jsonString = JsonSerializer.Serialize(person, options);

        // 使用自定义转换器  
        //var options = new JsonSerializerOptions
        //{
        //    Converters = { new CustomDateTimeConverter() }
        //};

        // 假设Person类有一个DateTime类型的属性  
        // ...



    }

    //自定义序列化/反序列化，对于更复杂的场景，比如需要自定义某些属性的序列化逻辑，你可以实现JsonConverter接口。
    public class CustomDateTimeConverter : JsonConverter<DateTime>
    {
        public override DateTime Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            // 自定义反序列化逻辑  
            throw new NotImplementedException();
        }

        public override void Write(Utf8JsonWriter writer, DateTime value, JsonSerializerOptions options)
        {
            // 自定义序列化逻辑，例如格式化日期时间  
            writer.WriteStringValue(value.ToString("yyyy-MM-dd"));
        }
    }
}

{"Name":"John Doe","Age":30}
Name: John Doe, Age: 30

3.第三方库解析（Newtonsoft.Json）