C# 实现流写入器 CBytesWriter

CBytesWriter

using System;

namespace Common
{
    /// <summary>
    /// author  :   Jave.Lin
    /// date    :   2018-03-24
    /// </summary>
    public class CBytesWriter : IDisposable
    {
        public static bool IsLittleEndian // return true
        {
            get { return BitConverter.IsLittleEndian; }
        }

        private int _m_iPos;
        private byte[] _m_pBuffer;
        private int _m_iIdx;
        private int _m_iLen;

        public int iRealPos { get { return _m_iIdx + _m_iPos; } }
        public int iPos { get { return _m_iPos; } set { _m_iPos = value; } }
        public int iLen { get { return _m_iLen; } }
        public int iBuffRemain { get { return Math.Max(_m_iLen - (_m_iIdx + _m_iPos), 0); } }

        public CBytesWriter(byte[] buffer, int idx = 0, int len = 0)
        {
            SetBuffer(buffer, idx, len);
        }

        public void Dispose()
        {
            _m_pBuffer = null;
        }

        public void SetBuffer(byte[] buffer, int idx = 0, int len = 0)
        {
            _m_pBuffer = buffer;
            _m_iIdx = idx;
            _m_iLen = len == 0 ? _m_pBuffer.Length : len;
            _m_iPos = 0;
            _checkBuffLen(_m_iLen);
        }

        /// <summary>
        /// Attention, it will change original-buffer data!
        /// </summary>
        /// <param name="idx">reset the offset index of writting</param>
        public void TrimtWritten()
        {
            var remain = iBuffRemain;
            var rpos = iRealPos;
            if (remain > 0)
            {
                Buffer.BlockCopy(_m_pBuffer, rpos, _m_pBuffer, _m_iIdx, remain);
            }

            _m_iPos = 0;
        }
        public void WriteChar(char value)
        {
            _checkBuffRemain(2);
            BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
            _m_iPos += 2;
        }
        public void WriteChar(char[] value)
        {
            _checkBuffRemain(2);
            BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
            _m_iPos += 2 * value.Length;
        }
        public void WriteBool(bool value)
        {
            _checkBuffRemain(1);
            BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
            _m_iPos += 1;
        }
        public void WriteBool(bool[] value)
        {
            _checkBuffRemain(1);
            BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
            _m_iPos += value.Length;
        }
        public void WriteSByte(sbyte value)
        {
            _checkBuffRemain(1);
            BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
            _m_iPos += 1;
        }
        public void WriteByte(byte value)
        {
            _checkBuffRemain(1);
            BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
            _m_iPos += 1;
        }

        /// <summary>
        /// Buffer.BlockCopy(writeBuf, writeIdxd, _m_pBuffer, _m_iIdx + _m_iPos, writeLen);
        /// </summary>
        public void WriteBytes(byte[] writeBuf, int writeIdxd, int writeLen)
        {
            if (writeBuf == null)
            {
                _throwErr(this.GetType().FullName + " WriteBytes argument: writeBuf == null");
            }
            if (writeLen > (_m_pBuffer.Length - iRealPos))
            {
                _throwErr(this.GetType().FullName + " WriteBytes argument: writeLen too large");
            }
            _checkBuffRemain(writeLen);
            Buffer.BlockCopy(writeBuf, writeIdxd, _m_pBuffer, _m_iIdx + _m_iPos, writeLen);
            _m_iPos += writeLen;
        }

        public void WriteInt16(short value)
        {
            _checkBuffRemain(2);
            BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
            _m_iPos += 2;
        }

        public void WriteUInt16(ushort value)
        {
            _checkBuffRemain(2);
            BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
            _m_iPos += 2;
        }
        public void WriteUInt16(ushort[] value)
        {
            _checkBuffRemain(2);
            BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
            _m_iPos += 2 * value.Length;
        }

        public void WriteInt32(int value)
        {
            _checkBuffRemain(4);
            BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
            _m_iPos += 4;
        }
        public void WriteInt32(int[] value)
        {
            _checkBuffRemain(4);
            BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
            _m_iPos += 4 * value.Length;
        }

        public void WriteUInt32(uint value)
        {
            _checkBuffRemain(4);
            BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
            _m_iPos += 4;
        }
        public void WriteUInt32(uint[] value)
        {
            _checkBuffRemain(4);
            BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
            _m_iPos += 4 * value.Length;
        }

        public void WriteInt64(long value)
        {
            _checkBuffRemain(8);
            BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
            _m_iPos += 8;
        }
        public void WriteInt64(long[] value)
        {
            _checkBuffRemain(8);
            BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
            _m_iPos += 8 * value.Length;
        }

        public void WriteUInt64(ulong value)
        {
            _checkBuffRemain(8);
            BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
            _m_iPos += 8;
        }
        public void WriteUInt64(ulong[] value)
        {
            _checkBuffRemain(8);
            BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
            _m_iPos += 8 * value.Length;
        }

        public void WriteSingle(float value)
        {
            _checkBuffRemain(4);
            BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
            _m_iPos += 4;
        }
        public void WriteSingle(float[] value)
        {
            _checkBuffRemain(4);
            BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
            _m_iPos += 4 * value.Length;
        }

        public void WriteDouble(double value)
        {
            _checkBuffRemain(8);
            BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
            _m_iPos += 8;
        }
        public void WriteDouble(double[] value)
        {
            _checkBuffRemain(8);
            BitConverterExt.GetBytes(_m_pBuffer, value, _m_iIdx + _m_iPos);
            _m_iPos += 8 * value.Length;
        }

        private void _checkBuffRemain(int value)
        {
            if (iBuffRemain < value)
            {
                _throwErr(this.GetType().FullName + " EOB (End of Byte[])");
            }
        }

        private void _checkBuffLen(int value)
        {
            if (value > iBuffRemain)
            {
                _throwErr(this.GetType().FullName + " set write buffer's len larger than buffer.Length");
            }
        }

        private void _throwErr(string errMsg)
        {
            throw new Exception(errMsg);
        }
    }
}

应用

            var one = false;
            var two = true;
            var three = true;
            var four = false;
            var arrBool = new bool[3] { true, false, true };

            var bytes = new byte[200];

            var pos = 0;
            BitConverterExt.GetBytes(bytes, one, 0);
            BitConverterExt.GetBytes(bytes, two, pos += sizeof(bool));
            BitConverterExt.GetBytes(bytes, three, pos += sizeof(bool));
            BitConverterExt.GetBytes(bytes, four, pos += sizeof(bool));
            BitConverterExt.GetBytes(bytes, 'a', pos += sizeof(bool));
            BitConverterExt.GetBytes(bytes, arrBool, pos += sizeof(char));
            BitConverterExt.GetBytes(bytes, (ushort)0xf0ff, pos += sizeof(bool) * 3);
            BitConverterExt.GetBytes(bytes, new char[] { 'A', 'B' }, pos += sizeof(ushort));
            BitConverterExt.GetBytes(bytes, new ushort[] { 0xff, 0x8 }, pos += sizeof(char) * 2);
            BitConverterExt.GetBytes(bytes, 0xff, pos += sizeof(ushort) * 2);
            BitConverterExt.GetBytes(bytes, 0xffffffu, pos += sizeof(int));
            BitConverterExt.GetBytes(bytes, 0.999f, pos += sizeof(uint));
            BitConverterExt.GetBytes(bytes, 0.999D, pos += sizeof(float));
            BitConverterExt.GetBytes(bytes, new int[] { 1, 2, 3, 4 }, pos += sizeof(double));
            BitConverterExt.GetBytes(bytes, new uint[] { 5, 6, 7, 8 }, pos += sizeof(int) * 4);
            BitConverterExt.GetBytes(bytes, new float[] { 0.1f, 0.2f, 0.3f, 0.4f }, pos += sizeof(uint) * 4);
            BitConverterExt.GetBytes(bytes, new double[] { 0.1d, 0.2d, 0.3d, 0.4d }, pos += sizeof(float) * 4);
            BitConverterExt.GetBytes(bytes, new long[] { 0xff, 0xffff, 0xffffff, 0xffffffff }, pos += sizeof(double) * 4);
            BitConverterExt.GetBytes(bytes, new ulong[] { 0xffff, 0xffffff, 0xffffffff, 0xffffffffff }, pos += sizeof(long) * 4);

            var bytes1 = new byte[200];
            var writer = new CBytesWriter(bytes1);
            writer.WriteBool(one);
            writer.WriteBool(two);
            writer.WriteBool(three);
            writer.WriteBool(four);
            writer.WriteChar('a');
            writer.WriteBool(arrBool);
            writer.WriteUInt16((ushort)0xf0ff);
            writer.WriteChar(new char[] { 'A', 'B' });
            writer.WriteUInt16(new ushort[] { 0xff, 0x8 });
            writer.WriteInt32(0xff);
            writer.WriteUInt32(0xffffffu);
            writer.WriteSingle(0.999f);
            writer.WriteDouble(0.999D);
            writer.WriteInt32(new int[] { 1, 2, 3, 4 });
            writer.WriteUInt32(new uint[] { 5, 6, 7, 8 });
            writer.WriteSingle(new float[] { 0.1f, 0.2f, 0.3f, 0.4f });
            writer.WriteDouble(new double[] { 0.1d, 0.2d, 0.3d, 0.4d });
            writer.WriteInt64(new long[] { 0xff, 0xffff, 0xffffff, 0xffffffff });
            writer.WriteUInt64(new ulong[] { 0xffff, 0xffffff, 0xffffffff, 0xffffffffff });

            var equal = Equal(bytes, bytes1);

            private static bool Equal(byte[] a, byte[] b)
            {
                if (a.Length != b.Length) return false;
                for (int i = 0, len = a.Length; i < len; ++i)
                {
                    if (a[i] != b[i]) return false;
                }
                return true;
            }

输出

+       bytes   {byte[200]} byte[]
+       bytes1  {byte[200]} byte[]
        equal   true    bool
+       writer  {Common.CBytesWriter}   Common.CBytesWriter