c#序列化日常操作

       使用C#中的`System.Text.Json`库来序列化和反序列化一个包含字符串的`List<string>`到文件，并通过`FileStream`进行读写操作，可以按照以下步骤实现：

首先，确保已引用了 `System.Text.Json` 命名空间。

using System;

using System.Collections.Generic;

using System.IO;

using System.Text.Json;

public class Program

{

    public static void Main()

    {

        // 创建一个 List<string>

        List<string> list1 = new List<string> { "我", "爱", "学习", "中文", "和地方文化" };

        // 序列化 List 到 JSON 字符串

        string json = JsonSerializer.Serialize(list1);

        // 使用 FileStream 写入到文件

        using (FileStream fs = new FileStream("list.json", FileMode.Create, FileAccess.Write))

        {

            byte[] utf8Json = Encoding.UTF8.GetBytes(json);

            fs.Write(utf8Json, 0, utf8Json.Length);

        }

        // 从文件反序列化 JSON 到 List<string>

        List<string> deserializedList = new List<string>();

        using (FileStream fs = new FileStream("list.json", FileMode.Open, FileAccess.Read))

        {

            // 读取文件内容为内存流

            var streamReader = new StreamReader(fs, Encoding.UTF8);

            string fileContent = streamReader.ReadToEnd();

            // 反序列化 JSON 字符串

            deserializedList = JsonSerializer.Deserialize<List<string>>(fileContent);

        }

        // 输出反序列化后的 List 以验证数据是否正确恢复

        foreach (var item in deserializedList)

        {

            Console.WriteLine(item);

        }

    }

       这段代码首先将列表序列化为JSON格式的字符串，然后将其写入名为“list.json”的文件中。之后打开该文件，读取其内容并反序列化回`List<string>`对象。最后输出反序列化后的列表内容，以确认数据保存与读取的正确性。

        使用 `System.Text.Json` 库对 `List<Person>` 进行序列化和反序列化，并通过 `Stream` 或 `FileStream` 来读写文件。

        使用 `System.Text.Json` 将 `List<Person>` 序列化到一个文件流中，然后从该文件流反序列化回 `List<Person>`：
using System;
using System.Collections.Generic;
using System.IO;
using System.Text.Json;

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

public static void SerializeToFile(List<Person> people)
{
    // 创建 JSON 序列化器选项（如果有需要，可以设置自定义选项）
    var options = new JsonSerializerOptions
    {
        WriteIndented = true, // 可选：格式化输出以便于阅读
    };

    // 使用 FileStream 创建或覆盖目标文件
    using (FileStream stream = new FileStream("people.json", FileMode.Create))
    {
        // 序列化 List<Person> 到 JSON 并写入文件流
        JsonSerializer.Serialize(stream, people, options);
    }
}

public static List<Person> DeserializeFromFile()
{
    List<Person> peopleList = new List<Person>();

    // 使用 FileStream 打开已存在的 JSON 文件
    using (FileStream stream = new FileStream("people.json", FileMode.Open))
    {
        // 从文件流反序列化 JSON 数据到 List<Person>
        peopleList = JsonSerializer.Deserialize<List<Person>>(stream);
    }

    return peopleList;
}

// 示例用法
public static void Main(string[] args)
{
    List<Person> people = new List<Person>
    {
        new Person { FirstName = "John", LastName = "Doe" },
        new Person { FirstName = "Jane", LastName = "Smith" },
    };

    SerializeToFile(people);

    List<Person> deserializedPeople = DeserializeFromFile();

    foreach (var person in deserializedPeople)
    {
        Console.WriteLine($"{person.FirstName} {person.LastName}");
    }
}

      这段代码首先定义了一个 `Person` 类，然后提供了两个静态方法：一个用于将 `List<Person>` 序列化到文件，另一个用于从文件反序列化 `List<Person>`。在实际操作时，确保具有相应的文件访问权限，并且正确处理可能出现的任何异常。

       将数据序列化后进行压缩保存可以减少存储空间，这对于网络传输或本地存储资源有限的情况特别有用。以下是一种使用GZipStream进行压缩和解压缩的简单方法，配合JSON.NET（Newtonsoft.Json）进行序列化的示例：
using System;
using System.IO;
using System.IO.Compression;
using Newtonsoft.Json;

// 假设我们有一个需要序列化并压缩保存的对象
public class MyClass
{
    public string Property1 { get; set; }
    public int Property2 { get; set; }
}

public static class SerializationHelper
{
    // 序列化并压缩对象到一个流
    public static void SerializeAndCompressToStream(MyClass data, Stream outputStream)
    {
        using (var gzip = new GZipStream(outputStream, CompressionLevel.Optimal))
        {
            var json = JsonConvert.SerializeObject(data);
            var bytes = System.Text.Encoding.UTF8.GetBytes(json);

            gzip.Write(bytes, 0, bytes.Length);
        }
    }

    // 从压缩的流中反序列化对象
    public static MyClass DeserializeAndDecompressFromStream(Stream inputStream)
    {
        using (var gzip = new GZipStream(inputStream, CompressionMode.Decompress))
        {
            using (var streamReader = new StreamReader(gzip, System.Text.Encoding.UTF8))
            {
                var jsonString = streamReader.ReadToEnd();
                return JsonConvert.DeserializeObject<MyClass>(jsonString);
            }
        }
    }

    // 示例：将对象序列化并压缩到文件
    public static void SerializeAndCompressToFile(MyClass data, string filePath)
    {
        using (FileStream fileStream = File.Create(filePath))
        {
            SerializeAndCompressToStream(data, fileStream);
        }
    }

    // 示例：从压缩文件中反序列化对象
    public static MyClass DeserializeAndDecompressFromFile(string filePath)
    {
        using (FileStream fileStream = File.OpenRead(filePath))
        {
            return DeserializeAndDecompressFromStream(fileStream);
        }
    }
}

       在这个例子中，`SerializeAndCompressToFile` 方法会将给定的对象序列化为JSON字符串，然后将其压缩并写入指定的文件路径。而 `DeserializeAndDecompressFromFile` 方法则读取压缩文件，解压缩其中的数据，并将其反序列化回原始对象类型。

       注意，这里使用了Json.NET库来处理JSON序列化和反序列化，同时也利用了 .NET Framework 提供的 `System.IO.Compression.GZipStream` 来进行数据压缩与解压操作。

         在C#中，使用`System.Text.Json`进行反序列化时，如果要反序列化的JSON没有对应的目标类，可以利用匿名类型或者动态对象（`System.Text.Json.JsonDocument`或`System.Dynamic.ExpandoObject`）来实现。这里是一个例子，说明如何将JSON反序列化为动态对象：
using System;
using System.Text.Json;

public class Program
{
    public static void Main()
    {
        // JSON字符串
        string json = "{\"Name\":\"John\", \"Age\":30, \"City\":\"New York\"}";

        // 使用JsonSerializer.Deserialize方法和ExpandoObject实现动态反序列化
        var options = new JsonSerializerOptions
        {
            PropertyNameCaseInsensitive = true,
        };

        dynamic obj = JsonSerializer.Deserialize<ExpandoObject>(json, options);

        // 现在可以通过动态属性访问JSON数据
        Console.WriteLine($"Name: {obj.Name}");
        Console.WriteLine($"Age: {obj.Age}");
        Console.WriteLine($"City: {obj.City}");
    }
}
       请注意，`ExpandoObject`允许您以动态方式访问JSON对象的属性，但请确保您使用的.NET版本支持这种用法。

       另一种方法是使用`JsonElement`和`JsonDocument`来解析JSON，并以非面向对象的方式遍历和读取JSON结构：
using System;
using System.Text.Json;

public class Program
{
    public static void Main()
    {
        string json = "{\"Name\":\"John\", \"Age\":30, \"City\":\"New York\"}";

        // 使用JsonDocument解析整个JSON文档
        JsonDocument document = JsonDocument.Parse(json);

        // 获取根元素
        JsonElement rootElement = document.RootElement;

        // 动态读取属性
        Console.WriteLine($"Name: {rootElement.GetProperty("Name").GetString()}");
        Console.WriteLine($"Age: {rootElement.GetProperty("Age").GetInt32()}");
        Console.WriteLine($"City: {rootElement.GetProperty("City").GetString()}");

        // 不再需要document时，释放资源
        document.Dispose();
    }
}

        这种方法不依赖于任何预定义的类结构，但提供了更底层、更直接的方式来处理JSON内容。