C#再谈序列化和反序列化

来源：互联网发布：淘宝上的军品是真的么编辑：程序博客网时间：2024/06/02 02:20

public IQueryable<V_Store> GetV_StoreWhere(Expression<Func<V_Store, bool>> Predicate)
        {
            DBEntities db = new DBEntities();
            var vdb = db.V_Store.Where(Predicate.Compile());
            return vdb.AsQueryable();

}

在Silverlight开发中，Domainservice需要复杂的查询，但是委托，对象数组凡是不能被序列化都不能传递。

反而常见的序列化的对象，以及值类型可以传递，例如STRING ,DOUBLE,等等，不能满足我们的需要。

利用XML反序列化读取数据库记录(转载)

c#Tips(转载)

C#序列化(转载)

2008-10-15 11:30:39| 分类： C# | 标签： |字号大中小订阅

序列化有下列要求:
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);
   }

}