using System;
using System.IO;
using System.IO.Compression;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Serialization.Formatters.Soap;
using System.Text;
using System.Xml;
using System.Xml.Serialization;
namespace PlatForm.Utilities
{
public enum SerializedType : ushort
{
ByteArray = 0,
Object = 1,
String = 2,
Datetime = 3,
Bool = 4,
//SByte = 5, //Makes no sense.
Byte = 6,
Short = 7,
UShort = 8,
Int = 9,
UInt = 10,
Long = 11,
ULong = 12,
Float = 13,
Double = 14,
CompressedByteArray = 255,
CompressedObject = 256,
CompressedString = 257,
}
public class SerializeHelper
{
public SerializeHelper()
{ }
#region XML序列化
/// <summary>
/// 文件化XML序列化
/// </summary>
/// <param name="obj">对象</param>
/// <param name="filename">文件路径</param>
public static void Save(object obj, string filename)
{
FileStream fs = null;
try
{
fs
= new FileStream
(filename, FileMode
.Create, FileAccess
.Write, FileShare
.ReadWrite); XmlSerializer serializer
= new XmlSerializer
(obj
.GetType()); serializer.Serialize(fs, obj);
}
catch (Exception ex)
{
throw ex;
}
finally
{
if (fs != null) fs.Close();
}
}
/// <summary>
/// 文件化XML反序列化
/// </summary>
/// <param name="type">对象类型</param>
/// <param name="filename">文件路径</param>
public static object Load(Type type, string filename)
{
FileStream fs = null;
try
{
fs
= new FileStream
(filename, FileMode
.Open, FileAccess
.Read, FileShare
.ReadWrite); XmlSerializer serializer
= new XmlSerializer
(type
); return serializer.Deserialize(fs);
}
catch (Exception ex)
{
throw ex;
}
finally
{
if (fs != null) fs.Close();
}
}
/// <summary>
/// 文本化XML序列化
/// </summary>
/// <param name="item">对象</param>
public string ToXml<T>(T item)
{
XmlSerializer serializer
= new XmlSerializer
(item
.GetType()); StringBuilder sb
= new StringBuilder
(); using (XmlWriter writer = XmlWriter.Create(sb))
{
serializer.Serialize(writer, item);
return sb.ToString();
}
}
/// <summary>
/// 文本化XML反序列化
/// </summary>
/// <param name="str">字符串序列</param>
public T FromXml<T>(string str)
{
XmlSerializer serializer
= new XmlSerializer
(typeof(T
)); using (XmlReader reader
= new XmlTextReader
(new StringReader
(str
))) {
return (T)serializer.Deserialize(reader);
}
}
#endregion
#region SoapFormatter序列化
/// <summary>
/// SoapFormatter序列化
/// </summary>
/// <param name="item">对象</param>
public static string ToSoap<T>(T item)
{
SoapFormatter formatter
= new SoapFormatter
(); using (MemoryStream ms
= new MemoryStream
()) {
formatter.Serialize(ms, item);
ms.Position = 0;
XmlDocument xmlDoc
= new XmlDocument
(); xmlDoc.Load(ms);
return xmlDoc.InnerXml;
}
}
/// <summary>
/// SoapFormatter反序列化
/// </summary>
/// <param name="str">字符串序列</param>
public static T FromSoap<T>(string str)
{
XmlDocument xmlDoc
= new XmlDocument
(); xmlDoc.LoadXml(str);
SoapFormatter formatter
= new SoapFormatter
(); using (MemoryStream ms
= new MemoryStream
()) {
xmlDoc.Save(ms);
ms.Position = 0;
return (T)formatter.Deserialize(ms);
}
}
#endregion
#region BinaryFormatter序列化
/// <summary>
/// BinaryFormatter序列化
/// </summary>
/// <param name="item">对象</param>
public static string ToBinary<T>(T item)
{
BinaryFormatter formatter
= new BinaryFormatter
(); using (MemoryStream ms
= new MemoryStream
()) {
formatter.Serialize(ms, item);
ms.Position = 0;
byte[] bytes = ms.ToArray();
StringBuilder sb
= new StringBuilder
(); foreach (byte bt in bytes)
{
sb.Append(string.Format("{0:X2}", bt));
}
return sb.ToString();
}
}
/// <summary>
/// BinaryFormatter反序列化
/// </summary>
/// <param name="str">字符串序列</param>
public static T FromBinary<T>(string str)
{
int intLen = str.Length / 2;
byte[] bytes
= new byte[intLen
]; for (int i = 0; i < intLen; i++)
{
int ibyte = Convert.ToInt32(str.Substring(i * 2, 2), 16);
bytes[i] = (byte)ibyte;
}
BinaryFormatter formatter
= new BinaryFormatter
(); using (MemoryStream ms
= new MemoryStream
(bytes
)) {
return (T)formatter.Deserialize(ms);
}
}
#endregion
/// <summary>
/// 将对象序列化为二进制字节
/// </summary>
/// <param name="obj">待序列化的对象</param>
/// <returns></returns>
public static byte[] SerializeToBinary(object obj)
{
byte[] bytes
= new byte[2500]; using (MemoryStream memoryStream
= new MemoryStream
()) {
BinaryFormatter bformatter
= new BinaryFormatter
(); bformatter.Serialize(memoryStream, obj);
memoryStream.Seek(0, 0);
if (memoryStream.Length > bytes.Length)
{
bytes
= new byte[memoryStream
.Length]; }
bytes = memoryStream.ToArray();
}
return bytes;
}
/// <summary>
/// 从二进制字节中反序列化为对象
/// </summary>
/// <param name="type">对象的类型</param>
/// <param name="bytes">字节数组</param>
/// <returns>反序列化后得到的对象</returns>
public static object DeserializeFromBinary(Type type, byte[] bytes)
{
object result
= new object(); using (MemoryStream memoryStream
= new MemoryStream
(bytes
)) {
BinaryFormatter serializer
= new BinaryFormatter
(); result = serializer.Deserialize(memoryStream);
}
return result;
}
/// <summary>
/// 将文件对象序列化到文件中
/// </summary>
/// <param name="obj">待序列化的对象</param>
/// <param name="path">文件路径</param>
/// <param name="fileMode">文件打开模式</param>
public static void SerializeToBinary(object obj, string path, FileMode fileMode)
{
using (FileStream fs
= new FileStream
(path, fileMode
)) {
// Construct a BinaryFormatter and use it to serialize the data to the stream.
BinaryFormatter formatter
= new BinaryFormatter
(); formatter.Serialize(fs, obj);
}
}
/// <summary>
/// 将文件对象序列化到文件中
/// </summary>
/// <param name="obj">待序列化的对象</param>
/// <param name="path">文件路径</param>
public static void SerializeToBinary(object obj, string path)
{
SerializeToBinary(obj, path, FileMode.Create);
}
/// <summary>
/// 从二进制文件中反序列化为对象
/// </summary>
/// <param name="type">对象的类型</param>
/// <param name="path">二进制文件路径</param>
/// <returns>反序列化后得到的对象</returns>
public static object DeserializeFromBinary(Type type, string path)
{
object result
= new object(); using (FileStream fileStream
= new FileStream
(path, FileMode
.Open)) {
BinaryFormatter serializer
= new BinaryFormatter
(); result = serializer.Deserialize(fileStream);
}
return result;
}
/// <summary>
/// 获取对象的转换为二进制的字节大小
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public static long GetByteSize(object obj)
{
long result;
BinaryFormatter bFormatter
= new BinaryFormatter
(); using (MemoryStream stream
= new MemoryStream
()) {
bFormatter.Serialize(stream, obj);
result = stream.Length;
}
return result;
}
/// <summary>
/// 克隆一个对象
/// </summary>
/// <param name="obj">待克隆的对象</param>
/// <returns>克隆的一个新的对象</returns>
public static object Clone(object obj)
{
object cloned = null;
BinaryFormatter bFormatter
= new BinaryFormatter
(); using (MemoryStream memoryStream
= new MemoryStream
()) {
try
{
bFormatter.Serialize(memoryStream, obj);
memoryStream.Seek(0, SeekOrigin.Begin);
cloned = bFormatter.Deserialize(memoryStream);
}
catch //(Exception e)
{
;
}
}
return cloned;
}
/// <summary>
/// 从文件中读取文本内容
/// </summary>
/// <param name="path">文件路径</param>
/// <returns>文件的内容</returns>
public static string ReadFile(string path)
{
string content = string.Empty;
using (StreamReader reader
= new StreamReader
(path
)) {
content = reader.ReadToEnd();
}
return content;
}
public static byte[] Serialize(object value, out SerializedType type, uint compressionThreshold)
{
byte[] bytes;
{
bytes = (byte[])value;
type = SerializedType.ByteArray;
if (bytes.Length > compressionThreshold)
{
bytes = compress(bytes);
type = SerializedType.CompressedByteArray;
}
}
else if (value is string) {
bytes = Encoding.UTF8.GetBytes((string)value);
type = SerializedType.String;
if (bytes.Length > compressionThreshold)
{
bytes = compress(bytes);
type = SerializedType.CompressedString;
}
}
else if (value is DateTime
) {
bytes = BitConverter.GetBytes(((DateTime)value).Ticks);
type = SerializedType.Datetime;
}
{
bytes
= new byte[] { (byte)((bool)value ? 1 : 0) }; type = SerializedType.Bool;
}
{
bytes
= new byte[] { (byte)value }; type = SerializedType.Byte;
}
{
bytes = BitConverter.GetBytes((short)value);
type = SerializedType.Short;
}
else if (value is ushort) {
bytes = BitConverter.GetBytes((ushort)value);
type = SerializedType.UShort;
}
{
bytes = BitConverter.GetBytes((int)value);
type = SerializedType.Int;
}
{
bytes = BitConverter.GetBytes((uint)value);
type = SerializedType.UInt;
}
{
bytes = BitConverter.GetBytes((long)value);
type = SerializedType.Long;
}
{
bytes = BitConverter.GetBytes((ulong)value);
type = SerializedType.ULong;
}
{
bytes = BitConverter.GetBytes((float)value);
type = SerializedType.Float;
}
else if (value is double) {
bytes = BitConverter.GetBytes((double)value);
type = SerializedType.Double;
}
else
{
//Object
using (MemoryStream ms
= new MemoryStream
()) {
new BinaryFormatter
().Serialize(ms,
value); bytes = ms.GetBuffer();
type = SerializedType.Object;
if (bytes.Length > compressionThreshold)
{
bytes = compress(bytes);
type = SerializedType.CompressedObject;
}
}
}
return bytes;
}
private static byte[] compress(byte[] bytes)
{
using (MemoryStream ms
= new MemoryStream
()) {
using (DeflateStream gzs
= new DeflateStream
(ms, CompressionMode
.Compress,
false)) {
gzs.Write(bytes, 0, bytes.Length);
}
ms.Close();
return ms.GetBuffer();
}
}
private static byte[] decompress(byte[] bytes)
{
using (MemoryStream ms
= new MemoryStream
(bytes,
false)) {
using (DeflateStream gzs
= new DeflateStream
(ms, CompressionMode
.Decompress,
false)) {
using (MemoryStream dest
= new MemoryStream
()) {
byte[] tmp
= new byte[bytes
.Length]; int read;
while ((read = gzs.Read(tmp, 0, tmp.Length)) != 0)
{
dest.Write(tmp, 0, read);
}
dest.Close();
return dest.GetBuffer();
}
}
}
}
public static object DeSerialize(byte[] bytes, SerializedType type)
{
switch (type)
{
case SerializedType.String:
return Encoding.UTF8.GetString(bytes);
case SerializedType.Datetime:
return new DateTime
(BitConverter
.ToInt64(bytes,
0)); case SerializedType.Bool:
return bytes[0] == 1;
case SerializedType.Byte:
return bytes[0];
case SerializedType.Short:
return BitConverter.ToInt16(bytes, 0);
case SerializedType.UShort:
return BitConverter.ToUInt16(bytes, 0);
case SerializedType.Int:
return BitConverter.ToInt32(bytes, 0);
case SerializedType.UInt:
return BitConverter.ToUInt32(bytes, 0);
case SerializedType.Long:
return BitConverter.ToInt64(bytes, 0);
case SerializedType.ULong:
return BitConverter.ToUInt64(bytes, 0);
case SerializedType.Float:
return BitConverter.ToSingle(bytes, 0);
case SerializedType.Double:
return BitConverter.ToDouble(bytes, 0);
case SerializedType.Object:
using (MemoryStream ms
= new MemoryStream
(bytes
)) {
return new BinaryFormatter
().Deserialize(ms
); }
case SerializedType.CompressedByteArray:
return DeSerialize(decompress(bytes), SerializedType.ByteArray);
case SerializedType.CompressedString:
return DeSerialize(decompress(bytes), SerializedType.String);
case SerializedType.CompressedObject:
return DeSerialize(decompress(bytes), SerializedType.Object);
case SerializedType.ByteArray:
default:
return bytes;
}
}
}
}
//csharp/6783