我们知道将对象的状态保持在存储媒体中，以便可以在以后重新创建精确的副本这正是数据持久化所要做的。而且，不同应用程序之间的通讯需要相互传输数据。那么序列化和反序列化正是为此而生。
序列化和反序列化
所谓序列化就是把对象转换为字节序列的过程称为对象的序列化。
所谓反序列化就是字节序列恢复为对象的过程称为对象的反序列化
那么.net开发中都为我们提供了哪些序列化和反序列化的方式呢?我简单总结了一下，有以下几种：
1.位于System.Xml.Serialization命名空间下的XmlSerializer
2.位于System.Runtime.Serialization.Formatters.Soap命名空间下的SoapFormatter
3.位于System.Runtime.Serialization.Formatters.Binary;命名空间下的BinaryFormatter
4.位于System.Web.Script.Serialization命名空间下的JavaScriptSerializer
5.位于System.Runtime.Serialization.Json命名空间下的DataContractJsonSerializer、DataContractSerializer
6.位于System.Runtime.Serialization命名空间下的NetDataContractSerializer
7.来自第三方的Newtonsoft.Json
那么我简单地写了个序列化帮助类。完整代码如下(它们都有各自的使用场合,用法也不止如此)：
namespace Serialization
{
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Serialization.Formatters.Soap;
using System.Runtime.Serialization.Json;
using System.Text;
using System.Web.Script.Serialization;
using System.Xml.Serialization;
using Newtonsoft.Json;
public class SerializeHelper
{
#region XmlSerializer
public static void XmlSerialize(string fileName, object obj)
{
using (FileStream fs = new FileStream(fileName, FileMode.Create, FileAccess.Write, FileShare.Write))
{
try
{
XmlSerializer serializer = new XmlSerializer(obj.GetType());
serializer.Serialize(fs, obj);
}
catch (Exception e)
{
throw e;
}
}
} public static T XmlDeSerialize<T>(string fileName) where T : class,new()
{
using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read))
{
try
{
XmlSerializer serializer = new XmlSerializer(typeof(T));
return serializer.Deserialize(fs) as T;
}
catch (Exception e)
{
throw e;
}
}
}
#endregion #region SoapFormatter
//不支持泛型 所序列化的类型必须标志为Serializable
public static void SoapSerialize(string fileName, object obj)
{
using (FileStream fs = new FileStream(fileName, FileMode.Create, FileAccess.Write, FileShare.Write))
{
try
{
SoapFormatter formatter = new SoapFormatter();
formatter.Serialize(fs, obj);
}
catch (Exception e)
{
throw e;
}
}
} public static T SoapDeSerialize<T>(string fileName) where T : class, new()
{
using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read))
{
try
{
SoapFormatter formatter = new SoapFormatter();
return formatter.Deserialize(fs) as T;
}
catch (Exception e)
{
throw e;
}
}
}
#endregion #region BinaryFormatter
//所序列化的类型必须标志为Serializable
public static void BinarySerialize(string fileName, object obj)
{
using (FileStream fs = new FileStream(fileName, FileMode.Create, FileAccess.Write, FileShare.Write))
{
try
{
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize(fs, obj);
}
catch (Exception e)
{
throw e;
}
}
} public static T BinaryDeSerialize<T>(string fileName) where T : class, new()
{
using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read))
{
try
{
BinaryFormatter formatter = new BinaryFormatter();
return formatter.Deserialize(fs) as T;
}
catch (Exception e)
{
throw e;
}
}
}
#endregion #region JavaScriptSerializer
public static string JavaScriptSerialize(object obj)
{
JavaScriptSerializer serizlizer = new JavaScriptSerializer();
return serizlizer.Serialize(obj);
} public static T JavaScriptDeSerialize<T>(string json) where T : class, new()
{
JavaScriptSerializer serizlizer = new JavaScriptSerializer();
return serizlizer.Deserialize<T>(json);
}
#endregion #region DataContractJsonSerializer
/// <summary>
/// (DataContractJsonSerialize)序列化
/// </summary>
/// <param name="item">对象</param>
public static string DataContractJsonSerialize(object obj)
{
DataContractJsonSerializer serializer = new DataContractJsonSerializer(obj.GetType());
using (MemoryStream ms = new MemoryStream())
{
serializer.WriteObject(ms, obj);
return Encoding.UTF8.GetString(ms.ToArray());
}
} /// <summary>
/// (DataContractJsonSerialize)反序列化
/// </summary>
/// <param name="str">字符串序列</param>
public static T DataContractJsonDeSerialize<T>(string str) where T : class,new()
{
DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(T));
using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(str)))
{
return serializer.ReadObject(ms) as T;
}
}
#endregion #region NetDataContractSerializer
public static void NetDataContractSerialize(string fileName, object obj)
{
using (FileStream fs = new FileStream(fileName, FileMode.Create, FileAccess.Write, FileShare.Write))
{
try
{
NetDataContractSerializer serializer = new NetDataContractSerializer();
serializer.Serialize(fs, obj);
}
catch (Exception e)
{
throw e;
}
}
} public static T NetDataContractDeSerialize<T>(string fileName) where T : class,new()
{
using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read))
{
try
{
NetDataContractSerializer serializer = new NetDataContractSerializer();
return serializer.Deserialize(fs) as T;
}
catch (Exception e)
{
throw e;
}
}
}
#endregion #region DataContractSerializer
public static void DataContractSerialize(string fileName, object obj)
{
using (FileStream fs = new FileStream(fileName, FileMode.Create, FileAccess.Write, FileShare.Write))
{
try
{
DataContractSerializer serializer = new DataContractSerializer(obj.GetType());
serializer.WriteObject(fs, obj);
}
catch (Exception e)
{
throw e;
}
}
} public static T DataContractDeSerialize<T>(string fileName) where T : class,new()
{
using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read))
{
try
{
DataContractSerializer serializer = new DataContractSerializer(typeof(T));
return serializer.ReadObject(fs) as T;
}
catch (Exception e)
{
throw e;
}
}
}
#endregion #region Newtonsoft
public static string JsonConvertSerialize(object item)
{
return JsonConvert.SerializeObject(item);
} public static T JsonDeSerialize<T>(string json) where T : class,new()
{
return JsonConvert.DeserializeObject<T>(json);
}
#endregion
}
}
关于各种序列化的各自"用武之地"以及总体性能比较，有空再细细深究。