C#序列化(转载)
2011-03-15 | 凯之风 | 转藏(2)
序列化有下列要求:
A> 只序列化PUBLIC的成员变量和属性
B> 类必须有默认识构造函数
C> 如果类没实现自定义序列化(2)，那么将按默认方式序列化(1)
D> XmlSerializer不能用于序列化任何实现了IDictionary接口的类的实体，比方说Hashtable。但SoapFormatter和BinaryFormatter没有这个限制。 所以在XML序列化过程中要用[XmlIgnore]标记其不被序列化
1>基本序列化
通过[Serializable]标记，标识该类可序列化
[Serializable]
public class MyObject {
public int n1 = 0;
public int n2 = 0;
public String str = null;
}
1.1序列化成文件
1.1.1 二进制的序列化和反序列化
//序列化
MyObject obj = new MyObject();
obj.n1 = 1;
obj.n2 = 24;
obj.str = "一些字符串";
IFormatter formatter = new BinaryFormatter();
Stream stream = new FileStream("MyFile.bin", FileMode.Create,
FileAccess.Write, FileShare.None);
formatter.Serialize(stream, obj);
stream.Close();
//反序列化
IFormatter formatter = new BinaryFormatter();
Stream stream = new FileStream("MyFile.bin", FileMode.Open,
FileAccess.Read, FileShare.Read);
MyObject obj = (MyObject) formatter.Deserialize(fromStream);
stream.Close();
1.1.2 XML序列化和反序列化
上面的代码换成SoapFormatter即可以生成XML
1.2选择性序列化
[Serializable]
public class MyObject
{
public int n1;
[NonSerialized]
//标记N2不序列化
public int n2;
public String str;
private int n3;
[NonSerialized]//对属性无效
[XmlIgnore]//标记该属性在XML序列化的过程中不序列化
public int N3
{
get{return n3;}
set{n3=value;}
}
}
注意:当类成员变量中出现不能被序列化的类或接口时候我们要通过
[NonSerialized] 只针对成员变量
[XmlIgnore] 针对成员变量和属性,只针对XML序列化
标记其不被序列化和反序列化
特别注意:要使某属性在XML序列化过程中不被序列化只能使用[XmlIgnore],[NonSerialized]无效
2>自定义序列化
为了解决1中序列化过程中会出现某些成员变量序列化过程中数据丢失的显现，
可采用自定义的序列化
[Serializable]
public class MyObject : ISerializable
{
public int n1;
public int n2;
public String str;
public MyObject()
{
}
protected MyObject(SerializationInfo info, StreamingContext context)
{
n1 = info.GetInt32("i");
n2 = info.GetInt32("j");
str = info.GetString("k");
}
public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
{
info.AddValue("i", n1);
info.AddValue("j", n2);
info.AddValue("k", str);
}
}
其派生类也必须实现上面的接口方法
[Serializable]
public class ObjectTwo : MyObject
{
public int num;
public ObjectTwo() : base()
{
}
protected ObjectTwo(SerializationInfo si, StreamingContext context) : base(si,context)
{
num = si.GetInt32("num");
}
public override void GetObjectData(SerializationInfo si, StreamingContext context)
{
base.GetObjectData(si,context);
si.AddValue("num", num);
}
}
切记要在反序列化构造函数中调用基类，否则，将永远不会调用基类上的构造函数，并且在反序列化后也无法构建完整的对象。
3>WEB 服务中的序列化
WEB 服务返回对象时候会自动把该对象进行XML序列化
因此，一个类要想在WEB 服务上传递必须可XML序列化
public class Test : WebService {
[WebMethod()]
public DateTime EchoString([XmlElement(DataType="string")]
string strval) {
return DateTime.Now;
}
//通过XmlInclude声明序列化过程中相关的类信息
[WebMethod()]
[XmlInclude(typeof(Car)), XmlInclude(typeof(Bike))]
public Vehicle Vehicle(string licenseNumber) {
if (licenseNumber == "0") {
Vehicle v = new Car();
v.licenseNumber = licenseNumber;
return v;
}
else if (licenseNumber == "1") {
Vehicle v = new Bike();
v.licenseNumber = licenseNumber;
return v;
}
else {
return null;
}
}
}
//通过XmlRoot指定序列化的ROOT描述信息
[XmlRoot("NewVehicle")]
public abstract class Vehicle {
public string licenseNumber;
public DateTime make;
}
public class Car : Vehicle {
}
public class Bike : Vehicle {
}
4>两个通用的序列化函数------来自Enterprise Lib 配置模块
public override object Serialize(object value)
{
XmlSerializer xmlSerializer = CreateXmlSerializer(value.GetType());
StringWriter stringWriter = new StringWriter(CultureInfo.InvariantCulture);
XmlTextWriter xmlTextWriter = new XmlTextWriter(stringWriter);
XmlDocument doc = new XmlDocument();
try
{
xmlTextWriter.WriteStartElement("xmlSerializerSection");
xmlTextWriter.WriteAttributeString("type", value.GetType().AssemblyQualifiedName);
xmlSerializer.Serialize(xmlTextWriter, value);
xmlTextWriter.WriteEndElement();
xmlTextWriter.Flush();
doc.LoadXml(stringWriter.ToString());
}
finally
{
xmlTextWriter.Close();
stringWriter.Close();
}
return doc.DocumentElement;
}
public override object Deserialize(object section)
{
XmlNode sectionNode = (XmlNode)section;
XmlNode serializationNode = sectionNode.SelectSingleNode("//xmlSerializerSection");
if (serializationNode == null)
{
throw new ConfigurationException(SR.ExceptionNotInSerializedObj);
}
XmlAttribute typeAttribute = serializationNode.Attributes["type"];
if (typeAttribute == null)
{
throw new ConfigurationException(SR.ExceptionSerializationTypeMissing);
}
string typeName = typeAttribute.Value;
Type classType = null;
try
{
classType = Type.GetType(typeName, true);
}
catch (TypeLoadException ex)
{
throw new ConfigurationException(SR.ExceptionTypeCreateError(typeName), ex);
}
catch (FileNotFoundException ex)
{
throw new ConfigurationException(SR.ExceptionTypeCreateError(typeName), ex);
}
if (serializationNode.ChildNodes.Count == 0)
{
throw new ConfigurationException(SR.ExceptionSerializedObjectMissing);
}
XmlSerializer xs = CreateXmlSerializer(classType);
try
{
return xs.Deserialize(new XmlNodeReader(serializationNode.ChildNodes[0]));
}
catch (InvalidOperationException e)
{
string message = e.Message;
if (null != e.InnerException)
{
message = String.Concat(message, " ", e.InnerException.Message);
}
throw new ConfigurationException(message, e);
}
}