前一段时间因为频繁使用类的序列化,所以一直在思考如何能更方便的使用这个功能,现在把一段时间的学习过程和大家分享,同时还有个疑问向大家请教,如果您已经非常熟悉类的序列化,那么请您直接看第三部分。
什么是类的序列化?说白了,就是把一个类的实例转化成一段XML格式或二进制格式的数据,以便于网络传输、保存等操作。
同理,反序列化就是把XML或者二进制描述的对象还原成一个类的实例。
零、开始序列化
在C#中,要实现类的序列化并不难,以XML序列化为例,首先我们声明一个类:
[Serializable]
public class myClass
{
......
}
其中类声明上面的一句[Serializable]用来指示此类是可以序列化的,然后
引用两个namespace:
using System.IO;
using System.Xml.Serialization;
于是就可以执行下面代码:
2 myClass cls = new myClass();
3 XmlSerializer xmlSerializer = new XmlSerializer(cls.GetType());
4 MemoryStream stream = new MemoryStream();
5 xmlSerializer.Serialize(stream, cls);
6 byte [] buf = stream.ToArray();
7 string xml = Encoding.ASCII.GetString(buf);
8 stream.Close();
自此,序列化就完成了,XML序列保存在string xml;变量中。
上述代码不难理解,XmlSerializer类用来提供XML序列化的功能,xmlSerializer.Serialize(stream, cls)方法,可以把类cls序列化,并将XML序列存储在流stream中。
以上便是序列化的基本方法,可以满足我们的需求。但问题是如果我们经常需要对数个类进行序列化和反序列化,就要频繁的重复上述代码,能不能让类具备自己进行序列化的方法呢?
一、第一次尝试
我首先想到,可以写一个基类,提供进行序列化的方法,任何想实现序列化的类,只需要继承此类就可以具备此方法。于是构造抽象类:
2 {
3 public virtual string XMLSerialize()
4 {
5 XmlSerializer xmlSerializer = new XmlSerializer(GetType()); // 差异1
6 MemoryStream stream = new MemoryStream();
7 xmlSerializer.Serialize(stream, this ); // 差异2
8 byte [] buf = stream.ToArray();
9 string xml = Encoding.ASCII.GetString(buf);
10 stream.Close();
11 return xml;
12 }
13 }
上面一段代码和之前的代码只有两行不一样:
差异1:
cls.GetType()变成GetType():其中GetType()是获取当前实例的类型,在基类中调用GetType()得到的是当前实例的类型,而不是积累的类型。也就是说上述基类中调用GetType()不会得到” SerializableBaseClass”,更不会是”System.Object”,而是当前对象实例的类型。
差异2:
cls变成this:同理,this引用是指向当前实例的,只不过在基类中,不能使用this直接访问子类成员。当然通过类型转换可以达到此目的,但不在本文讨论范围内。所以Serialize(stream,this)会将整个对象序列化,而不会造成对象分割,只把基类给序列化了。
二、第二次尝试
到此为止,任何类只要集成了SerializableBaseClass就拥有了自我序列化的方法,但如何反序列化呢?我们在SerializableBaseClass类中再添加一个方法。
2 {
3 XmlSerializer xmlSerializer = new XmlSerializer(GetType());
4 byte [] buf = Encoding.ASCII.GetBytes(xmlString);
5 MemoryStream stream = new MemoryStream(buf);
6 object o = xmlSerializer.Deserialize(stream);
7 return o;
8 }
此方法就实现了类的反序列化,我们可以这样使用:
声明:
[Serializable]
public class myClass : SerializableBaseClass
{
……
}
使用:
2 string xml = cls. Serialize();
3 myClass cls1 = (myClass)cls. DeSerialize(xml);
这个使用乍一看没什么问题,但实际使用起来就很蹩脚
1、要想反序列化一个类,先要创建这个类的实例,只为了调用DeSerialize()
2、调用DeSerialize()返回的是object类型,需要进行类型转换
对于这两个问题,我也考虑过很久,如果把DeSerialize()定义为static,那么就不能使用GetType()方法,而其,也无法获取子类的类型。
三、最后的尝试
对于上述两个问题,想了很久,始终没想到解决办法,直到一天和朋友讨论c++STL的某个问题的时候,终于茅塞顿开,c#也是支持模板的呀,于是激动不已,改写SerializableBaseClass类:
2 public abstract class SerializableBaseClass < T >
3 {
4 public virtual string XMLSerialize()
5 {
6 XmlSerializer xmlSerializer = new XmlSerializer(GetType());
7 MemoryStream stream = new MemoryStream();
8 xmlSerializer.Serialize(stream, this );
9 byte [] buf = stream.ToArray();
10 string xml = Encoding.ASCII.GetString(buf);
11 stream.Close();
12 return xml;
13 }
14
15 public static T DeSerialize( string xmlString)
16 {
17 XmlSerializer xmlSerializer = new XmlSerializer( typeof (T));
18 byte [] buf = Encoding.ASCII.GetBytes(xmlString);
19 MemoryStream stream = new MemoryStream(buf);
20 T o = (T)xmlSerializer.Deserialize(stream);
21 return o;
22 }
23 }
24
这样,问题就不完美的解决了(确实不完美)。为什么不完美呢?那就看下面的代码:
[Serializable]
public class myClass : SerializableBaseClass<myClass>
{
……
}
使用:
myClass cls = myClass.DeSerialize(xmlData);
看似上述问题都解决了,但我还是心里不爽,因为每次定义一个继承SerializableBaseClass的类,还必须把自己的类名再写一遍,放在模板类型的参数里。有没有一种方案,可以让上述myClass类的声明默认模板参数就是自身myClass,而无须再写一遍<myClass>呢?或者还有更好的其他方法?欢迎讨论。
上述的所有代码,包括二进制序列化的方法,我已经做成了c#库,欢迎大家使用、指正,互相学习。
http://www.cnblogs.com/icyplayer/archive/2009/01/08/1372097.html
XmlSerializer 泄漏:.NET Framework 中的某些部分(例如 XmlSerializer)会在内部使用动态代码生成。请看下列典型的 XmlSerializer 代码:
XmlSerializer serializer = new XmlSerializer(typeof(Person)); serializer.Serialize(outputStream, person);
XmlSerializer 构造函数将使用反射来分析 Person 类,并藉此生成一对由 XmlSerializationReader 和 XmlSerializationWriter 派生而来的类。它将创建临时的 C# 文件,将结果文件编译成临时程序集,并最终将该程序集加载到进程。通过这种方式生成的代码同样需要相当大的开销。因此 XmlSerializer 对每种类型的临时程序集进行缓存。也就是说,下一次为 Person 类创建 XmlSerializer 时,会使用缓存的程序集,而不再生成新的程序集。
默认情况下,XmlSerializer 所使用的 XmlElement 名称就是该类的名称。因此,Person 将被序列化为:
<?xml version="1.0" encoding="utf-8"?> <Person xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> <Id>5d49c002-089d-4445-ac4a-acb8519e62c9</Id> <FirstName>John</FirstName> <LastName>Doe</LastName> </Person>
有时有必要在不改变类名称的前提下改变根元素的名称。(要与现有架构兼容可能需要根元素名称。)因此 Person 可能需要被序列化为 <PersonInstance>。XmlSerializer 构造函数能够很方便地被重载,将根元素名称作为第二参数,如下所示:
XmlSerializer serializer = new XmlSerializer(typeof(Person), new XmlRootAttribute("PersonInstance"));
当应用程序开始对 Person 对象进行序列化/反序列化时,一切运转正常,直至引发 OutOfMemoryException。对 XmlSerializer 构造函数的重载并不会对动态生成的程序集进行缓存,而是在每次实例化新的 XmlSerializer 时生成新的临时程序集。这时应用程序以临时程序集的形式泄漏非托管内存。
要修复该泄漏,请在类中使用 XmlRootAttribute 以更改序列化类型的根元素名称:
[XmlRoot("PersonInstance")] public class Person { // code }
如果直接将属性赋予类型,则 XmlSerializer 对为类型所生成的程序集进行缓存,从而避免了内存的泄漏。如果需要对根元素名称进行动态切换,应用程序能够利用工厂对其进行检索,从而对 XmlSerializer 实例自身进行缓存。
XmlSerializer serializer = XmlSerializerFactory.Create( typeof(Person), "PersonInstance");
XmlSerializerFactory 是我创建的一个类,它可以使用 PersonInstance 根元素名称来检查 Dictionary<Tkey, Tvalue> 中是否包含有用于 Person 的 Xmlserializer。如果包含,则返回该实例。如果不包含,则创建一个新的实例,并将其存储在哈希表中返回给调用方。
from:http://hi.baidu.com/gotosky/blog/item/aa8717d52d246dc251da4ba0.html