arraystruct.cs

TCompressionStream和TDecompressionStream

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Text;

namespace ZipDotNet
{

    /// <summary>
    /// ArrayStruct 的摘要说明
    /// </summary>
    public class ArrayStruct
    {
        public ArrayStruct()
        {
            //
            // TODO: 在此处添加构造函数逻辑
            //
        }



        private byte[] m_byBuf;										//信息内容


        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="len"></param>
        public ArrayStruct(int len)
        {
            //
            // TODO: 在此处添加构造函数逻辑
            //
            m_byBuf = new byte[len];
        }

        public ArrayStruct(byte[] abData)
        {
            m_byBuf = abData;
        }

        /// <summary>
        /// 在指定位置设置Int型
        /// </summary>
        /// <param name="offset"></param>
        /// <param name="nVal"></param>
        /// <returns></returns>
        public bool setInt(int offset, int nVal)
        {
            m_byBuf[offset] = (byte)(0xff & (nVal >> 24));
            m_byBuf[offset + 1] = (byte)(0xff & (nVal >> 16));
            m_byBuf[offset + 2] = (byte)(0xff & (nVal >> 8));
            m_byBuf[offset + 3] = (byte)(0xff & nVal);
            return true;
        }

        /// <summary>
        /// 从指定位置得到int
        /// </summary>
        /// <param name="offset"></param>
        /// <returns></returns>
        public int getInt(int offset)
        {
            int i0, i1, i2, i3;
            i0 = m_byBuf[offset];
            i1 = m_byBuf[offset + 1];
            i2 = m_byBuf[offset + 2];
            i3 = m_byBuf[offset + 3];
            return (((i0 & 0xff) << 24) | ((i1 & 0xff) << 16) | ((i2 & 0xff) << 8) | (i3 & 0xff));
        }

        /// <summary>
        /// 在指定位置设置Short型
        /// </summary>
        /// <param name="offset"></param>
        /// <param name="nVal"></param>
        /// <returns></returns>
        public bool setShort(int offset, int nVal)
        {
            m_byBuf[offset] = (byte)(0xff & (nVal >> 8));
            m_byBuf[offset + 1] = (byte)(0xff & nVal);
            return true;
        }

        /// <summary>
        /// 从指定位置得到Short
        /// </summary>
        /// <param name="offset"></param>
        /// <returns></returns>
        public int getShort(int offset)
        {
            int i0, i1;
            i0 = m_byBuf[offset];
            i1 = m_byBuf[offset + 1];
            return (((i0 & 0xff) << 8) | (i1 & 0xff));
        }


        /// <summary>
        /// 在指定位置设置Byte型
        /// </summary>
        /// <param name="offset"></param>
        /// <param name="nVal"></param>
        /// <returns></returns>
        public bool setByte(int offset, byte nVal)
        {
            m_byBuf[offset] = nVal;
            return true;
        }

        /// <summary>
        /// 从指定位置得到byte
        /// </summary>
        /// <param name="offset"></param>
        /// <returns></returns>
        public byte getByte(int offset)
        {
            return m_byBuf[offset];
        }

        /// <summary>
        /// 在指定位置设置Long型
        /// </summary>
        /// <param name="offset"></param>
        /// <param name="nVal"></param>
        /// <returns></returns>
        public bool setLong(int offset, long nVal)
        {
            m_byBuf[offset + 7] = (byte)(0xffffffff & (nVal >> 56));
            m_byBuf[offset + 6] = (byte)(0xffffffff & (nVal >> 48));
            m_byBuf[offset + 5] = (byte)(0xffffffff & (nVal >> 40));
            m_byBuf[offset + 4] = (byte)(0xffffffff & (nVal >> 32));
            m_byBuf[offset + 3] = (byte)(0xffffffff & (nVal >> 24));
            m_byBuf[offset + 2] = (byte)(0xffffffff & (nVal >> 16));
            m_byBuf[offset + 1] = (byte)(0xffffffff & (nVal >> 8));
            m_byBuf[offset + 0] = (byte)(0xffffffff & nVal);
            return true;
        }

        /// <summary>
        /// 从指定位置得到Long
        /// </summary>
        /// <param name="offset"></param>
        /// <returns></returns>
        public long getLong(int offset)
        {
            int i0, i1, i2, i3, i4, i5, i6, i7;
            i7 = m_byBuf[offset];
            i6 = m_byBuf[offset + 1];
            i5 = m_byBuf[offset + 2];
            i4 = m_byBuf[offset + 3];
            i3 = m_byBuf[offset + 4];
            i2 = m_byBuf[offset + 5];
            i1 = m_byBuf[offset + 6];
            i0 = m_byBuf[offset + 7];
            return (((i0 & 0xffffffff) << 56)
                | ((i1 & 0xffffffff) << 48)
                | ((i2 & 0xffffffff) << 40)
                | ((i3 & 0xffffffff) << 32)
                | ((i4 & 0xffffffff) << 24)
                | ((i5 & 0xffffffff) << 16)
                | ((i6 & 0xffffffff) << 8)
                | (i7 & 0xffffffff));
        }

        /// <summary>
        /// 在指定位置设置String型
        /// </summary>
        /// <param name="offset"></param>
        /// <param name="len"></param>
        /// <param name="sVal"></param>
        /// <returns></returns>
        public bool setString(int offset, int len, string sVal)
        {
            if (len > sVal.Length)
                len = sVal.Length;

            char[] cy = new char[len];
            cy = sVal.ToCharArray();
            for (int i = 0; i < len; i++)
            {
                m_byBuf[offset + i] = (byte)cy[i];
            }

            return true;
        }

        /// <summary>
        /// 从指定位置得到String
        /// </summary>
        /// <param name="offset"></param>
        /// <param name="len"></param>
        /// <returns></returns>
        public string getString(int offset, int len)
        {
            char[] tmp = new char[len];
            int i;
            for (i = 0; i < len; i++)
            {
                tmp[i] = (char)m_byBuf[offset + i];
                if (tmp[i] == 0)
                    break;
            }
            char[] by = new char[i];
            for (int j = 0; j < i; j++)
                by[j] = tmp[j];
            return new string(by);
        }

        /// <summary>
        /// 设置GB字串到指定未知
        /// </summary>
        /// <param name="offset"></param>
        /// <param name="len"></param>
        /// <param name="sVal"></param>
        /// <returns></returns>
        public bool setGBString(int offset, int len, string sVal)
        {
            System.Text.Encoding gb2312 = System.Text.Encoding.GetEncoding("gb2312");
            byte[] by = gb2312.GetBytes(sVal);
            for (int i = 0; i < len && i < by.Length; i++)
            {
                m_byBuf[offset + i] = by[i];
            }

            return true;
        }

        /// <summary>
        /// 从指定位置得到GB字串
        /// </summary>
        /// <param name="offset"></param>
        /// <param name="len"></param>
        /// <returns></returns>
        public string getGBString(int offset, int len)
        {
            byte[] tmp = new byte[len];
            int i;
            for (i = 0; i < len; i++)
            {
                tmp[i] = m_byBuf[offset + i];
                if (tmp[i] == 0)
                    break;
            }
            byte[] by = new byte[i];
            for (int j = 0; j < i; j++)
                by[j] = tmp[j];

            char[] cy = new char[i];
            System.Text.Encoding gb2312 = System.Text.Encoding.GetEncoding("gb2312");
            gb2312.GetChars(by, 0, i, cy, 0);

            return new string(cy);
        }

        /// <summary>
        /// 在指定位置设置UNICODE字串
        /// </summary>
        /// <param name="offset"></param>
        /// <param name="len"></param>
        /// <param name="sVal"></param>
        /// <returns></returns>
        public bool setUnicodeString(int offset, string sVal)
        {

            UnicodeEncoding unicode = new UnicodeEncoding();
            byte[] by = unicode.GetBytes(sVal);

            for (int i = 0; i < sVal.Length; i++)
            {
                m_byBuf[offset + (2 * i)] = by[2 * i + 1];
                m_byBuf[offset + (2 * i + 1)] = by[2 * i];
                //m_byBuf[offset+i] = by[i];
            }
            return true;
        }


        /// <summary>
        /// 从指定位置得到UNICODE字串
        /// </summary>
        /// <param name="offset"></param>
        /// <param name="len"></param>
        /// <returns></returns>
        public string getUnicodeString(int offset, int len)
        {
            byte[] tmp = new byte[len];
            int i;
            for (i = 0; i < len; i++)
            {
                tmp[i] = m_byBuf[offset + i];
            }
            byte[] by = new byte[i];
            for (int j = 0; j < i / 2; j++)
            {
                by[2 * j] = tmp[2 * j + 1];
                by[2 * j + 1] = tmp[2 * j];
            }

            UnicodeEncoding unicode = new UnicodeEncoding();

            return unicode.GetString(by, 0, by.Length);
        }

        /// <summary>
        /// 在指定位置设置byte数组
        /// </summary>
        /// <param name="offset"></param>
        /// <param name="len"></param>
        /// <param name="byVal"></param>
        /// <returns></returns>
        public bool setBytes(int offset, int len, byte[] byVal)
        {
            for (int i = 0; i < len; i++)
            {
                m_byBuf[offset + i] = byVal[i];
            }

            return true;
        }

        /// <summary>
        /// 从指定位置得到byte数组
        /// </summary>
        /// <param name="offset"></param>
        /// <param name="len"></param>
        /// <returns></returns>
        public byte[] getBytes(int offset, int len)
        {
            byte[] by = new byte[len];
            for (int i = 0; i < len; i++)
            {
                by[i] = m_byBuf[offset + i];
            }
            return by;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="ab"></param>
        /// <param name="offset"></param>
        /// <param name="len"></param>
        public void fillArrayStructWith(byte[] ab, int offset, int len)
        {
            for (int i = 0; i < len; i++)
            {
                if (offset + i >= ab.Length)
                {
                    break;
                }
                m_byBuf[i] = ab[offset + i];
            }
        }

        /// <summary>
        /// 返回整个byte数组
        /// </summary>
        /// <returns></returns>
        public byte[] convertToBytes()
        {
            return m_byBuf;
        }

        /// <summary>
        /// 打印数组
        /// </summary>
        /// <returns></returns>
        public string print()
        {
            string str = null;

            str += "       0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F";
            str += "\r\n--------------------------------------------------------";
            byte bTmp;
            char cTmp;
            int iCol = 16;
            for (int i = 0; i < m_byBuf.Length; i++)
            {
                if (iCol == 16)
                {
                    iCol = 0;
                    str += "\r\n";
                    if (i < 10) str += "000" + i;
                    else if (i < 100) str += "00" + i;
                    else str += "0" + i;

                    str += ":";
                }
                str += " ";
                //高4位
                bTmp = (byte)(m_byBuf[i] >> 4 & 0xFF);
                if (bTmp < 10)
                {
                    cTmp = (char)(bTmp + 48);
                }
                else
                {
                    cTmp = (char)(bTmp + 55);
                }
                str += cTmp;
                //低4位
                bTmp = (byte)(m_byBuf[i] & 0xF);
                if (bTmp < 10)
                {
                    cTmp = (char)(bTmp + 48);
                }
                else
                {
                    cTmp = (char)(bTmp + 55);
                }
                str += cTmp;
                iCol++;

            }
            Console.WriteLine(str + "\n\n");
            return str;
        }
    }
}