C#序列化与反序列化集合对象并进行版本控制详解

共计 4155 个字符，预计需要花费 11 分钟才能阅读完成。

当涉及到跨进程甚至是跨域传输数据的时候，我们需要把对象序列化和反序列化。

首先可以使用 Serializable 特性。

[Serializable]
public class Person
{
    public string _firstName;
    public string _secondName;
    // 序列化
    [OnSerializing]
    internal void OnSerializing(StreamingContext context)
    {_firstName = _firstName.ToUpper();
        _secondName = _secondName.ToUpper();}
    // 反序列化
    [OnDeserialized]
    internal void OnDeserialized(StreamingContext context)
    {_firstName = _firstName.ToLower();
        _secondName = _secondName.ToLower();}
}

当然，也可以实现 ISerializable 接口。在接口方法 GetObjectData 完成序列化，把信息保存到 SerializationInfo 中，在构造函数中反序列化，把信息从 SerializationInfo 中读取出来。

[Serializable]
 public class Person : ISerializable
 {
     public string _firstName;
     public string _secondName;
     public Person()
     { }
     // 反序列化
     public Person(SerializationInfo si, StreamingContext context)
     {_firstName = si.GetString("first").ToLower();
         _secondName = si.GetString("second").ToLower();}
     // 序列化
     public void GetObjectData(SerializationInfo info, StreamingContext context)
     {info.AddValue("first", _firstName.ToUpper());
         info.AddValue("second",_secondName.ToUpper());
     }
 }

下面的类，描述了对象的第一个版本。

[Serializable]
public class SomeClass : ISerializable
{
    private int a;
    public SomeClass(){}
    public SomeClass(SerializationInfo info, StreamingContext context)
    {a = info.GetInt32("myval");
    }
    public void GetObjectData(SerializationInfo, StreamingContext context)
    {info.AddValue("VERSION",1);
         info.AddValue("myval", a);
    }
}

现在 SomeClass 要增加一个私有字段，成为版本二。

[Serializable]
public class SomeClass : ISerializable
{
    private int a;
    private string b;
    public SomeClass(){}
    public SomeClass(SerializationInfo info, StreamingContext context)
    {int VERSION = info.GetInt32("VERSION");
        a = info.GetInt32("a");
        if(VERSION > 1)
        {b = info.GetString("another");
        }
        else
        {b = "默认值";}
    }
    public void GetObjectData(SerializationInfo, StreamingContext context)
    {info.AddValue("VERSION",2);
         info.AddValue("myval", a);
         info.AddValue("another", b);
    }
}

如果一个集合对象需要实现序列化和反序列化，那么集合元素对象必须可以被序列化和反序列化，并且集合元素对象中的对象属性也必须可以被序列化和反序列化，依此类推。

[Serializable]
public class Car : ISerializable
{
    private string _model;
    private int _year;
    private Owner _owner;
    public Car()
    { }
    public Car(SerializationInfo info, StreamingContext context)
    {this._model = (string) info.GetValue("Model", typeof (string));
        this._year = (int) info.GetValue("Year", typeof (int));
        this._owner = (Owner) info.GetValue("Owner", typeof (Owner));
    }
    public void GetObjectData(SerializationInfo info, StreamingContext context)
    {info.AddValue("Model",this._model);
        info.AddValue("Year", this._year);
        info.AddValue("Owner", this._owner);
    }
}
[Serializable]
public class Owner : ISerializable
{
    private string _name;
    public Owner()
    { }
    public Owner(SerializationInfo info, StreamingContext context)
    {this._name = (string) info.GetValue("Name", typeof (string));
    }
    public void GetObjectData(SerializationInfo info, StreamingContext context)
    {info.AddValue("Name", this._name);
    }
}

以上，我们想序列化 Car 的集合到文件中，再反序列化 Cars 的集合读取出来。那么，我们必须让 Car 可以被序列化和反序列化，Car 的属性对象 Owner 也必须可以被序列化和反序列化。

接着，用来封装 Car 集合的一个类。

[Serializable]
public class CarsList : ISerializable
{private List _cars;
    public List Cars
    {get { return this._cars;}
        set {this._cars = value;}
    }
    public CarsList()
    { }
    public CarsList(SerializationInfo info, StreamingContext context)
    {this._cars = (List) info.GetValue("Cars", typeof (List));
    }
    public void GetObjectData(SerializationInfo info, StreamingContext context)
    {info.AddValue("Cars", this._cars);
    }
}

针对 CarsList 写一个序列化和反序列化的帮助类。

public class SerializerHelper
{public SerializerHelper()
    { }
    // 序列化
    public void SerializeObject(string fileName, CarsList carsList)
    {
        // 根据文件名打开流
        Stream stream = File.Open(fileName, FileMode.Create);
        BinaryFormatter bFormatter = new BinaryFormatter();
        // 把对象序列化到流中
        bFormatter.Serialize(stream,carsList);
        stream.Close();}
    // 反序列化
    public CarsList DeserializeObject(string fileName)
    {
        CarsList carsList;
        // 根据文件名打开流
        Stream stream = File.Open(fileName, FileMode.Open);
        BinaryFormatter bfFormatter = new BinaryFormatter();
        carsList = (CarsList)bfFormatter.Deserialize(stream);
        stream.Close();
        return carsList;
    }
}

在客户端按如下调用：

static void Main(string[] args)
{List cars = new List();
    CarsList carsList = new CarsList();
    carsList.Cars = cars;
    SerializerHelper serializerHelper = new SerializerHelper();
    serializerHelper.SerializeObject(@"temp.txt", carsList);
    carsList = serializerHelper.DeserializeObject(@"temp.txt");
    cars = carsList.Cars;
}

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值

阿里云 2 核 2G 服务器 3M 带宽 61 元 1 年，有高配

腾讯云新客低至 82 元 / 年，老客户 99 元 / 年

代金券：在阿里云专用满减优惠券