GHZMRClassXR/Assets/Scripts/Base/Web/Socket/BData/ByteDataArray.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.IO.Compression;

namespace Engine.Data
{
	public class ByteDataArray
	{

	    public const int BYTE_LEN = 1;
	    public const int SHORT16_LEN = 2;
	    public const int INT32_LEN = 4;
	    public const int FLOAT_LEN = 4;
	    public const int LONG_LEN = 8;
	    public const int DOUBLE_LEN = 8;

	    private byte[] data;

	    private int byteIndex = 0;

	    public ByteDataArray(byte[] bytes = null)
	    {
	        data = (bytes == null) ? new byte[0] : bytes;
	    }

	    /// <summary>byte[] 数据原</summary>
	    public byte[] Data
	    {
	        get { return data; }
	        set { data = value; }
	    }

	    /// <summary>可读字节数，修改读取位置可修改此值</summary>
	    public int ByteLength
	    {
	        get { return data.Length - byteIndex; }
	    }

	    /// <summary>总字节数据</summary>
	    public int Length
	    {
	        get { return data.Length; }
	    }

	    /// <summary>当前读取位置</summary>
	    public int Position
	    {
	        get { return byteIndex; }
	        set { byteIndex = value; }
	    }

	    public byte ReadByte()
	    {
	        return this.ReadBytes(byteIndex)[0];
	    }

	    public bool ReadBool()
	    {
	        byte bt = this.ReadByte();
	        return (bt == (byte)1) ? true : false;
	    }

	    public short ReadShort()
	    {
	        return BitConverter.ToInt16(this.ReadBytes(SHORT16_LEN), 0);
	    }

	    public int ReadInt()
	    {
	        return BitConverter.ToInt32(this.ReadBytes(INT32_LEN), 0);
	    }

	    public long ReadLong()
	    {
	        return BitConverter.ToInt64(this.ReadBytes(LONG_LEN), 0);
	    }

	    public float ReadFloat()
	    {
	        return BitConverter.ToSingle(this.ReadBytes(FLOAT_LEN), 0);
	    }

	    public double ReadDouble()
	    {
	        return BitConverter.ToDouble(this.ReadBytes(DOUBLE_LEN), 0);
	    }

	    public string ReadString()
	    {
	        return Encoding.UTF8.GetString(this.ReadBytes(this.ReadShort()));
	    }

	    public ByteDataArray ReadUnit(int leng)
	    {
	        return new ByteDataArray(this.ReadBytes(leng));
	    }

	    public byte[] ReadBytes(int leng)
	    {
	        if (leng > this.ByteLength)
	        {
	            throw new Exception("超出字节流长度");
	        }

	        //这里重复开辟了内存，会产生内存垃圾，可能会有性能问题
	        byte[] byets = new byte[leng];
	        for (int i = 0; i < leng; i++)
	        {
	            byets[i] = data[byteIndex];
	            byteIndex++;
	        }
	        return byets;
	    }

	    public void WriteByte(byte by)
	    {
	        byte[] bytes = new byte[BYTE_LEN];
	        bytes[0] = by;
	        this.WriteBytes(bytes);
	    }

	    public void WriteBool(bool flag)
	    {
	        byte b = (byte)0;
	        if (flag) b = (byte)1;

	        this.WriteByte(b);
	    }

	    public void WriteShort(short value)
	    {
	        byte[] bytes = BitConverter.GetBytes(value);
	        this.WriteBytes(bytes);
	    }

	    public void WriteInt(int value)
	    {
	        byte[] bytes = BitConverter.GetBytes(value);
	        this.WriteBytes(bytes);
	    }

	    public void WriteLong(int value)
	    {
	        byte[] bytes = BitConverter.GetBytes(value);
	        this.WriteBytes(bytes);
	    }

	    public void WriteDouble(int value)
	    {
	        byte[] bytes = BitConverter.GetBytes(value);
	        this.WriteBytes(bytes);
	    }

	    public void WriteFloat(int value)
	    {
	        byte[] bytes = BitConverter.GetBytes(value);
	        this.WriteBytes(bytes);
	    }

	    public void WriteString(string str)
	    {
	        short len = (short)Encoding.UTF8.GetByteCount(str);
	        this.WriteShort(len);
	        byte[] bytes = new byte[len];
	        Encoding.UTF8.GetBytes(str, 0, str.Length, bytes, 0);
	        this.WriteBytes(bytes);
	    }

	    public void WriteUnit(byte[] bytes)
	    {
	        this.WriteInt(bytes.Length);
	        this.WriteBytes(bytes);
	    }

	    public void WriteBytes(byte[] bytes)
	    {
	        byteIndex = data.Length;
	        int leng = bytes.Length;
	        //这里重复开辟了内存，会产生内存垃圾，可能会有性能问题
	        byte[] newData = new byte[byteIndex + leng];
	        data.CopyTo(newData, 0);
	        Array.Copy(bytes, 0, newData, byteIndex, leng);
	        data = newData;
	        byteIndex = data.Length;
	    }

	    public void Dispose()
	    {
	        data = null;
	    }

	    /// <summary>压缩字节流 zip压缩</summary>
	    public void Compress()
	    {

	    }

	    /// <summary>解压缩字节流</summary>
	    public void Decompress()
	    {

	    }
	}
}