字节流转化工具

// 工具
public class MemoryStreamTool : MemoryStream
{
#region 构造方法

public MemoryStreamTool ()
{

}

public MemoryStreamTool (byte[] buffer) : base (buffer)
{

}

#endregion

#region Int

/// <summary>
/// 从流中读取一个Int数据
/// </summary>
/// <returns>The int.</returns>
public int ReadInt ()
{
    byte[] arr = new byte[4];
    base.Read (arr, 0, arr.Length);
    return BitConverter.ToInt32 (arr, 0);
}

/// <summary>
/// 把一个int数据写入流
/// </summary>
/// <param name="value">Value.</param>
public void WriteInt (int value)
{
    byte[] arr = BitConverter.GetBytes (value);
    base.Write (arr, 0, arr.Length);
}

#endregion

#region Ushort

/// <summary>
/// 从流中读取一个Ushort数据
/// </summary>
/// <returns>The int.</returns>
public ushort ReadUshort ()
{
    byte[] arr = new byte[2];
    base.Read (arr, 0, arr.Length);
    return BitConverter.ToUInt16 (arr, 0);
}

/// <summary>
/// 把一个Ushort数据写入流
/// </summary>
/// <param name="value">Value.</param>
public void WriteUshort (ushort value)
{       
    byte[] arr = BitConverter.GetBytes (value);
    base.Write (arr, 0, arr.Length);
}

#endregion

#region Float

/// <summary>
/// 从流中读取一个Float数据
/// </summary>
/// <returns>The int.</returns>
public float ReadFloat ()
{
    byte[] arr = new byte[4];
    base.Read (arr, 0, 4);
    return BitConverter.ToSingle (arr, 0);
}

/// <summary>
/// 把一个Float数据写入流
/// </summary>
/// <param name="value">Value.</param>
public void WriteFloat (float value)
{
    byte[] arr = BitConverter.GetBytes (value);
    base.Write (arr, 0, 4);
}

#endregion

#region Double

/// <summary>
/// 从流中读取一个Double数据
/// </summary>
/// <returns>The int.</returns>
public double ReadDouble ()
{
    byte[] arr = new byte[8];
    base.Read (arr, 0, arr.Length);
    return BitConverter.ToDouble (arr, 0);
}

/// <summary>
/// 把一个Double数据写入流
/// </summary>
/// <param name="value">Value.</param>
public void WriteDouble (double value)
{
    byte[] arr = BitConverter.GetBytes (value);
    base.Write (arr, 0, arr.Length);
}

#endregion

#region Bool

/// <summary>
/// 从流中读取一个Bool数据
/// </summary>
/// <returns>The int.</returns>
public bool ReadBool ()
{
    return this.ReadByte () == 1;
}

/// <summary>
/// 把一个Bool数据写入流
/// </summary>
/// <param name="value">Value.</param>
public void WriteBool (bool value)
{
    this.WriteByte ((byte)(value == true ? 1 : 0));
}

#endregion

#region String

/// <summary>
/// 从流中读取一个String数据
/// </summary>
/// <returns>The int.</returns>
public string ReadUTF8String ()
{
    ushort len = this.ReadUshort ();
    byte[] arr = new byte[len];
    base.Read (arr, 0, len);
    return Encoding.UTF8.GetString (arr);
}

/// <summary>
/// 把一个String数据写入流
/// </summary>
/// <param name="value">Value.</param>
public void WriteUTF8String (string str)
{
    byte[] arr = Encoding.UTF8.GetBytes (str);
    if (arr.Length > 65535) {
        throw new InvalidCastException ("字符串超出范围");
    }
    this.WriteUshort ((ushort)arr.Length);
    base.Write (arr, 0, arr.Length);
}

#endregion
}

使用测试

/// <summary>
/// 测试工具是否可用
/// </summary>
public class TestModel
{
    public int ID;
    public string Name;
    public float Price;
    public bool IsFailed;
}
/// <summary>
/// 通过协议编号来区分协议
/// </summary>
public interface IProtocal
{
    // 协议编号
    ushort ProtoCode{ get; }
}

/// <summary>
/// 协议
/// </summary>
public struct TestProto:IProtocal
{
    public ushort ProtoCode{ get { return 1001; } }

public int ID;
public string Name;
public int Type;
public float Price;

// 转成字节流以传输
public byte[] ToArray ()
{
    byte[] data = null;
    using (MemoryStreamTool ms = new MemoryStreamTool ()) {
        ms.WriteInt (ID);
        ms.WriteUTF8String (Name);
        ms.WriteInt (Type);
        ms.WriteFloat (Price);
        data = ms.ToArray ();
    }
    return data;
}

// 解析字节流
public static TestProto GetProto (byte[] buffer)
{
    TestProto proto = new TestProto ();
    using (MemoryStreamTool ms = new MemoryStreamTool (buffer)) {
        proto.ID = ms.ReadInt ();
        proto.Name = ms.ReadUTF8String ();
        proto.Type = ms.ReadInt ();
        proto.Price = ms.ReadFloat ();
    }
    return proto;
}
}

public class BytesTest : MonoBehaviour
{
// 测试一：工具在本地是否可用
//  void Start ()
//  {
//      // 测试写入
//      TestModel item = new TestModel (){ ID = 15, Name = "好机会jiuh", Price = 12.25f, IsFailed = false };
//      byte[] arrWrite = null;
//      using (MemoryStreamTool ms = new MemoryStreamTool ()) {
//          ms.WriteInt (item.ID);
//          ms.WriteUTF8String (item.Name);
//          ms.WriteFloat (item.Price);
//          ms.WriteBool (item.IsFailed);
//          arrWrite = ms.ToArray ();
//      }
//
//      // 测试读出
//      TestModel item2 = new TestModel ();
//      using (MemoryStreamTool ms = new MemoryStreamTool (arrWrite)) {
//          item2.ID = ms.ReadInt ();
//          item2.Name = ms.ReadUTF8String ();
//          item2.Price = ms.ReadFloat ();
//          item2.IsFailed = ms.ReadBool ();
//      }
//      print (item2.ID);
//      print (item2.Name);
//      print (item2.Price);
//      print (item2.IsFailed);
//  }

// 测试二：协议的测试使用
void Start ()
{
    TestProto proto = new TestProto (){ ID = 5, Name = "阿萨德", Type = 89, Price = 12.56f };

    byte[] buffer = null;

    buffer = proto.ToArray ();

    print ("---------->" + buffer.Length);

    TestProto proto2 = TestProto.GetProto (buffer);
    print (proto2.ID);
    print (proto2.Name);
    print (proto2.Type);
    print (proto2.Price);
}
}