对象类的序列化轻型的XML和复杂型的byte[]方式
/// <summary>
/// 对象序列化工具
/// </summary>
public class ObjectSerializationHelper
{
/// <summary>
/// 序列化集合
/// </summary>
private static Dictionary<int, XmlSerializer> xmlSerializer_dict = new Dictionary<int, XmlSerializer>();
#region --- Functions Begin ---
/// <summary>
/// 获取对象类型的序列化Xml格式
/// </summary>
/// <typeparam name="T">对象类型</typeparam>
/// <returns>Xml格式</returns>
private static XmlSerializer GetXmlSerializer<T>() where T : new()
{
int tHash = typeof(T).GetHashCode();
if (!xmlSerializer_dict.ContainsKey(tHash))
{
xmlSerializer_dict.Add(tHash, new XmlSerializer(typeof(T)));
}
return xmlSerializer_dict[tHash];
}
/// <summary>
/// 把对象序列化为字符串
/// </summary>
/// <typeparam name="T">对象类型</typeparam>
/// <param name="t">对象</param>
/// <returns>序列化后的字符串,失败则会抛出异常信息</returns>
public static string SerializeToXmlString<T>(T t) where T : new()
{
string str = string.Empty;
XmlSerializer xml = GetXmlSerializer<T>();
MemoryStream ms = new MemoryStream();
XmlTextWriter xtw = null;
StreamReader sr = null;
try
{
xtw = new System.Xml.XmlTextWriter(ms, Encoding.UTF8);
xtw.Formatting = System.Xml.Formatting.Indented;
xml.Serialize(xtw, t);
ms.Seek(0, SeekOrigin.Begin);
sr = new StreamReader(ms);
str = sr.ReadToEnd();
}
catch (Exception ex)
{
throw ex;
}
finally
{
if (xtw != null)
xtw.Close();
if (sr != null)
sr.Close();
ms.Close();
}
return str;
}
/// <summary>
/// 从字符窜反序列化为对象
/// </summary>
/// <typeparam name="T">对象类</typeparam>
/// <param name="s">需要反序列化的字符串</param>
/// <returns>该对象实例,失败则会抛出异常信息</returns>
public static T DeSerializeForXmlString<T>(string s) where T : new()
{
byte[] bArray = System.Text.Encoding.UTF8.GetBytes(s);
try
{
XmlSerializer xml = GetXmlSerializer<T>();
return (T)xml.Deserialize(new MemoryStream(bArray));
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 对象序列化为Byte数组
/// </summary>
/// <typeparam name="T">对象类</typeparam>
/// <param name="t">来源对象</param>
/// <returns>返回结果</returns>
public static byte[] SerializeToBytes<T>(T t) where T : new()
{
using (MemoryStream stream = new MemoryStream())
{
try
{
byte[] buf = null;
IFormatter formatter = new BinaryFormatter();
formatter.Serialize(stream, t);
buf = stream.ToArray();
stream.Close();
return buf;
}
catch (Exception ex)
{
throw ex;
}
}
}
/// <summary>
/// 序列化为Byte数组对象还原为对象实体
/// </summary>
/// <typeparam name="T">对象类型</typeparam>
/// <param name="buf">对象序列化后数据</param>
/// <returns></returns>
public static T DeSerializeForBytes<T>(byte[] buf) where T : new()
{
try
{
using (MemoryStream stream = new MemoryStream(buf))
{
IFormatter formatter = new BinaryFormatter();
return (T)formatter.Deserialize(stream);
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 简单克隆利用Xml模式进行序列化克隆
/// </summary>
/// <typeparam name="T">对象类型</typeparam>
/// <param name="obj">对象实体</param>
/// <returns>对象副本</returns>
public static T SimpleClone<T>(T obj) where T : new()
{
try
{
string xmlString = SerializeToXmlString(obj);
return DeSerializeForXmlString<T>(xmlString);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 高级克隆利用内存流模式进行序列化克隆
/// </summary>
/// <typeparam name="T">对象类型</typeparam>
/// <param name="obj">对象实体</param>
/// <returns>对象副本</returns>
public static T AdvancedClone<T>(T obj) where T : new()
{
try
{
byte[] buf = SerializeToBytes(obj);
return DeSerializeForBytes<T>(buf);
}
catch (Exception ex)
{
throw ex;
}
}
/*
/// <summary>
/// 克隆对象
/// </summary>
public static class ObjectCloner
{
/// <summary>
/// 克隆对象
/// </summary>
/// <param name="obj">需要克隆的对象</param>
/// <returns>返回当前对象的克隆对象</returns>
public static T Clone<T>(T obj) where T : new()
{
try
{
using (MemoryStream stream = new MemoryStream())
{
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize(stream, obj);
stream.Position = 0L;
return (T)formatter.Deserialize(stream);
}
}
catch (Exception ex)
{
throw ex;
}
}
}
*/
#endregion --- Functions End ---
}