序列化（完整）

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Runtime.Serialization;
using System.Data;
using System.Xml;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO.Compression;
using System.Collections;

namespace JD_SparePartsWarehouse_DataProvider.Common
{
    /// <summary>
    /// WebService的二进制格式化工具类
    /// </summary>
    public class WebServiceFormatter
    {
        public WebServiceFormatter() { }
        /// <summary>
        /// 将DataSet格式化成字节数组byte[]
        /// </summary>
        /// <param name="dsOriginal">DataSet对象</param>
        /// <returns>字节数组</returns>
        public static byte[] GetBinaryFormatData(DataSet dsOriginal)
        {
            if (dsOriginal == null)
                return null;
            byte[] binaryDataResult = null;
            using (MemoryStream memStream = new MemoryStream())
            {
                IFormatter brFormatter = new BinaryFormatter();
                dsOriginal.RemotingFormat = SerializationFormat.Binary;
                brFormatter.Serialize(memStream, dsOriginal);
                binaryDataResult = memStream.ToArray();
                memStream.Close();
                memStream.Dispose();
            }
            return binaryDataResult;
        }

        /// <summary>
        /// 将泛型List集合格式化成字节数组byte[]
        /// </summary>
        /// <typeparam name="T">对象</typeparam>
        /// <param name="dsOriginal">对象集合List</param>
        /// <returns>字节数组</returns>
        public static byte[] GetBinaryFormatData<T>(List<T> dsOriginal) where T : class
        {
            if (null == dsOriginal || dsOriginal.Count == 0)
            {
                return null;
            }
            byte[] binaryDataResult = null;
            using (MemoryStream memStream = new MemoryStream())
            {
                IFormatter brFormatter = new BinaryFormatter();
                brFormatter.Serialize(memStream, dsOriginal.ToArray());
                binaryDataResult = memStream.ToArray();
                memStream.Close();
                memStream.Dispose();
            }
            return Compress(binaryDataResult);
        }

        /// <summary>
        /// 将字节数组byte[]格式化成泛型List集合
        /// </summary>
        /// <typeparam name="T">泛型对象</typeparam>
        /// <param name="binaryData">二进制数组</param>
        /// <returns>泛型List集合</returns>
        public static List<T> RetrieveList<T>(byte[] binaryData) where T : class
        {
            if (binaryData == null)
                return null;
            List<T> dsOriginal = null;
            using (MemoryStream memStream = new MemoryStream(Decompress(binaryData)))
            {
                IFormatter brFormatter = new BinaryFormatter();
                Object obj = brFormatter.Deserialize(memStream);
                if (obj is T[])
                {
                    T[] t = obj as T[];
                    if (null != t && t.Length > 0)
                    {
                        dsOriginal = new List<T>(t.Length);
                        dsOriginal.AddRange(t);
                    }

                }
            }
            return dsOriginal;
        }

        /// <summary>
        /// 将DataSet格式化成字节数组byte[]，并且已经经过压缩
        /// </summary>
        /// <param name="dsOriginal">DataSet对象</param>
        /// <returns>字节数组</returns>
        public static byte[] GetBinaryFormatDataCompress(DataSet dsOriginal)
        {
            if (dsOriginal == null)
                return null;
            byte[] binaryDataResult = null;
            using (MemoryStream memStream = new MemoryStream())
            {
                IFormatter brFormatter = new BinaryFormatter();
                dsOriginal.RemotingFormat = SerializationFormat.Binary;
                brFormatter.Serialize(memStream, dsOriginal);
                binaryDataResult = memStream.ToArray();
                memStream.Close();
                memStream.Dispose();
            }
            return Compress(binaryDataResult);
        }

        /// <summary>
        /// 解压数据
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public static byte[] Decompress(byte[] data)
        {
            if (data == null)
                return null;
            byte[] bData = null;
            using (MemoryStream ms = new MemoryStream())
            {
                try
                {
                    ms.Write(data, 0, data.Length);
                    ms.Position = 0;
                    GZipStream stream = new GZipStream(ms, CompressionMode.Decompress, true);
                    byte[] buffer = new byte[1024];
                    MemoryStream temp = new MemoryStream();
                    int read = stream.Read(buffer, 0, buffer.Length);
                    while (read > 0)
                    {
                        temp.Write(buffer, 0, read);
                        read = stream.Read(buffer, 0, buffer.Length);
                    }
                    //TOBO:必须把stream流关闭才能返回ms流数据,不然数据会不完整
                    stream.Close();
                    stream.Dispose();
                    ms.Close();
                    ms.Dispose();
                    bData = temp.ToArray();
                    temp.Close();
                    temp.Dispose();
                }
                catch (Exception e)
                {
                }
            }
            return bData;
        }

        /// <summary>
        /// 压缩数据
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public static byte[] Compress(byte[] data)
        {
            if (data == null)
                return null;
            byte[] bData=null;
            using (MemoryStream ms = new MemoryStream())
            {
                try
                {
                    GZipStream stream = new GZipStream(ms, CompressionMode.Compress, true);
                    stream.Write(data, 0, data.Length);
                    stream.Close();
                    stream.Dispose();
                    //必须把stream流关闭才能返回ms流数据,不然数据会不完整
                    //并且解压缩方法stream.Read(buffer, 0, buffer.Length)时会返回0
                    bData = ms.ToArray();
                    ms.Close();
                    ms.Dispose();
                }
                catch (Exception e)
                {
                }
            }
            return bData;
        }

        /// <summary>
        /// 将字节数组反序列化成DataSet对象
        /// </summary>
        /// <param name="binaryData">字节数组</param>
        /// <returns>DataSet对象</returns>
        public static DataSet RetrieveDataSet(byte[] binaryData)
        {
            if (binaryData == null)
                return null;
            DataSet dsOriginal = null;
            using (MemoryStream memStream = new MemoryStream(binaryData))
            {
                IFormatter brFormatter = new BinaryFormatter();
                Object obj = brFormatter.Deserialize(memStream);
                dsOriginal = (DataSet)obj;
            }
            return dsOriginal;
        }

        /// <summary>
        /// 将字节数组反解压后序列化成DataSet对象
        /// </summary>
        /// <param name="binaryData">字节数组</param>
        /// <returns>DataSet对象</returns>
        public static DataSet RetrieveDataSetDecompress(byte[] binaryData)
        {
            if (binaryData == null)
                return null;
            DataSet dsOriginal = null;
            using (MemoryStream memStream = new MemoryStream(Decompress(binaryData)))
            {
                IFormatter brFormatter = new BinaryFormatter();
                Object obj = brFormatter.Deserialize(memStream);
                dsOriginal = (DataSet)obj;
            }
            return dsOriginal;
        }

        /// <summary>
        /// 将object格式化成字节数组byte[]
        /// </summary>
        /// <param name="dsOriginal">object对象</param>
        /// <returns>字节数组</returns>
        public static byte[] GetBinaryFormatData(object dsOriginal)
        {
            if (dsOriginal == null)
                return null;
            byte[] binaryDataResult = null;
            using (MemoryStream memStream = new MemoryStream())
            {
                IFormatter brFormatter = new BinaryFormatter();
                brFormatter.Serialize(memStream, dsOriginal);
                binaryDataResult = memStream.ToArray();
                memStream.Close();
                memStream.Dispose();
            }
            return binaryDataResult;
        }

        /// <summary>
        /// 将objec格式化成字节数组byte[]，并压缩
        /// </summary>
        /// <param name="dsOriginal">object对象</param>
        /// <returns>字节数组</returns>
        public static byte[] GetBinaryFormatDataCompress(object dsOriginal)
        {
            if (null == dsOriginal)
                return null;
            byte[] binaryDataResult = null;
            using (MemoryStream memStream = new MemoryStream())
            {
                IFormatter brFormatter = new BinaryFormatter();
                brFormatter.Serialize(memStream, dsOriginal);
                binaryDataResult = memStream.ToArray();
                memStream.Close();
                memStream.Dispose();
            }
            return Compress(binaryDataResult);
        }

        /// <summary>
        /// 将字节数组反序列化成object对象
        /// </summary>
        /// <param name="binaryData">字节数组</param>
        /// <returns>object对象</returns>
        public static object RetrieveObject(byte[] binaryData)
        {
            if (binaryData == null)
                return null;
            Object obj ;
            using (MemoryStream memStream = new MemoryStream(binaryData))
            {
                IFormatter brFormatter = new BinaryFormatter();
                obj = brFormatter.Deserialize(memStream);
            }
            return obj;
        }

        /// <summary>
        /// 将字节数组解压后反序列化成object对象
        /// </summary>
        /// <param name="binaryData">字节数组</param>
        /// <returns>object对象</returns>
        public static object RetrieveObjectDecompress(byte[] binaryData)
        {
            if (binaryData == null)
                return null;
            Object obj;
            using (MemoryStream memStream = new MemoryStream(Decompress(binaryData)))
            {
                IFormatter brFormatter = new BinaryFormatter();
                obj = brFormatter.Deserialize(memStream);
            }
            return obj;
        }
    }

}