压缩解压和二进制序列化DEMO

仅供参考

using System.Data;
using System.IO;
using System.IO.Compression;
using System.Runtime.Serialization.Formatters.Binary;

namespace WebServiceTestApp
{
    public class ByteHelper
    {
        #region 压缩/解压缩
        /// <summary>
        /// 解压缩二进制格式数据,得到数据集
        /// </summary>
        /// <param name="bytes">二进制格式数据</param>
        /// <returns>数据集</returns>
        public static DataSet DecompressionDataSet(byte[] bytes)
        {
            // 初始化流，设置读取位置
            MemoryStream mStream = new MemoryStream(bytes);
            mStream.Seek(0, SeekOrigin.Begin);
            // 解压缩
            DeflateStream unZipStream = new DeflateStream(mStream, CompressionMode.Decompress, true);
            // 反序列化得到数据集
            DataSet dsResult = new DataSet();
            dsResult.RemotingFormat = SerializationFormat.Xml;//SerializationFormat.Binary会将数据中日期为空的值默认设置为“0001-01-01 08:00:00”
            BinaryFormatter bFormatter = new BinaryFormatter();
            dsResult = (DataSet)bFormatter.Deserialize(unZipStream);

            return dsResult;
        }
        /// <summary>
        /// 压缩Bytes
        /// </summary>
        /// <param name="btData">Byte数据</param>
        /// <returns></returns>
        public static byte[] CompressBytes(byte[] btData)
        {
            MemoryStream oStream = new MemoryStream();
            DeflateStream zipStream = new DeflateStream(oStream, CompressionMode.Compress);
            zipStream.Write(btData, 0, btData.Length);
            zipStream.Flush();
            zipStream.Close();
            //
            return oStream.ToArray();
        }
        /// <summary>
        /// 解压字节流
        /// </summary>
        /// <param name="btData"></param>
        /// <returns></returns>
        public static byte[] DeCompressBytes(byte[] btData)
        {
            // 初始化流，设置读取位置
            MemoryStream mStream = new MemoryStream(btData);
            mStream.Seek(0, SeekOrigin.Begin);
            // 解压缩
            DeflateStream unZipStream = new DeflateStream(mStream, CompressionMode.Decompress, true);
            //
            MemoryStream ms = new MemoryStream();
            int BUFFER_SIZE = 1000;
            byte[] buffer = new byte[BUFFER_SIZE];
            int count = unZipStream.Read(buffer, 0, buffer.Length);
            while (count > 0)
            {
                ms.Write(buffer, 0, count);
                count = unZipStream.Read(buffer, 0, buffer.Length);
            }
            unZipStream.Close();
            byte[] decompressed = ms.ToArray();
            ms.Close();
            return decompressed;
        }
        #endregion

        #region 二进制序列化
        /// <summary>
        /// 序列化对象
        /// </summary>
        /// <param name="ObjSerialize">待序列化的对象</param>
        /// <returns>内存流</returns>
        public static System.IO.MemoryStream SerializeBinary(object ObjSerialize)
        {
            System.Runtime.Serialization.Formatters.Binary.BinaryFormatter serializer =
             new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
            System.IO.MemoryStream ms = new System.IO.MemoryStream();
            serializer.Serialize(ms, ObjSerialize);
            return ms;
        }
        /// <summary>
        /// 反序列化对象
        /// </summary>
        /// <param name="ms">内存流</param>
        /// <returns>原始对象</returns>
        public static object DeSerializeBinary(System.IO.MemoryStream ms)
        {
            ms.Position = 0;
            System.Runtime.Serialization.Formatters.Binary.BinaryFormatter deserializer =
             new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
            object Obj = deserializer.Deserialize(ms);
            ms.Close();
            return Obj;
        }
        /// <summary>
        /// 字符串数组转字节数组
        /// </summary>
        /// <param name="strSource"></param>
        /// <returns></returns>
        public static byte[] ToBytes(string[] strSource)
        {
            System.IO.MemoryStream ms = SerializeBinary(strSource);
            return ms.ToArray();
        }
        /// <summary>
        /// 字符串数组转字节数组
        /// </summary>
        /// <param name="strSource"></param>
        /// <returns></returns>
        public static byte[] ToByte(string[][] strSource)
        {
            System.IO.MemoryStream ms = SerializeBinary(strSource);
            return ms.ToArray();
        }
        /// <summary>
        /// 内存流转字符串
        /// </summary>
        /// <param name="ms">内存流</param>
        /// <returns>字符串</returns>
        public static string StreamToString(MemoryStream ms)
        {
            // 准备起始位置
            ms.Position = 0;
            using (StreamReader sr = new StreamReader(ms))
            {
                // 读取数据量到String中
                return sr.ReadToEnd();
            }
        }
        /// <summary>
        /// 字符串转内存流
        /// </summary>
        /// <param name="strSource">字符串</param>
        /// <returns>内存流</returns>
        public static Stream StringToStream(string strSource)
        {
            StreamWriter sw = new StreamWriter(new MemoryStream());
            sw.Write(strSource);
            sw.Flush();
            return sw.BaseStream;
        }
        #endregion
    }
}