/// <summary>
/// 序列化接口
/// </summary>
public interface ILibSerializer
{
/// <summary>
/// 序列化對象到流
/// </summary>
/// <param name="instance">對象</param>
/// <param name="type">對象類型</param>
/// <returns>流</returns>
Stream SerializeToStream(object instance, Type type);
/// <summary>
/// 序列化對象到文件
/// </summary>
/// <param name="fileName">文件路徑</param>
/// <param name="instance">對象</param>
/// <param name="type">對象類型</param>
void SerializeToFile(string fileName, object instance, Type type);
/// <summary>
/// 序列化對象到字符串
/// </summary>
/// <param name="instance">對象</param>
/// <param name="type">對象類型</param>
/// <returns>對象字符串流</returns>
string SerializeToString(object instance, Type type);
/// <summary>
/// 從字符串中反序列化出對象
/// </summary>
/// <param name="objectString">對象字符串</param>
/// <param name="type">對象類型</param>
/// <returns>對象</returns>
object DeserializeFromString(string objectString, Type type);
/// <summary>
/// 從流中反序列化出對象
/// </summary>
/// <param name="stream">對象流</param>
/// <param name="type">對象類型</param>
/// <returns>對象</returns>
object DeserializeFromStream(Stream stream, Type type);
/// <summary>
/// 從文件反序列化出對象
/// </summary>
/// <param name="fileName">文件路徑</param>
/// <param name="type">對象類型</param>
/// <returns>對象</returns>
object DeserializeFromFile(string fileName, Type type);
}
/// <summary>
/// 序列化基類
/// </summary>
public class LibSerializer : ILibSerializer
{
/// <summary>
/// 序列化對象到流
/// </summary>
/// <param name="instance">對象</param>
/// <param name="type">對象類型</param>
/// <returns>流</returns>
public virtual Stream SerializeToStream(object instance, Type type)
{
return null;
}
/// <summary>
/// 序列化對象到文件
/// </summary>
/// <param name="fileName">文件路徑</param>
/// <param name="instance">對象</param>
/// <param name="type">對象類型</param>
public virtual void SerializeToFile(string fileName, object instance, Type type)
{
}
/// <summary>
/// 序列化對象到字符串
/// </summary>
/// <param name="instance">對象</param>
/// <param name="type">對象類型</param>
/// <returns>字符串</returns>
public virtual string SerializeToString(object instance, Type type)
{
return String.Empty;
}
/// <summary>
/// 從字符串中反序列化出對象
/// </summary>
/// <param name="objectString">對象字符串</param>
/// <param name="type">對象類型</param>
/// <returns>對象</returns>
public virtual object DeserializeFromString(string objectString, Type type)
{
return null;
}
/// <summary>
/// 從流中反序列化出對象
/// </summary>
/// <param name="stream">對象流</param>
/// <param name="type">對象類型</param>
/// <returns>對象</returns>
public virtual object DeserializeFromStream(Stream stream, Type type)
{
return null;
}
/// <summary>
/// 從文件反序列化出對象
/// </summary>
/// <param name="fileName">文件路徑</param>
/// <param name="type">對象類型</param>
/// <returns>對象</returns>
public virtual object DeserializeFromFile(string fileName, Type type)
{
return null;
}
}
/// <summary>
/// 二進制序列化類
/// </summary>
public class LibBinarySerializer : LibSerializer
{
/// <summary>
/// 序列化對象到流
/// </summary>
/// <param name="instance">對象</param>
/// <param name="type">對象類型</param>
/// <returns>流</returns>
public override Stream SerializeToStream(object instance, Type type)
{
BinaryFormatter bf = new BinaryFormatter();
bf.Binder = new CustomSerializationBinder();
MemoryStream stream = new MemoryStream();
bf.Serialize(stream, instance);
return stream;
}
/// <summary>
/// 序列化對象到文件
/// </summary>
/// <param name="fileName">文件路徑</param>
/// <param name="instance">對象</param>
/// <param name="type">對象類型</param>
public override void SerializeToFile(string fileName, object instance, Type type)
{
string sDirPath = LibSysUtils.GetDirectory(fileName);
if (!LibSysUtils.PathExists(sDirPath))
{
LibSysUtils.CreatePath(sDirPath);
}
using (FileStream fs = new FileStream(fileName, FileMode.Create))
{
BinaryFormatter bf = new BinaryFormatter();
bf.Binder = new CustomSerializationBinder();
bf.Serialize(fs, instance);
fs.Close();
}
}
/// <summary>
/// 序列化對象到字符串
/// </summary>
/// <param name="instance">對象</param>
/// <param name="type">對象類型</param>
/// <returns>字符串</returns>
public override string SerializeToString(object instance, Type type)
{
using (MemoryStream stream = (MemoryStream)SerializeToStream(instance, type))
{
byte[] dataBuf = stream.ToArray();
string result = Convert.ToBase64String(dataBuf);
return result;
}
}
/// <summary>
/// 從字符串中反序列化出對象
/// </summary>
/// <param name="objectString">對象字符串</param>
/// <param name="type">對象類型</param>
/// <returns>對象</returns>
public override object DeserializeFromString(string objectString, Type type)
{
byte[] dataBuf = Convert.FromBase64String(objectString);
using (MemoryStream stream = new MemoryStream(dataBuf))
{
stream.Position = 0;
stream.Seek(0, SeekOrigin.Begin);
object result = DeserializeFromStream(stream, type);
return result;
}
}
/// <summary>
/// 從流中反序列化出對象
/// </summary>
/// <param name="stream">對象流</param>
/// <param name="type">對象類型</param>
/// <returns>對象</returns>
public override object DeserializeFromStream(Stream stream, Type type)
{
BinaryFormatter bf = new BinaryFormatter();
bf.Binder = new CustomSerializationBinder();
return bf.Deserialize(stream);
}
/// <summary>
/// 從文件反序列化出對象
/// </summary>
/// <param name="fileName">文件路徑</param>
/// <param name="type">對象類型</param>
/// <returns>對象</returns>
public override object DeserializeFromFile(string fileName, Type type)
{
object objResult = null;
using (FileStream fs = new FileStream(fileName, FileMode.Open))
{
BinaryFormatter bf = new BinaryFormatter();
bf.Binder = new CustomSerializationBinder();
objResult = bf.Deserialize(fs);
fs.Close();
}
return objResult;
}
}
/// <summary>
/// SOAP格式序列化類
/// </summary>
public class LibSoapSerializer : LibSerializer
{
/// <summary>
/// 序列化對象到流
/// </summary>
/// <param name="instance">對象</param>
/// <param name="type">對象類型</param>
/// <returns>流</returns>
public override Stream SerializeToStream(object instance, Type type)
{
MemoryStream stream = new MemoryStream();
SoapFormatter sf = new SoapFormatter();
sf.Binder = new CustomSerializationBinder();
sf.Serialize(stream, instance);
return stream;
}
/// <summary>
/// 序列化對象到文件
/// </summary>
/// <param name="fileName">文件路徑</param>
/// <param name="instance">對象</param>
/// <param name="type">對象類型</param>
public override void SerializeToFile(string fileName, object instance, Type type)
{
string sDirPath = LibSysUtils.GetDirectory(fileName);
if (!LibSysUtils.PathExists(sDirPath))
{
LibSysUtils.CreatePath(sDirPath);
}
using (FileStream fs = new FileStream(fileName, FileMode.Create))
{
SoapFormatter sf = new SoapFormatter();
sf.Binder = new CustomSerializationBinder();
sf.Serialize(fs, instance);
fs.Close();
}
}
/// <summary>
/// 序列化對象到字符串
/// </summary>
/// <param name="instance">對象</param>
/// <param name="type">對象類型</param>
/// <returns>字符串</returns>
public override string SerializeToString(object instance, Type type)
{
using (MemoryStream ms = SerializeToStream(instance, type) as MemoryStream)
{
ms.Position = 0;
ms.Seek(0, SeekOrigin.Begin);
byte[] dataBuf = ms.ToArray();
string result = UTF8Encoding.UTF8.GetString(dataBuf);
ms.Close();
return result;
}
}
/// <summary>
/// 從字符串中反序列化出對象
/// </summary>
/// <param name="objectString">對象字符串</param>
/// <param name="type">對象類型</param>
/// <returns>對象</returns>
public override object DeserializeFromString(string objectString, Type type)
{
using (MemoryStream ms = new MemoryStream(UTF8Encoding.UTF8.GetBytes(objectString)))
{
ms.Position = 0;
ms.Seek(0, SeekOrigin.Begin);
object result = DeserializeFromStream(ms, type);
ms.Close();
return result;
}
}
/// <summary>
/// 從流中反序列化出對象
/// </summary>
/// <param name="stream">對象流</param>
/// <param name="type">對象類型</param>
/// <returns>對象</returns>
public override object DeserializeFromStream(Stream stream, Type type)
{
SoapFormatter sf = new SoapFormatter();
sf.Binder = new CustomSerializationBinder();
return sf.Deserialize(stream);
}
/// <summary>
/// 從文件反序列化出對象
/// </summary>
/// <param name="fileName">文件路徑</param>
/// <param name="type">對象類型</param>
/// <returns>對象</returns>
public override object DeserializeFromFile(string fileName, Type type)
{
object objResult = null;
using (FileStream fs = new FileStream(fileName, FileMode.Open))
{
SoapFormatter sf = new SoapFormatter();
sf.Binder = new CustomSerializationBinder();
objResult = sf.Deserialize(fs);
fs.Close();
}
return objResult;
}
}
/// <summary>
/// XML格式序列化類
/// </summary>
public class LibXmlSerializer : LibSerializer
{
/// <summary>
/// 序列化對象到流
/// </summary>
/// <param name="instance">對象</param>
/// <param name="type">對象類型</param>
/// <returns>流</returns>
public override Stream SerializeToStream(object instance, Type type)
{
XmlSerializer serializer = new XmlSerializer(type);
MemoryStream stream = new MemoryStream();
serializer.Serialize(stream, instance);
return stream;
}
/// <summary>
/// 序列化對象到文件
/// </summary>
/// <param name="fileName">文件路徑</param>
/// <param name="instance">對象</param>
/// <param name="type">對象類型</param>
public override void SerializeToFile(string fileName, object instance, Type type)
{
string sDirPath = LibSysUtils.GetDirectory(fileName);
if (!LibSysUtils.PathExists(sDirPath))
{
LibSysUtils.CreatePath(sDirPath);
}
using (FileStream fs = new FileStream(fileName, FileMode.Create))
{
XmlSerializer serializer = new XmlSerializer(type);
serializer.Serialize(fs, instance);
fs.Close();
}
}
/// <summary>
/// 序列化對象到字符串
/// </summary>
/// <param name="instance">對象</param>
/// <param name="type">對象類型</param>
/// <returns>字符串</returns>
public override string SerializeToString(object instance, Type type)
{
using (StringWriter sw = new StringWriter())
{
XmlSerializer xz = new XmlSerializer(type);
xz.Serialize(sw, type);
return sw.ToString();
}
}
/// <summary>
/// 從字符串中反序列化出對象
/// </summary>
/// <param name="objectString">對象字符串</param>
/// <param name="type">對象類型</param>
/// <returns>對象</returns>
public override object DeserializeFromString(string objectString, Type type)
{
using (StringReader sr = new StringReader(objectString))
{
XmlSerializer xz = new XmlSerializer(type);
return xz.Deserialize(sr);
}
}
/// <summary>
/// 從流中反序列化出對象
/// </summary>
/// <param name="stream">對象流</param>
/// <param name="type">對象類型</param>
/// <returns>對象</returns>
public override object DeserializeFromStream(Stream stream, Type type)
{
XmlSerializer serializer = new XmlSerializer(type);
return serializer.Deserialize(stream);
}
/// <summary>
/// 從文件反序列化出對象
/// </summary>
/// <param name="fileName">文件路徑</param>
/// <param name="type">對象類型</param>
/// <returns>對象</returns>
public override object DeserializeFromFile(string fileName, Type type)
{
object objResult = null;
using (FileStream fs = new FileStream(fileName, FileMode.Open))
{
XmlSerializer serializer = new XmlSerializer(type);
objResult = serializer.Deserialize(fs);
fs.Close();
}
return objResult;
}
}
/// <summary>
/// Json格式序列化類
/// </summary>
public class LibJsonSerializer : LibSerializer
{
/// <summary>
/// 序列化對象到流
/// </summary>
/// <param name="instance">對象</param>
/// <param name="type">對象類型</param>
/// <returns>流</returns>
public override Stream SerializeToStream(object instance, Type type)
{
MemoryStream stream = new MemoryStream();
string result = this.SerializeToString(instance, type);
byte[] resultBytes = Encoding.UTF8.GetBytes(result);
stream.Write(resultBytes, 0, resultBytes.Length);
stream.Position = 0;
return stream;
}
/// <summary>
/// 序列化對象到文件
/// </summary>
/// <param name="fileName">文件路徑</param>
/// <param name="instance">對象</param>
/// <param name="type">對象類型</param>
public override void SerializeToFile(string fileName, object instance, Type type)
{
string sDirPath = LibSysUtils.GetDirectory(fileName);
if (!LibSysUtils.PathExists(sDirPath))
{
LibSysUtils.CreatePath(sDirPath);
}
using (FileStream fs = new FileStream(fileName, FileMode.Create))
{
string result = this.SerializeToString(instance, type);
byte[] resultBytes = Encoding.UTF8.GetBytes(result);
fs.Write(resultBytes, 0, resultBytes.Length);
fs.Close();
}
}
/// <summary>
/// 序列化對象到字符串
/// </summary>
/// <param name="instance">對象</param>
/// <param name="type">對象類型</param>
/// <returns>字符串</returns>
public override string SerializeToString(object instance, Type type)
{
return JsonConvert.SerializeObject(instance);
}
/// <summary>
/// 從字符串中反序列化出對象
/// </summary>
/// <param name="objectString">對象字符串</param>
/// <param name="type">對象類型</param>
/// <returns>對象</returns>
public override object DeserializeFromString(string objectString, Type type)
{
object result = JsonConvert.DeserializeObject(objectString, type);
return result;
}
/// <summary>
/// 從流中反序列化出對象
/// </summary>
/// <param name="stream">對象流</param>
/// <param name="type">對象類型</param>
/// <returns>對象</returns>
public override object DeserializeFromStream(Stream stream, Type type)
{
byte[] dataBuf = new byte[stream.Length];
stream.Read(dataBuf, 0, dataBuf.Length);
string dataStr = Encoding.UTF8.GetString(dataBuf);
object result = this.DeserializeFromString(dataStr, type);
return result;
}
/// <summary>
/// 從文件反序列化出對象
/// </summary>
/// <param name="fileName">文件路徑</param>
/// <param name="type">對象類型</param>
/// <returns>對象</returns>
public override object DeserializeFromFile(string fileName, Type type)
{
object objResult = null;
using (FileStream fs = new FileStream(fileName, FileMode.Open))
{
byte[] dataBuf = new byte[fs.Length];
fs.Read(dataBuf, 0, dataBuf.Length);
string dataStr = Encoding.UTF8.GetString(dataBuf);
objResult = this.DeserializeFromString(dataStr, type);
fs.Close();
}
return objResult;
}
}
/// <summary>
/// 序列化控制類
/// </summary>
public class LibSerializerControl
{
/// <summary>
/// 序列化對象到流
/// </summary>
/// <param name="instance">對象</param>
/// <param name="type">對象類型</param>
/// <returns>流</returns>
public static Stream SerializeToStream<T>(object instance, Type type)
where T : ILibSerializer
{
ILibSerializer serializer = Activator.CreateInstance(typeof(T)) as ILibSerializer;
return serializer.SerializeToStream(instance, type);
}
/// <summary>
/// 序列化對象到文件
/// </summary>
/// <param name="fileName">文件路徑</param>
/// <param name="instance">對象</param>
/// <param name="type">對象類型</param>
public static void SerializeToFile<T>(string fileName, object instance, Type type)
where T : ILibSerializer
{
ILibSerializer serializer = Activator.CreateInstance(typeof(T)) as ILibSerializer;
serializer.SerializeToFile(fileName, instance, type);
}
/// <summary>
/// 序列化對象到字符串
/// </summary>
/// <param name="instance">對象</param>
/// <param name="type">對象類型</param>
/// <returns>返回對象字符串流</returns>
public static string SerializeToString<T>(object instance, Type type)
where T : ILibSerializer
{
ILibSerializer serializer = Activator.CreateInstance(typeof(T)) as ILibSerializer;
return serializer.SerializeToString(instance, type);
}
/// <summary>
/// 從字符串中反序列化出對象
/// </summary>
/// <param name="stream">對象字符串流</param>
/// <param name="type">對象類型</param>
/// <returns>對象</returns>
public static object DeserializeFromString<T>(string objectString, Type type)
where T : ILibSerializer
{
ILibSerializer serializer = Activator.CreateInstance(typeof(T)) as ILibSerializer;
return serializer.DeserializeFromString(objectString, type);
}
/// <summary>
/// 從字符串中反序列化出對象
/// </summary>
/// <param name="stream">對象字符串流</param>
/// <param name="type">對象類型</param>
/// <returns>對象</returns>
public static object TryDeserializeFromString<T>(string objectString, Type type)
where T : ILibSerializer
{
try
{
ILibSerializer serializer = Activator.CreateInstance(typeof(T)) as ILibSerializer;
return serializer.DeserializeFromString(objectString, type);
}
catch
{
return null;
}
}
/// <summary>
/// 從流中反序列化出對象
/// </summary>
/// <param name="stream">對象流</param>
/// <param name="type">對象類型</param>
/// <returns>對象</returns>
public static object DeserializeFromStream<T>(Stream stream, Type type)
where T : ILibSerializer
{
ILibSerializer serializer = Activator.CreateInstance(typeof(T)) as ILibSerializer;
return serializer.DeserializeFromStream(stream, type);
}
/// <summary>
/// 從文件反序列化出對象
/// </summary>
/// <param name="fileName">文件路徑</param>
/// <param name="type">對象類型</param>
/// <returns>對象</returns>
public static object DeserializeFromFile<T>(string fileName, Type type)
where T : ILibSerializer
{
ILibSerializer serializer = Activator.CreateInstance(typeof(T)) as ILibSerializer;
return serializer.DeserializeFromFile(fileName, type);
}
/// <summary>
/// 克隆對象
/// </summary>
/// <param name="instance">對象</param>
/// <returns>返回流對象</returns>
public static object CloneObject(object instance)
{
object result = null;
using (Stream stream = SerializeToStream<LibBinarySerializer>(instance, instance.GetType()))
{
stream.Position = 0;
result = DeserializeFromStream<LibBinarySerializer>(stream, instance.GetType());
stream.Close();
return result;
}
}
}
【代碼片段】序列化和反序列化之接口和控制類
發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.