GZip压缩相关的方法

2016-02-01 17:09:32 访问(1379) 赞(0) 踩(0)

using System;
using System.Collections.Generic;
using System.Text;
using System.Security.Cryptography;
using System.Data;
using System.IO;
using System.IO.Compression;

namespace eKing.AodbLib.Utils
{
    /// <summary>
    /// GZip压缩相关的方法
    /// </summary>
    public class GZipManager
    {

        /// <summary>
        /// 获得gb2312的编码
        /// </summary>
        /// <returns></returns>
        public static System.Text.Encoding EncodingGetGB2312()
        {
            return System.Text.Encoding.GetEncoding("gb2312");
        }


        /// <summary>
        /// 获得MD5值
        /// </summary>
        /// <param name="s"></param>
        /// <param name="en"></param>
        /// <returns></returns>
        public static string GetMD5
            (
                string s,
                System.Text.Encoding en
            )
        {
            if (s == null)
                s = "";

            MD5 md5 = new MD5CryptoServiceProvider();

            byte[] t = md5.ComputeHash
                (
                    en.GetBytes(s)
                );

            StringBuilder sb = new StringBuilder(32);

            for (int i = 0; i < t.Length; i++)
            {
                sb.Append(t[i].ToString("x").PadLeft(2, '0'));
            }

            return sb.ToString();
        }


        /// <summary>
        /// DataSet结构的XML字符串转回成DataSet
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static DataSet StringToDataSet(string str)
        {
            DataSet ds = new DataSet();

            using (StringReader xmlSR = new StringReader(str))
            {

                // 忽视任何内联架构，从数据推断出强类型架构并加载数据。如果无法推断，则解释成字符串数据
                ds.ReadXml(xmlSR, XmlReadMode.InferTypedSchema);


                if (ds.Tables.Count > 0)
                    return ds;
                else
                    return null;
            }
        }



        /// <summary>
        /// 将传入字符串以GZip算法压缩后，返回Base64编码字符（默认用utf8编码）
        /// </summary>
        /// <param name="rawString">需要压缩的字符串</param>
        /// <returns>压缩后的Base64编码的字符串</returns>
        public static string GZipCompressString(string rawString)
        {
            if (rawString == null || rawString.Length == 0)
                return "";

            System.Text.Encoding en
                =
                System.Text.Encoding.UTF8;

            byte[] rawData = en.GetBytes(rawString);
            byte[] zippedData = Compress(rawData);
            return Convert.ToBase64String(zippedData);

        }

        /// <summary>
        /// 将传入字符串以GZip算法压缩后，返回Base64编码字符
        /// </summary>
        /// <param name="rawString">需要压缩的字符串</param>
        /// <param name="en"></param>
        /// <returns>压缩后的Base64编码的字符串</returns>
        public static string GZipCompressString
            (
                string rawString,
                System.Text.Encoding en
            )
        {
            if (rawString == null || rawString.Length == 0)
                return "";

            byte[] rawData = en.GetBytes(rawString);
            byte[] zippedData = Compress(rawData);
            return Convert.ToBase64String(zippedData);
        }



        /// <summary>
        /// GZip压缩
        /// </summary>
        /// <param name="rawData"></param>
        /// <returns></returns>
        private static byte[] Compress(byte[] rawData)
        {
            byte[] theResult = null;

            MemoryStream ms = null;
            GZipStream compressedzipStream = null;
            try
            {
                ms = new MemoryStream();
                compressedzipStream = new GZipStream(ms, CompressionMode.Compress, true);
                compressedzipStream.Write(rawData, 0, rawData.Length);

                compressedzipStream.Flush();
                compressedzipStream.Close();

                ms.Flush();
                theResult = ms.ToArray();
            }
            catch (Exception err)
            {
                throw err;
            }
            finally
            {
                if (compressedzipStream != null)
                {
                    compressedzipStream.Close();
                    compressedzipStream.Dispose();
                    compressedzipStream = null;
                }

                if (ms != null)
                {
                    ms.Close();
                    ms.Dispose();
                    ms = null;
                }
            }

            return theResult;
        }

        /// <summary>
        /// 将传入的二进制字符串资料以GZip算法解压缩
        /// </summary>
        /// <param name="zippedString">经GZip压缩后的二进制字符串</param>
        /// <returns>原始未压缩字符串</returns>
        public static string GZipDecompressString
            (
                string zippedString
            )
        {
            if (string.IsNullOrEmpty(zippedString) || zippedString.Length == 0)
            {
                return "";
            }

            System.Text.Encoding en
                =
                System.Text.Encoding.UTF8;

            byte[] zippedData = Convert.FromBase64String(zippedString);
            return en.GetString(Decompress(zippedData));

        }

        /// <summary>
        /// 将传入的二进制字符串资料以GZip算法解压缩
        /// </summary>
        /// <param name="zippedString">经GZip压缩后的二进制字符串</param>
        /// <returns>原始未压缩字符串</returns>
        public static string GZipDecompressString
            (
                string zippedString,
                System.Text.Encoding en
            )
        {
            if (zippedString == null || zippedString.Length == 0)
                return "";


            byte[] zippedData = Convert.FromBase64String(zippedString.ToString());
            return en.GetString(Decompress(zippedData));

        }



        /// <summary>
        /// ZIP解压
        /// </summary>
        /// <param name="zippedData"></param>
        /// <returns></returns>
        private static byte[] Decompress(byte[] zippedData)
        {
            byte[] theResult = null;
            MemoryStream ms = null;
            GZipStream compressedzipStream = null;
            MemoryStream outBuffer = null;
            try
            {
                ms = new MemoryStream(zippedData);
                compressedzipStream = new GZipStream(ms, CompressionMode.Decompress);

                outBuffer = new MemoryStream();
                byte[] block = new byte[1024];
                while (true)
                {
                    int bytesRead = compressedzipStream.Read(block, 0, block.Length);
                    if (bytesRead <= 0)
                        break;
                    else
                        outBuffer.Write(block, 0, bytesRead);
                }

                ms.Flush();
                compressedzipStream.Flush();
                outBuffer.Flush();

                theResult = outBuffer.ToArray();

            }
            catch (Exception err)
            {
                throw err;
            }
            finally
            {
                if (compressedzipStream != null)
                {
                    compressedzipStream.Flush();
                    compressedzipStream.Close();
                    compressedzipStream.Dispose();
                    compressedzipStream = null;
                }

                if (ms != null)
                {
                    ms.Flush();
                    ms.Close();
                    ms.Dispose();
                    ms = null;
                }

                if (outBuffer != null)
                {

                    outBuffer.Close();
                    outBuffer.Dispose();
                    outBuffer = null;
                }
            }

            return theResult;
        }


    }
}