数据序列化处理之经验积累（1）-BinaryFormatter

以前的项目使用到了数据序列化，由此抽象出了一些辅助类来更方便的实现数据序列化处理，将一一列出共享：
二进制序列化类，此类用于类标示为Serializable，以及实现了ISerializable接口的对象的序列化：
using System;
using System.IO;
using System.IO.Compression;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Xml;

namespace Skyline.Tools.Serialize
{
public static class BinaryFormatSerializer
{
private static readonly BinaryFormatter InnerBinaryFormatter = new BinaryFormatter();
private readonly static MemoryStreamStack MemoryStreamStacker = new MemoryStreamStack();

public static byte[] Serialize(object obj, bool compress)
{
if (obj == null)
{
return null;
}
byte[] info;
MemoryStream stream = MemoryStreamStacker.GetMemoryStream();
try
{
InnerBinaryFormatter.Serialize(stream, obj);
stream.SetLength(stream.Position);
info = stream.ToArray();
if (compress)
{
info = CompressHelper.CompressBytes(info);
}
}
finally
{
MemoryStreamStacker.ReleaseMemoryStream(stream);
}
return info;
}

public static object Deserialize(byte[] info, bool decompress)
{
if (info == null || info.Length <= 0)
{
return info;
}
object ret;
if (decompress)
{
info = CompressHelper.DeCompressBytes(info);
}
MemoryStream stream = MemoryStreamStacker.GetMemoryStream();
try
{
stream.Write(info, 0, info.Length);
stream.Position = 0L;
ret = InnerBinaryFormatter.Deserialize(stream);
}
finally
{
MemoryStreamStacker.ReleaseMemoryStream(stream);
}
return ret;
}

public static byte[] Serialize(object obj)
{
return Serialize(obj, false);
}

public static object Deserialize(byte[] info)
{
return Deserialize(info, false);
}

public static string SerializeToBase64String(object data, bool compress)
{
byte[] buffer = Serialize(data, compress);
return Convert.ToBase64String(buffer);
}

public static object DeserializeFromBase64String(string baseString, bool decompress)
{
if (String.IsNullOrEmpty(baseString))
return null;

byte[] buffer = Convert.FromBase64String(baseString);
return Deserialize(buffer, decompress);
}

public static string SerializeToBase64String(object data)
{
return SerializeToBase64String(data, false);
}

public static object DeserializeFromBase64String(string baseString)
{
return DeserializeFromBase64String(baseString, false);
}
}
}

辅助类：
public class MemoryStreamStack
{
private Stack<MemoryStream> _streams = null;

public MemoryStreamStack():this(100)
{

}

public MemoryStreamStack(int capacity)
{
_streams = new Stack<MemoryStream>(capacity);
}

public MemoryStream GetMemoryStream()
{
MemoryStream stream = null;
if (_streams.Count > 0)
{
lock (_streams)
{
if (_streams.Count > 0)
{
stream = (MemoryStream)_streams.Pop();
}
}
}
if (stream == null)
{
stream = new MemoryStream(0x800);
}
return stream;
}

public void ReleaseMemoryStream(MemoryStream stream)
{
if (stream == null)
{
return;
}
stream.Position = 0L;
stream.SetLength(0L);
lock (_streams)
{
_streams.Push(stream);
}
}

~MemoryStreamStack()
{
foreach (MemoryStream memory in _streams)
{
memory.Dispose();
}
_streams.Clear();
_streams = null;
}



}

压缩类：
using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.IO.Compression;

namespace Skyline.Tools.Serialize
{
public static class CompressHelper
{
private readonly static MemoryStreamStack MemoryStreamStacker = new MemoryStreamStack();
public static string CompressBytesToBase64String(byte[] buffer)
{
if (buffer == null || buffer.Length == 0)
{
return "";
}
byte[] compressedData = CompressBytes(buffer);
return System.Convert.ToBase64String(compressedData, 0, compressedData.Length);
}

public static string ConvertBytesToBase64String(byte[] buffer)
{
if (buffer == null || buffer.Length == 0)
{
return "";
}
return System.Convert.ToBase64String(buffer, 0, buffer.Length);
}

public static byte[] ConvertBase64StringToBytes(string deCompressString)
{
if (string.IsNullOrEmpty(deCompressString))
{
return new byte[0];
}
byte[] buffer = System.Convert.FromBase64String(deCompressString);
return buffer;
}

public static byte[] DeCompressBase64StringToBytes(string deCompressString)
{
if (string.IsNullOrEmpty(deCompressString))
{
return new byte[0];
}
byte[] buffer = System.Convert.FromBase64String(deCompressString);

byte[] ret = DeCompressBytes(buffer);
return ret;
}

public static byte[] CompressBytes(byte[] buffer)
{
if (buffer == null || buffer.Length == 0)
{
return buffer;
}
byte[] compressedData;
MemoryStream ms = MemoryStreamStacker.GetMemoryStream();
try
{
using (DeflateStream compressedzipStream = new DeflateStream(ms, CompressionMode.Compress, true))
{
compressedzipStream.Write(buffer, 0, buffer.Length);
}
ms.SetLength(ms.Position);
//如果得到的结果长度比原来还大,则不需要压宿,返回原来的,并带上一位标识数据是否已压宿过
if (ms.Length >= buffer.Length)
{
compressedData = new byte[buffer.Length + 1];
buffer.CopyTo(compressedData, 0);
compressedData[compressedData.Length - 1] = 0;
}
else
{
compressedData = new byte[ms.Length + 1];
ms.ToArray().CopyTo(compressedData, 0);
compressedData[compressedData.Length - 1] = 1;
}
//ms.Close();
}
finally
{
MemoryStreamStacker.ReleaseMemoryStream(ms);
}
return compressedData;
}



private static MemoryStream DeCompressMemoryToMemory(MemoryStream ms)
{
MemoryStream data = MemoryStreamStacker.GetMemoryStream();
using (DeflateStream zipStream = new DeflateStream(ms, CompressionMode.Decompress))
{
byte[] writeData = new byte[8192];
// Use the ReadAllBytesFromStream to read the stream.
while (true)
{
int size = zipStream.Read(writeData, 0, writeData.Length);
if (size > 0)
{
data.Write(writeData, 0, size);
}
else
{
break;
}
}
}
return data;
}

public static byte[] DeCompressBytes(byte[] buffer)
{
if (buffer == null || buffer.Length <= 0)
{
return buffer;
}
byte[] bytes = new byte[buffer.Length - 1];
Array.Copy(buffer, bytes, bytes.Length);

//如果最后一位是0,说明没有被压宿,那么也不需要解压速
if (buffer[buffer.Length - 1] == 0)
{
return bytes;
}
using (MemoryStream ms = new MemoryStream(buffer))
{
MemoryStream stream = null;
try
{
stream = DeCompressMemoryToMemory(ms);
stream.SetLength(stream.Position);
bytes = stream.ToArray();
}
finally
{
MemoryStreamStacker.ReleaseMemoryStream(stream);
}
}
return bytes;
}
}

}