压缩和解压缩

 public enum CompressAlgorithm
    {
        GZip,
        DeflateStream
    }


    public class Compressor
    {
        private CompressAlgorithm algorithm;


        public Compressor(CompressAlgorithm algorithm)
        {
            this.algorithm = algorithm;
        }


        //压缩数组
        public ArraySegment<byte> Compress(ArraySegment<byte> data)
        {
            MemoryStream ms = new MemoryStream();
            Stream compressStream = new GZipStream(ms, CompressionMode.Compress, true);
            compressStream.Write(data.Array, 0, data.Count);
            compressStream.Close();
            byte[] newByteArray = new byte[ms.Length];


            ms.Seek(0, SeekOrigin.Begin);
            ms.Read(newByteArray, 0, newByteArray.Length);


            ArraySegment<byte> bytes = new ArraySegment<byte>(newByteArray);
            return bytes;
        }


        //压缩流
        public Stream Compress(Stream stream)
        {
            MemoryStream ms = new MemoryStream();
            if (algorithm == CompressAlgorithm.GZip)
            {
                Stream compressStream = new GZipStream(ms, CompressionMode.Compress, true);
                byte[] buffer = new byte[stream.Length];
                stream.Read(buffer, 0, buffer.Length);
                compressStream.Write(buffer, 0, buffer.Length);
                compressStream.Close();
            }
            else
            {
                Stream compressStream = new DeflateStream(ms, CompressionMode.Compress, true);
                byte[] buffer = new byte[stream.Length];
                stream.Read(buffer, 0, buffer.Length);
                compressStream.Write(buffer, 0, buffer.Length);
                compressStream.Close();
            }
            return ms;
        }


        //解压缩数组
        public ArraySegment<byte> DeCompress(ArraySegment<byte> data)
        {
            MemoryStream ms = new MemoryStream();


            ms.Write(data.Array, 0, data.Count);
            ms.Seek(0, SeekOrigin.Begin);
            if (algorithm == CompressAlgorithm.GZip)
            {
                Stream compressStream = new GZipStream(ms, CompressionMode.Decompress, false);
                byte[] newByteArray = RetrieveBytesFromStream(compressStream, 1);
                compressStream.Close();
                return new ArraySegment<byte>(newByteArray);
            }
            else
            {
                Stream compressStream = new DeflateStream(ms, CompressionMode.Decompress, false);
                byte[] newByteArray = RetrieveBytesFromStream(compressStream, 1);
                compressStream.Close();
                return new ArraySegment<byte>(newByteArray);
            }
        }


        //解压缩数组
        public Stream DeCompress(Stream stream)
        {
            stream.Seek(0, SeekOrigin.Begin);
            if (algorithm == CompressAlgorithm.GZip)
            {
                Stream compressStream = new GZipStream(stream, CompressionMode.Decompress, false);
                byte[] newByteArray = RetrieveBytesFromStream(compressStream, 1);
                compressStream.Close();
                return new MemoryStream(newByteArray);
            }
            else
            {
                Stream compressStream = new DeflateStream(stream, CompressionMode.Decompress, false);
                byte[] newByteArray = RetrieveBytesFromStream(compressStream, 1);
                compressStream.Close();
                return new MemoryStream(newByteArray);
            }
        }


        public byte[] RetrieveBytesFromStream(Stream stream, int bytesblock)
        {


            List<byte> lst = new List<byte>();
            byte[] data = new byte[1024];
            int totalCount = 0;
            while (true)
            {
                int bytesRead = stream.Read(data, 0, data.Length);
                if (bytesRead == 0)
                {
                    break;
                }
                byte[] buffers = new byte[bytesRead];
                Array.Copy(data, buffers, bytesRead);
                lst.AddRange(buffers);
                totalCount += bytesRead;
            }
            return lst.ToArray();
        }


        //压缩数组
        public static byte[] Compress(byte[] data)
        {
            MemoryStream stream = new MemoryStream();
            GZipStream gZipStream = new GZipStream(stream, CompressionMode.Compress);
            gZipStream.Write(data, 0, data.Length);
            gZipStream.Close();
            return stream.ToArray();
        }
        //解压缩数组
        public static byte[] Decompress(byte[] data)
        {
            MemoryStream stream = new MemoryStream();
            GZipStream gZipStream = new GZipStream(new MemoryStream(data), CompressionMode.Decompress);
            byte[] bytes = new byte[40960];
            int n;
            while ((n = gZipStream.Read(bytes, 0, bytes.Length)) != 0)
            {
                stream.Write(bytes, 0, n);
            }
            gZipStream.Close();
            return stream.ToArray();
        }

--------------------------------

序列化-----压缩过的。

  public static ParaTemplate GetTemplate(string id)
        {
            byte[] bytes = GetTemplateByte(id);
            return GetTemplate(bytes);
        }

        public static ParaTemplate GetTemplate(byte[] bytes)
        {
            ParaTemplate template = null;
            if (bytes == null)
            {
                return template;
            }
            try
            {
                bytes = Compressor.Decompress(bytes);
                Stream s = new MemoryStream();
                BinaryWriter writer = new BinaryWriter(s);
                s.Write(bytes, 0, bytes.Length);
                s.Seek(0, SeekOrigin.Begin);
                IFormatter formatter = new BinaryFormatter();

                template = formatter.Deserialize(s) as ParaTemplate;
                s.Close();
            }
            catch
            {
                throw new Exception("参数模板反序列化错误！");
            }
            return template;
        }

        public static byte[] GetTemplateByte(string templateid)
        {
            byte[] bytes = null;
            //string files = string.Format(fileFormat, System.Windows.Forms.Application.LocalUserAppDataPath, templateid);
            //if (System.IO.File.Exists(files))
            //{
            //    bytes = System.IO.File.ReadAllBytes(files);
            //}
            //else
            //{
            string sql = @"select byte from template where t.templateid = '{0}'";
            object obj = OracleHelp.DB.ExecScalar(string.Format(sql, eid));
            bytes = obj as byte[];
            //}

            return bytes;
        }

        public static Byte[] ObjectToByte(object obj)
        {
            Stream s = new MemoryStream();
            BinaryFormatter formatter = new BinaryFormatter();
            try
            {
                formatter.Serialize(s, obj);
            }
            catch (Exception ex)
            {
                System.Windows.Forms.MessageBox.Show("Template To Byte Error！");
            }
            byte[] buffer = new byte[s.Length];
            s.Seek(0, SeekOrigin.Begin);
            s.Read(buffer, 0, buffer.Length);
            s.Close();
            return Compressor.Compress(buffer);
        }