黑马程序员技术交流社区

标题: C#、Unity网络通信中基于字节码的自定义协议解码 [打印本页]
作者: aisini    时间: 2014-7-28 18:39
标题: C#、Unity网络通信中基于字节码的自定义协议解码
       C#、Unity基于字节的网络通信中字节码解析类，类似java中的ByteBuffer，不过这个实现是参考的netty4中的ByteBuf类。
因为网络通道中是高字节序列，所以本类没有考虑低字节序列

  1. public class ByteBuffer
  2.     {
  3.         private byte[] buf;

  5.         private int readIndex = 0;
  6.         private int writeIndex = 0;
  7.         private int markReadIndex = 0;
  8.         private int markWirteIndex = 0;

  10.         private int capacity;

  12.         private ByteBuffer(int capacity)
  13.         {
  14.             buf = new byte[capacity];
  15.             this.capacity = capacity;
  16.         }

  18.         private ByteBuffer(byte[] bytes)
  19.         {
  20.             buf = bytes;
  21.             this.capacity = bytes.Length;
  22.         }

  24.         public static ByteBuffer Allocate(int capacity)
  25.         {
  26.             return new ByteBuffer(capacity);
  27.         }

  29.         public static ByteBuffer Allocate(byte[] bytes)
  30.         {
  31.             return new ByteBuffer(bytes);
  32.         }

  34.         public void Write(byte[] bytes)
  35.         {
  36.             int total = bytes.Length + writeIndex;
  37.             int len = buf.Length;
  38.             FixSizeAndReset(len, total);
  39.             for (int i = writeIndex, j = 0; i < total; i++, j++)
  40.             {
  41.                 buf[i] = bytes[j];
  42.             }
  43.             writeIndex = total;
  44.         }

  46.         private int FixLength(int length)
  47.         {
  48.             int n = 2;
  49.             int b = 2;
  50.             while( b < length) {
  51.                 b = 2 << n;
  52.                 n++;
  53.             }
  54.             return b;
  55.         }

  57.         private byte[] flip(byte[] bytes)
  58.         {
  59.             if (BitConverter.IsLittleEndian)
  60.             {
  61.                 Array.Reverse(bytes);
  62.             }
  63.             return bytes;
  64.         }

  66.         private int FixSizeAndReset(int currLen, int futureLen)
  67.         {
  68.             if (futureLen > currLen)
  69.             {
  70.                 byte[] newbuf = new byte[FixLength(currLen) * 2];
  71.                 Array.Copy(buf, 0, newbuf, 0, currLen);
  72.                 buf = newbuf;
  73.                 capacity = newbuf.Length;
  74.             }
  75.             return futureLen;
  76.         }

  78.         public void Write(ByteBuffer buffer)
  79.         {
  80.             if (buffer == null) return;
  81.             if (buffer.ReadableBytes() <= 0) return;
  82.             Write(buffer.ToArray());
  83.         }

  85.         public void WriteShort(short value)
  86.         {
  87.             Write(flip(BitConverter.GetBytes(value)));
  88.         }

  90.         public void WriteUshort(ushort value)
  91.         {
  92.             Write(flip(BitConverter.GetBytes(value)));
  93.         }

  95.         public void WriteInt(int value)
  96.         {
  97.             //byte[] array = new byte[4];
  98.             //for (int i = 3; i >= 0; i--)
  99.             //{
  100.             //    array[i] = (byte)(value & 0xff);
  101.             //    value = value >> 8;
  102.             //}
  103.             //Array.Reverse(array);
  104.             //Write(array);
  105.             Write(flip(BitConverter.GetBytes(value)));
  106.         }

  108.         public void WriteUint(uint value)
  109.         {
  110.             Write(flip(BitConverter.GetBytes(value)));
  111.         }

  113.         public void WriteLong(long value)
  114.         {
  115.             Write(flip(BitConverter.GetBytes(value)));
  116.         }

  118.         public void WriteUlong(ulong value)
  119.         {
  120.             Write(flip(BitConverter.GetBytes(value)));
  121.         }

  123.         public void WriteFloat(float value)
  124.         {
  125.             Write(flip(BitConverter.GetBytes(value)));
  126.         }

  128.         public void WriteByte(byte value)
  129.         {
  130.             int afterLen = writeIndex + 1;
  131.             int len = buf.Length;
  132.             FixSizeAndReset(len, afterLen);
  133.             buf[writeIndex] = value;
  134.             writeIndex = afterLen;
  135.         }

  137.         public void WriteDouble(double value)
  138.         {
  139.             Write(flip(BitConverter.GetBytes(value)));
  140.         }

  142.         public byte ReadByte()
  143.         {
  144.             byte b = buf[readIndex];
  145.             readIndex++;
  146.             return b;
  147.         }

  149.         public int ReadByteToInt()
  150.         {
  151.             return ReadByte();
  152.         }

  154.         private byte[] Read(int len)
  155.         {
  156.             byte[] bytes = new byte[len];
  157.             Array.Copy(buf, readIndex, bytes, 0, len);
  158.             if (BitConverter.IsLittleEndian)
  159.             {
  160.                 Array.Reverse(bytes);
  161.             }
  162.             readIndex += len;
  163.             return bytes;
  164.         }

  166.         public ushort ReadUshort()
  167.         {
  168.             return BitConverter.ToUInt16(Read(2), 0);
  169.         }

  171.         public short ReadShort()
  172.         {
  173.             return BitConverter.ToInt16(Read(2), 0);
  174.         }

  176.         public uint ReadUint()
  177.         {
  178.             return BitConverter.ToUInt32(Read(4), 0);
  179.         }

  181.         public int ReadInt()
  182.         {
  183.             return BitConverter.ToInt32(Read(4), 0);
  184.         }

  186.         public ulong ReadUlong()
  187.         {
  188.             return BitConverter.ToUInt64(Read(8), 0);
  189.         }

  191.         public long ReadLong()
  192.         {
  193.             return BitConverter.ToInt64(Read(8), 0);
  194.         }

  196.         public float ReadFloat()
  197.         {
  198.             return BitConverter.ToSingle(Read(4), 0);
  199.         }

  201.         public double ReadDouble()
  202.         {
  203.             return BitConverter.ToDouble(Read(8), 0);
  204.         }

  206.         public void ReadBytes(byte[] disbytes, int disstart, int len)
  207.         {
  208.             int size = disstart + len;
  209.             for (int i = disstart; i < size; i++)
  210.             {
  211.                 disbytes[i] = this.ReadByte();
  212.             }
  213.         }

  215.         public void DiscardReadBytes()
  216.         {
  217.             if(readIndex <= 0) return;
  218.             int len = buf.Length - readIndex;
  219.             byte[] newbuf = new byte[len];
  220.             Array.Copy(buf, readIndex, newbuf, 0, len);
  221.             buf = newbuf;
  222.             readIndex = 0;
  223.             writeIndex -= readIndex;
  224.             markReadIndex -= readIndex;
  225.             if (markReadIndex < 0)
  226.             {
  227.                 markReadIndex = readIndex;
  228.             }
  229.             markWirteIndex -= readIndex;
  230.             if (markWirteIndex < 0 || markWirteIndex < readIndex || markWirteIndex < markReadIndex)
  231.             {
  232.                 markWirteIndex = writeIndex;
  233.             }
  234.         }

  236.         public void Clear()
  237.         {
  238.             buf = new byte[buf.Length];
  239.             readIndex = 0;
  240.             writeIndex = 0;
  241.             markReadIndex = 0;
  242.             markWirteIndex = 0;
  243.         }

  245.         public void MarkReaderIndex()
  246.         {
  247.             markReadIndex = readIndex;
  248.         }

  250.         public void MarkWriterIndex()
  251.         {
  252.             markWirteIndex = writeIndex;
  253.         }

  255.         public void ResetReaderIndex()
  256.         {
  257.             readIndex = markReadIndex;
  258.         }

  260.         public void ResetWriterIndex()
  261.         {
  262.             writeIndex = markWirteIndex;
  263.         }

  265.         public int ReadableBytes()
  266.         {
  267.             return writeIndex - readIndex;
  268.         }

  270.         public byte[] ToArray()
  271.         {
  272.             byte[] bytes = new byte[writeIndex];
  273.             Array.Copy(buf, 0, bytes, 0, bytes.Length);
  274.             return bytes;
  275.         }

  277.         public int GetCapacity()
  278.         {
  279.             return this.capacity;
  280.         }
  281.     }
复制代码







欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2