游戏实时网络通信实现【Socket与FlatBuffer协议】（二）

上篇介绍了字节与基本类型数据转换工具的编写。本篇来介绍Byte数组类的实现，Socket网络通信传输的就单元是字节数组，因此有必要对其进行封装。ByteArray既实现了对基本类型数据转换成Byte数组封装；也实现了对Byte数组转换成基本数据类型的封装。

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.IO;
using System;

 /*
  * Author:W
  * byte数组
  * 1.从内存流中读取基本类型数据【Byte数组-》基本数据类型】
  * 2.向内存流中写入基本类型数据【基本数据类型->Byte数组】
  */
namespace W.NetWork
{
	public class ByteArray
	{
		/// <summary>
		/// 内存流
		/// </summary>
		private MemoryStream memoryStream;
		/// <summary>
		/// 是否使用小端编码
		/// </summary>
		private bool isLittleEndian = true;

		/// <summary>
		/// 构造函数1
		/// </summary>
		/// <param name="capacity">字节大小</param>
		public ByteArray(int capacity)
		{
			memoryStream = new MemoryStream(capacity);
		}

		/// <summary>
		/// 构造函数2
		/// </summary>
		/// <param name="buffer">缓冲区大小</param>
		public ByteArray(byte[] buffer)
		{
			memoryStream = new MemoryStream(buffer);
		}

		/// <summary>
		/// 内存流的大小
		/// </summary>
		public int Length { get { return (int)memoryStream.Length; } }
		/// <summary>
		/// 内存流当前读写位置
		/// </summary>
		public int Position
		{
			set { memoryStream.Position = value; }
			get { return (int)memoryStream.Position; }
		}

		/// <summary>
		/// 内存流的当前缓冲区
		/// </summary>
		public byte[] Buffer { get { return memoryStream.ToArray(); } }

		/// <summary>
		/// 内存流对象
		/// </summary>
		public MemoryStream MemoryStream { get { return memoryStream; } }


		/// <summary>
		/// 读取一个字节
		/// </summary>
		/// <returns></returns>
		public byte ReadByte()
		{
			if (Position >= Length)
				Debug.LogError("流的位置已经超出了流的大小");

			return (byte)memoryStream.ReadByte();
		}

		/// <summary>
		/// 读取short型
		/// </summary>
		/// <returns></returns>
		public short ReadShort()
		{
			return ByteTool.ReadShort(memoryStream, isLittleEndian);
		}

		/// <summary>
		/// 读取ushort型
		/// </summary>
		/// <returns></returns>
		public ushort ReadUShort()
		{
			return ByteTool.ReadUShort(memoryStream,isLittleEndian);
		}

		/// <summary>
		/// 读取Int型
		/// </summary>
		/// <returns></returns>
		public int ReadInt()
		{
			return ByteTool.ReadInt(memoryStream,isLittleEndian);
		}

		/// <summary>
		/// 读取uint型
		/// </summary>
		/// <returns></returns>
		public uint ReadUInt()
		{
			return ByteTool.ReadUInt(memoryStream,isLittleEndian);
		}

		/// <summary>
		/// 读取long型
		/// </summary>
		/// <returns></returns>
		public long ReadLong()
		{
			return ByteTool.ReadLong(memoryStream,isLittleEndian);
		}

		/// <summary>
		/// 读取ulong型
		/// </summary>
		/// <returns></returns>
		public ulong ReadULong()
		{
			return ByteTool.ReadULong(memoryStream,isLittleEndian);
		}

		/// <summary>
		/// 读取float型
		/// </summary>
		/// <returns></returns>
		public float ReadFloat()
		{
			return ByteTool.ReadFloat(memoryStream,isLittleEndian);
		}

		/// <summary>
		/// 读取double型
		/// </summary>
		/// <returns></returns>
		public double ReadDouble()
		{
			return ByteTool.ReadDouble(memoryStream,isLittleEndian);
		}

		/// <summary>
		/// 读取utf-8编码的字符串
		/// </summary>
		/// <returns></returns>
		public string ReadUTFString()
		{
			return ByteTool.ReadString(memoryStream,"utf-8",isLittleEndian);
		}

		/// <summary>
		/// 向内存流中写入一个字节
		/// </summary>
		/// <param name="value"></param>
		public void WriteByte(byte value)
		{
			memoryStream.WriteByte(value);
		}

		/// <summary>
		/// 向内存流中写入一个sbyte
		/// </summary>
		/// <param name="value"></param>
		public void WriteSByte(sbyte value)
		{
			byte byteV = 0;
			if (value > 0)
			{
				byteV = (byte)value;
			}
			else
			{
				byteV = (byte)(value + 256);
			}

			memoryStream.WriteByte(byteV);
		}

		/// <summary>
		/// 向内存流中写入byte数组
		/// </summary>
		/// <param name="bytes"></param>
		public void WriteBytes(byte[] bytes)
		{
			ByteTool.WriteBytes(memoryStream,bytes,isLittleEndian);
		}

		/// <summary>
		/// 向内存流中写入一个short型数据
		/// </summary>
		/// <param name="value"></param>
		public void WriteShort(short value)
		{
			ByteTool.WriteShort(memoryStream,value,isLittleEndian);
		}

		/// <summary>
		/// 向内存流中写入一个ushort型数据
		/// </summary>
		/// <param name="value"></param>
		public void WriteUShort(ushort value)
		{
			ByteTool.WriteUShort(memoryStream,value,isLittleEndian);
		}

		/// <summary>
		/// 写入一个Int型
		/// </summary>
		/// <param name="value"></param>
		public void WriteInt(int value)
		{
			ByteTool.WriteInt(memoryStream,value,isLittleEndian);
		}

		/// <summary>
		/// 写入一个uint型
		/// </summary>
		/// <param name="value"></param>
		public void WriteUInt(uint value)
		{
			ByteTool.WriteUInt(memoryStream,value,isLittleEndian);
		}

		/// <summary>
		/// 写入long型
		/// </summary>
		/// <param name="value"></param>
		public void WriteLong(long value)
		{
			ByteTool.WriteLong(memoryStream,value,isLittleEndian);
		}

		/// <summary>
		/// 写入ulong型
		/// </summary>
		/// <param name="value"></param>
		public void WriteULong(ulong value)
		{
			ByteTool.WriteULong(memoryStream,value,isLittleEndian);
		}

		/// <summary>
		/// 写入float型
		/// </summary>
		/// <param name="value"></param>
		public void WriteFloat(float value)
		{
			ByteTool.WriteFloat(memoryStream,value,isLittleEndian);
		}

		/// <summary>
		/// 写入double型
		/// </summary>
		/// <param name="value"></param>
		public void WriteDouble(double value)
		{
			ByteTool.WriteDouble(memoryStream,value,isLittleEndian);
		}

		/// <summary>
		/// 写入字符串
		/// </summary>
		/// <param name="value"></param>
		public void WriteString(string value)
		{
			ByteTool.WriteString(memoryStream,value,"utf-8",isLittleEndian);
		}


		/// <summary>
		/// 内存流重置
		/// </summary>
		public void Reset()
		{
			Position = 0;
			memoryStream.SetLength(0);
		}

	}
}