MemoryStream有关内存数据的读写
MemoryStream内存数据的读写
电脑中最基本的单位是位（bit）,但位这个单位太小，所以字节(Byte)是电脑存储容量的基本计量单位。Byte可简写为B，一个字节右八个二进制组成，其最小值为0，最大值为11111111，一个存储单元能存储一个字节的内容。
基本的数据类型：byte 、short（2个字节） 、int（4个字节）、 long（8个字节）、float（4个字节）、double（个字节）、bool（1个字节）、string（若char则占1个字节，若汉字则占2个字节，视情况而定）。
内存读写原理：
往内存中写东西实际上，是把相应的数据类型转换成byte类型存到电脑上，从内存中读东西实际上是从把byte类型再转换为相应的类型。
C#本身在有个内存读写的类，叫MemoryStream。小规模的数据类型转换还好，但是数据类型变多使用起来就不太方便了。为了在项目中方便使用，我把基本数据类型和byte之间的相互转换封装成了一个类MMOMemoryStream。如下：
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.IO;
using System;
using System.Text;
/// <summary>
/// 数据转换（byte short int long float double bool string)
/// </summary>
public class MMOMemoryStream :MemoryStream
{
public MMOMemoryStream()
{ }
public MMOMemoryStream(byte[] buffer):base(buffer)
{ }
#region Short
/// <summary>
/// 从流中读取一个short数据
/// </summary>
/// <returns></returns>
public short ReadShort()
{
byte[] arr = new byte[2];
base.Read(arr, 0, 2);
return BitConverter.ToInt16(arr, 0);
}
/// <summary>
/// 把一个short数据写入流
/// </summary>
/// <param name="value"></param>
public void WriteShort(short value)
{
byte[] arr = BitConverter.GetBytes(value);
base.Write(arr, 0, arr.Length);
}
#endregion
#region UShort
/// <summary>
/// 从流中读取一个ushort数据
/// </summary>
/// <returns></returns>
public ushort ReadUShort()
{
byte[] arr = new byte[2];
base.Read(arr, 0, 2);
return BitConverter.ToUInt16(arr, 0);
}
/// <summary>
/// 把一个ushort数据写入流
/// </summary>
/// <param name="value"></param>
public void WriteUShort(ushort value)
{
byte[] arr = BitConverter.GetBytes(value);
base.Write(arr, 0, arr.Length);
}
#endregion
#region Int
/// <summary>
/// 从流中读取一个int数据
/// </summary>
/// <returns></returns>
public int ReadInt()
{
byte[] arr = new byte[4];
base.Read(arr, 0, 4);
return BitConverter.ToInt32(arr,0);
}
/// <summary>
/// 把一个int数据写入流
/// </summary>
/// <param name="value"></param>
public void WriteInt(int value)
{
byte[] arr = BitConverter.GetBytes(value);
base.Write(arr, 0, arr.Length);
}
#endregion
#region UInt
/// <summary>
/// 从流中读取一个uint数据
/// </summary>
/// <returns></returns>
public uint ReadUInt()
{
byte[] arr = new byte[4];
base.Read(arr, 0, 4);
return BitConverter.ToUInt32(arr, 0);
}
/// <summary>
/// 把一个uint数据写入流
/// </summary>
/// <param name="value"></param>
public void WriteUInt(uint value)
{
byte[] arr = BitConverter.GetBytes(value);
base.Write(arr, 0, arr.Length);
}
#endregion
#region Long
/// <summary>
/// 从流中读取一个long数据
/// </summary>
/// <returns></returns>
public long ReadLong()
{
byte[] arr = new byte[8];
base.Read(arr, 0, 8);
return BitConverter.ToInt64(arr, 0);
}
/// <summary>
/// 把一个long数据写入流
/// </summary>
/// <param name="value"></param>
public void WriteLong(long value)
{
byte[] arr = BitConverter.GetBytes(value);
base.Write(arr, 0, arr.Length);
}
#endregion
#region ULong
/// <summary>
/// 从流中读取一个ulong数据
/// </summary>
/// <returns></returns>
public ulong ReadULong()
{
byte[] arr = new byte[8];
base.Read(arr, 0, 8);
return BitConverter.ToUInt64(arr, 0);
}
/// <summary>
/// 把一个ulong数据写入流
/// </summary>
/// <param name="value"></param>
public void WriteULong(ulong value)
{
byte[] arr = BitConverter.GetBytes(value);
base.Write(arr, 0, arr.Length);
}
#endregion
#region Float
/// <summary>
/// 从流中读取一个float数据
/// </summary>
/// <returns></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"></param>
public void WriteFloat(float value)
{
byte[] arr = BitConverter.GetBytes(value);
base.Write(arr, 0, arr.Length);
}
#endregion
#region Double
/// <summary>
/// 从流中读取一个double数据
/// </summary>
/// <returns></returns>
public double ReadDouble()
{
byte[] arr = new byte[8];
base.Read(arr, 0, 8);
return BitConverter.ToDouble(arr, 0);
}
/// <summary>
/// 把一个double数据写入流
/// </summary>
/// <param name="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></returns>
public bool ReadBool()
{
return base.ReadByte()==1;
}
/// <summary>
/// 把一个bool数据写入流
/// </summary>
/// <param name="value"></param>
public void WriteBool(bool value)
{
base.WriteByte((byte)(value == true ? 1 : 0));
}
#endregion
#region UTF8String
/// <summary>
/// 从流中读取一个string数据
/// </summary>
/// <returns></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"></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
}
下面是我写的测试脚本，把类里面的数据写到内存，再从内存里读取出来。
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class Role
{
public int id;
public string name;
}
public class TestMMOMemoryStream : MonoBehaviour {
private void Start()
{
#region 写的操作
Role role = new Role() { id = 1, name = "笔圣" };
byte[] arr = null;
using (MMOMemoryStream ms = new MMOMemoryStream())
{
ms.WriteInt(role.id);
ms.WriteUTF8String(role.name);
arr = ms.ToArray();
}
//if (arr != null)
//{
// for (int i = 0; i < arr.Length; i++)
// {
// Debug.Log(string.Format("arr{0}={1}", i, arr[i]));
// }
//}
#endregion
#region 读的操作
Role role1 = new Role();
using (MMOMemoryStream ms = new MMOMemoryStream(arr))
{
role1.id = ms.ReadInt();
role1.name = ms.ReadUTF8String();
}
Debug.Log(string.Format("role1.id={0},role1.name={1}", role1.id, role1.name));
#endregion
}
}
写的结果如下图：
读的结果如下图：
