C#实现的序列化通用类实例

介绍

在C#中，序列化是将对象转换为流的过程，以便将其存储在磁盘或通过网络传输。反序列化则是将对象流转换回对象的过程。序列化通用类是一个可以将对象序列化为数据流或从数据流中反序列化的类，它可用于序列化不同类型的对象。

实现过程

1. 创建配置文件（可选）

在整个应用程序中，配置文件非常重要，它包含着我们程序的基本配置信息。序列化通用类也可以使用配置文件来节省程序内部实现，例如常用的XML格式来存放序列化器的基本配置属性（比如类型、命名空间、加密等），再在软件初始化时读取到内存中，这样使得程序的调整、升级和实现相对容易和快捷。

1. 构建类库文件

构建一个序列化通用的类库文件，例如创建一个名为Serializations类库。该类库文件中包含了一些基础的序列化方法，还可以根据具体需求添加自定义的方法。

1. 序列化通用类的基本方法

在序列化通用类中，创建基本的序列化和反序列化方法，可用以下代码实现：

public static byte[] Serialize<T>(T obj)
{
    if (obj == null)
    {
        return null;
    }
    using (MemoryStream ms = new MemoryStream())
    {
        BinaryFormatter binaryFormatter = new BinaryFormatter();
        binaryFormatter.Serialize(ms, obj);
        return ms.ToArray();
    }
}

public static T Deserialize<T>(byte[] bytes)
{
    if (bytes == null)
    {
        return default(T);
    }
    using (MemoryStream ms = new MemoryStream(bytes))
    {
        BinaryFormatter binaryFormatter = new BinaryFormatter();
        object obj = binaryFormatter.Deserialize(ms);
        return (T)obj;
    }
}

代码中使用了 BinaryFormatter 类将对象序列化成二进制数据，并使用内存流将序列化后的二进制数据写入到内存中。反序列化也同样使用 BinaryFormatter 类将内存流中的二进制数据转换成对象。

1. 自定义序列化和反序列化方法

如果需要实现自定义的序列化和反序列化方法，可以继承IFormatter接口，并实现Serialize方法和Deserialize方法，如下所示：

public class MyFormatter : IFormatter
{
    public SerializationBinder Binder { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
    public StreamingContext Context { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
    public ISurrogateSelector SurrogateSelector { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }

    public object Deserialize(Stream serializationStream)
    {
        throw new NotImplementedException();
    }

    public void Serialize(Stream serializationStream, object graph)
    {
        throw new NotImplementedException();
    }
}

使用时只需要将MyFormatter类添加到序列化通用类即可自定义序列化和反序列化方法。

1. 示例

下面是两个简单的示例说明如何使用序列化通用类：

（1）创建一个Person类，包含Name，Age两个属性，及构造函数。

public class Person 
{
    public string Name { get; set; }
    public int Age { get; set; }

    public Person(string name, int age) 
    {
        this.Name = name;
        this.Age = age;         
    } 
}

在项目中需要序列化这个对象，可以先定义一个这个类型的对象，然后使用序列化类库的Serialize方法序列化，并可以通过反序列化类库的DeSerialize方法来获取该对象。

Person person = new Person("Tom", 28);
byte[] bytes = Serializations.Serialize<Person>(person);
Person newPerson = Serializations.Deserialize<Person>(bytes);

（2）创建一个Animal基类，包含一个属性Name，及ToString方法，创建两个子类Dog，Cat。

public class Animal 
{
    public string Name { get; set; }
    public Animal(string name) 
    {
        this.Name = name;
    } 

    public override string ToString()
    {
        return $"Name:{this.Name}";
    }
}

public class Dog : Animal 
{
    public int Age { get; set; }
    public Dog(string name, int age) : base(name)
    {
        this.Age = age;
    }
    public override string ToString()
    {
        return $"{base.ToString()},Age:{this.Age}";
    }
}

public class Cat : Animal 
{
    public bool IsCute { get; set; }
    public Cat(string name, bool isCute) : base(name)
    {
        this.IsCute = isCute;
    }
    public override string ToString()
    {
        return $"{base.ToString()},IsCute:{this.IsCute}";
    }
}

在项目中需要序列化这个对象，可以先定义一个这个类型的对象列表，使用序列化类库的Serialize方法序列化，并可以通过反序列化类库的DeSerialize方法来获取该对象列表。

List<Animal> animalList = new List<Animal>();
animalList.Add(new Dog("Spike", 3));
animalList.Add(new Cat("Tom", true));
byte[] bytes = Serializations.Serialize<List<Animal>>(animalList);
List<Animal> newAnimalList = Serializations.Deserialize<List<Animal>>(bytes);

结论

通过本文分析可以看到C#实现的序列化通用类非常方便且实用，可以用于快速实现串行化和反串行化过程，同时还支持自定义功能和属性，并且灵活扩展。