相关文章推荐
小百科  ›  MemoryStream有关内存数据的读写_memorystream read write_笔圣的博客
arr param
小眼睛的苹果
1 年前

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

写的结果如下图：

读的结果如下图：

MemoryStream内存数据的读写   电脑中最基本的单位是位（bit）,但位这个单位太小，所以字节(Byte)是电脑存储容量的基本计量单位。Byte可简写为B，一个字节右八个二进制组成，其最小值为0，最大值为11111111，一个存储单元能存储一个字节的内容。   基本的数据类型：byte 、short（2个字节） 、int（4个字节）、long（8个字节）、float（4个 1. 首先，在项目中安装EPPlus包。 2. 然后，创建一个控制器处理导出 数据 。在控制器中，可以使用Entity Framework或其他ORM库从 数据 库中检索所需 数据 。 3. 接下来，使用EPPlus创建一个新的Excel文档，并创建一个工作表。 4. 再然后，将从 数据 库中检索到的 数据 填充到工作表中。使用适当的 数据 类型格式化单元格。 5. 最后，将Excel文档保存到服务器上的某个位置，然后将其提供给用户进行下载。 下面是一个示例控制器代码： public ActionResult ExportToExcel() var dataList = dbContext.MyTable.ToList(); var excelPackage = new ExcelPackage(); var worksheet = excelPackage.Workbook.Worksheets.Add("My Data"); worksheet.Cells[1, 1].Value = "Column 1"; worksheet.Cells[1, 2].Value = "Column 2"; worksheet.Cells[1, 3].Value = "Column 3"; int rowIndex = 2; foreach (var dataItem in dataList) worksheet.Cells[rowIndex, 1].Value = dataItem.Column1; worksheet.Cells[rowIndex, 2].Value = dataItem.Column2; worksheet.Cells[rowIndex, 3].Value = dataItem.Column3; rowIndex++; var memory Stream = new Memory Stream (); excelPackage.SaveAs( memory Stream ); memory Stream .Position = 0; return File( memory Stream , "application/vnd.openxmlformats-officedocument.sp read sheetml.sheet", "MyData.xlsx"); 这个示例将从名为"MyTable"的表中检索 数据 ，并将它们填充到一个名为"My Data"的Excel工作表中。最后，它将Excel文档返回给用户进行下载。
 
推荐文章
Link管理   ·   51好读   ·   Sov5搜索   ·   小百科
小百科 - 百科知识指南