MemoryStream有关内存数据的读写

来源：互联网发布：农村淘宝物流编辑：程序博客网时间：2024/06/03 17:35

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

}

写的结果如下图：

读的结果如下图：

阅读全文

0 0