一、数据类型的等效性
例如下面定义的两个类成员名称、定义顺序都不一样，但是在DataContract、DataMember的Name属性作用下，两个类的实例对象序列化后的xml是一样的，因此Order和OrderV2对于DataContractSerializer序列化是等效的。
[DataContract]
public class Order
{
[DataMember]
public int price;
[DataMember(Name = "datev2")]
public DateTime date;
}
[DataContract(Name = "Order")]
public class OrderV2
{
[DataMember]
public DateTime datev2;
[DataMember(Name = "price")]
public int PriceV2;
}
二、数据添加导致的不一致
假设客户端定义的是OrderLess，服务端定义的是OrderMore。客户端会基于OrderLess进行序列化后发送到服务端。服务端会基于OrderMore反序列化来自客户端的OrderLess序列化后的消息，能序列化成功，但是会发现缺少Name的值。
[DataContract(Name="Order")]
public class OrderLess
{
[DataMember]
public int Price;
[DataMember]
public DateTime Date;
}
[DataContract(Name = "Order")]
public class OrderMore
{
[DataMember]
public DateTime Date;
[DataMember]
public int Price;
[DataMember]
public string Name;
}
此时如果我们想对这个缺失的值设置一个默认值，可以通过注册序列化回调方法实现。
OnDeserialized : 在对象反序列化后立即调用。
OnDeserializing ：反序列化对象之前调用。
OnSerialized : 在序列化后调用此。
OnSerializing ：在序列化前调用。
对OrderMore修改后如下：
[DataContract(Name = "Order")]
public class OrderMore
{
[DataMember]
public DateTime Date;
[DataMember]
public int Price;
[DataMember]
public string Name;
[OnDeserializing]
void OnSerializing(StreamingContext context)
{
this.Name="未指定";
}
}
Main函数：
static void Main(string[] args)
{
OrderLess less=new OrderLess();
less.Date=DateTime.Now;
less.Price=8;
Serialize(less,@"D:\1.txt");
OrderMore more=null;
DeSerialize(@"D:\1.txt",out more);
Console.WriteLine("{0} {1} {2}",more.Date,more.Price,more.Name);
}
public static void Serialize(T t, string path)
{
DataContractSerializer ser = new DataContractSerializer(typeof(T));
using (XmlTextWriter writer = new XmlTextWriter(path, Encoding.UTF8))
{
writer.Formatting = Formatting.Indented;
ser.WriteObject(writer, t);
}
}
public static void DeSerialize(string path, out T t)
{
DataContractSerializer ser = new DataContractSerializer(typeof(T));
using (XmlReader reader = new XmlTextReader(path))
{
t = (T)ser.ReadObject(reader);
}
}
输出：
三、数据删除导致的不一致
与二中的交换一下，客户端定义的是OrderMore，服务端定义的是OrderLess。客户端基于OrderMore类型的序列化器序列化OrderMore对象，服务端按基于OrderLess的序列化器反序列化来自客户端的OrderMore的消息。服务端也能序列化成功，但是当服务端将这个对象返回给客户端时，客户端那边会发现少了Name值。为了避免这种情况发生，OrderLess可以实现IExtensibleDataObject接口。作用是将反序列化时未知的数据存放到ExtensionData，再次对这个对象序列化时就可以还原这些未知对象。
对OrderLess进行修改：
[DataContract(Name="Order")]
public class OrderLess:IExtensibleDataObject
{
[DataMember]
public int Price;
[DataMember]
public DateTime Date;
public ExtensionDataObject ExtensionData
{
get;set;
}
}
Main函数模拟客户端和服务端的交互过程，先序列化OrderMore，再反序列化为OrderLess，此时将未知的Name属性放在OrderLess的ExtensionData。再次序列化这个OrderLess对象。发现1.txt和2.txt的序列化内容是一样的。
static void Main(string[] args)
{
OrderMore more = new OrderMore();
more.Date = DateTime.Now;
more.Price = 8;
more.Name = "OrderMore";
Serialize(more, @"D:\1.txt");
OrderLess less = null;
DeSerialize(@"D:\1.txt", out less);
Serialize(less, @"D:\2.txt");
}
四、数据契约代理
在上述描述都是数据成员添加或删除这种小差异。当两个对象差异很大时(如下面的A和B)，却想让两个对象序列化时等效，需要数据契约代理来做一些工作。
[DataContract]
public class A
{
[DataMember]
public string FullName;
[DataMember]
public int age;
}
[DataContract]
public class B
{
[DataMember]
public string FirstName;
[DataMember]
public string LastName;
[DataMember]
public int age;
}
MatchA2B实现IDataContractSurrogate接口，在DataContractSerializer序列化过程中能够将一个A对象序列化为B对象，将B对象反序列化为A对象。需要实现GetDataContractType方法，获取需要序列化的实际类型。GetObjectToSerialize序列化前的转换，GetDeserializedObject序列化后的转换。
public class MatchA2B : IDataContractSurrogate
{
public Type GetDataContractType(Type type)
{
return type == typeof(A) ? typeof(B) : type;
}
public object GetObjectToSerialize(object obj, Type targetType)
{
A a=obj as A;
if (a != null)
{
B b = new B();
b.age = a.age;
b.FirstName = a.FullName.Split(" ".ToCharArray())[0];
b.LastName = a.FullName.Split(" ".ToCharArray())[1];
return b;
}
return obj;
}
public object GetDeserializedObject(object obj, Type targetType)
{
B b = obj as B;
if (b != null)
{
A a = new A();
a.FullName = b.FirstName + " " + b.LastName;
a.age = b.age;
return a;
}
return obj;
}
public object GetCustomDataToExport(Type clrType, Type dataContractType){return null;}
public object GetCustomDataToExport(System.Reflection.MemberInfo memberInfo, Type dataContractType){return null;}
public void GetKnownCustomDataTypes(System.Collections.ObjectModel.Collection customDataTypes){ }
public Type GetReferencedTypeOnImport(string typeName, string typeNamespace, object customData){return null;}
public System.CodeDom.CodeTypeDeclaration ProcessImportedType(System.CodeDom.CodeTypeDeclaration typeDeclaration, System.CodeDom.CodeCompileUnit compileUnit)
{ return null; }
}
Main函数：
class Program
{
static void Main(string[] args)
{
A a = new A();
a.FullName = "Leonardo DiCaprio";
a.age = 41;
Serialize(a, @"D:\1.txt");
A b = null;
DeSerialize(@"D:\1.txt", out b);
Console.WriteLine("{0} {1} ", b.FullName, b.age);
}
public static void Serialize(T t, string path)
{
DataContractSerializer ser = new DataContractSerializer(typeof(T),null,int.MaxValue,false,false,new MatchA2B());
using (XmlTextWriter writer = new XmlTextWriter(path, Encoding.UTF8))
{
writer.Formatting = Formatting.Indented;
ser.WriteObject(writer, t);
}
}
public static void DeSerialize(string path, out T t)
{
DataContractSerializer ser = new DataContractSerializer(typeof(T), null, int.MaxValue, false, false, new MatchA2B());
using (XmlReader reader = new XmlTextReader(path))
{
t = (T)ser.ReadObject(reader);
}
}
}
1.txt中的内容为，成功的将A对象序列化为B：
Leonardo
DiCaprio
41