Unity从流中读取各种类型的数据和写入数据(利用MemoryStream关于内存数据的读写)

原创已于 2022-11-02 16:16:15 修改 · 4.3k 阅读

6 ·

CC 4.0 BY-SA版权

文章标签：

#unity #游戏引擎

于 2018-05-03 15:46:23 首次发布

基础专栏收录该内容

24 篇文章

订阅专栏

本文介绍如何在Unity中创建一个自定义的MemoryStream类，用于高效地处理各种基本数据类型的读写操作。通过继承.NET Framework中的MemoryStream类并进行扩展，可以方便地将自定义的数据结构序列化到内存流中，再从中反序列化出来。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1、主要是对MemoryStream.cs这个类的封装操作，自己重写了一个类继承自该MemoryStream类，并添加了对流写入short ,ushort,int,uint,long,ulong,float,double,bool,string等类型数据的写入和其在流中读取出该数据类型的方法。

using UnityEngine;
using System.Collections;
using System.IO;
using System;
using System.Text;
//数据转换
public class MyMemoryStream :MemoryStream
{
    public MyMemoryStream(byte[] buffer):base (buffer )
    {

    }
    public MyMemoryStream()
    {

    }
    #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="vaule"></param>
    public void WriteShort(short vaule)
    {
        byte[] arr = BitConverter.GetBytes (vaule);
        base.Write(arr, 0, arr.Length);
    }
    #endregion
    #region UShort
    /// <summary>
    /// 从流中读取一个short数据
    /// </summary>
    /// <returns></returns>
    public ushort ReadUShort()
    {
        byte[] arr = new byte[2];
        base.Read(arr, 0, 2);
        return BitConverter.ToUInt16(arr, 0);
    }
    /// <summary>
    /// 把一个short数据写入流
    /// </summary>
    /// <param name="vaule"></param>
    public void WriteUShort(ushort  vaule)
    {
        byte[] arr = BitConverter.GetBytes(vaule);
        base.Write(arr, 0, arr.Length);
    }
    #endregion
    #region Int
    /// <summary>
    /// 从流中读取一个short数据
    /// </summary>
    /// <returns></returns>
    public int  ReadInt()
    {
        byte[] arr = new byte[4];
        base.Read(arr, 0, 4);
        return BitConverter.ToInt32 (arr, 0);
    }
    /// <summary>
    /// 把一个short数据写入流
    /// </summary>
    /// <param name="vaule"></param>
    public void WriteInt(int  vaule)
    {
        byte[] arr = BitConverter.GetBytes(vaule);
        base.Write(arr, 0, arr.Length);
    }
    #endregion
    #region UInt
    /// <summary>
    /// 从流中读取一个short数据
    /// </summary>
    /// <returns></returns>
    public uint  ReadUInt()
    {
        byte[] arr = new byte[4];
        base.Read(arr, 0, 4);
        return BitConverter.ToUInt32(arr, 0);
    }
    /// <summary>
    /// 把一个short数据写入流
    /// </summary>
    /// <param name="vaule"></param>
    public void WriteUInt(uint  vaule)
    {
        byte[] arr = BitConverter.GetBytes(vaule);
        base.Write(arr, 0, arr.Length);
    }
    #endregion
    #region Long
    /// <summary>
    /// 从流中读取一个short数据
    /// </summary>
    /// <returns></returns>
    public long  ReadLong()
    {
        byte[] arr = new byte[8];
        base.Read(arr, 0, 8);
        return BitConverter.ToInt64(arr, 0);
    }
    /// <summary>
    /// 把一个short数据写入流
    /// </summary>
    /// <param name="vaule"></param>
    public void WriteLong(long  vaule)
    {
        byte[] arr = BitConverter.GetBytes(vaule);
        base.Write(arr, 0, arr.Length);
    }
    #endregion
    #region ULong
    /// <summary>
    /// 从流中读取一个short数据
    /// </summary>
    /// <returns></returns>
    public ulong  ReadULong()
    {
        byte[] arr = new byte[4];
        base.Read(arr, 0, 4);
        return BitConverter.ToUInt64(arr, 0);
    }
    /// <summary>
    /// 把一个short数据写入流
    /// </summary>
    /// <param name="vaule"></param>
    public void WriteULong(ulong vaule)
    {
        byte[] arr = BitConverter.GetBytes(vaule);
        base.Write(arr, 0, arr.Length);
    }
    #endregion
    #region Float
    /// <summary>
    /// 从流中读取一个short数据
    /// </summary>
    /// <returns></returns>
    public float  ReadFloat()
    {
        byte[] arr = new byte[4];
        base.Read(arr, 0, 4);
        return BitConverter.ToSingle (arr, 0);
    }
    /// <summary>
    /// 把一个short数据写入流
    /// </summary>
    /// <param name="vaule"></param>
    public void WriteFloat(float  vaule)
    {
        byte[] arr = BitConverter.GetBytes(vaule);
        base.Write(arr, 0, arr.Length);
    }
    #endregion
    #region Double
    /// <summary>
    /// 从流中读取一个short数据
    /// </summary>
    /// <returns></returns>
    public double  ReadDouble()
    {
        byte[] arr = new byte[8];
        base.Read(arr, 0, 8);
        return BitConverter.ToDouble (arr, 0);
    }
    /// <summary>
    /// 把一个short数据写入流
    /// </summary>
    /// <param name="vaule"></param>
    public void WriteDouble(double  vaule)
    {
        byte[] arr = BitConverter.GetBytes(vaule);
        base.Write(arr, 0, arr.Length);
    }
    #endregion
    #region Bool
    /// <summary>
    /// 从流中读取一个short数据
    /// </summary>
    /// <returns></returns>
    public bool  ReadBool()
    {
        return base.ReadByte() == 1;
    }
    /// <summary>
    /// 把一个short数据写入流
    /// </summary>
    /// <param name="vaule"></param>
    public void WriteBool(bool  vaule)
    {    
        base.WriteByte((byte )(vaule ==true ?1:0));
    }
    #endregion
    #region String
    /// <summary>
    /// 从流中读取一个short数据
    /// </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>
    /// 把一个short数据写入流
    /// </summary>
    /// <param name="vaule"></param>
    public void WriteString(string  vaule)
    {
        byte[] arr = Encoding.UTF8.GetBytes(vaule);
        if(arr.Length >65535)
        {
            throw new InvalidCastException("字符串超出范围");
        }
        this.WriteUShort((ushort)arr.Length);
        base.Write(arr, 0, arr.Length);
    }
    #endregion
}

2.应用例子，自己谢了一个Item的类，实例化一个该类并为其赋值，如下所示

using UnityEngine;
using System.Collections;

public class TestMemoryStream : MonoBehaviour {

	// Use this for initialization
	void Start ()
    {
        Item item = new Item();
        item.Id = 1;
        item.Name = "测试输出";
        byte[] arr = null;

        //向流中写入我们自己的数据类信息
        using (MyMemoryStream ms = new MyMemoryStream())
        {
            ms.WriteInt(item.Id);
            ms.WriteString(item.Name);
            arr = ms.ToArray();
        }

        //if(arr !=null )
        //{
        //    for (int i = 0; i < arr.Length ; i++)
        //    {
        //        Debug.Log(string.Format("{0}={1}", i, arr[i]));
        //    }
        //}
        //从流中读取出我们想要的信息
        using (MyMemoryStream ms = new MyMemoryStream(arr ))
        {
            int id = ms.ReadInt();
            string name = ms.ReadUTF8String();
            Debug.Log(string.Format("id={0}:Name={1}", id, name));
        }
	}
	
	// Update is called once per frame
	void Update () {
	
	}
}

public class Item
{
    public int Id;
    public string Name;
}

运行结果输出Log为;id=1:Name=测试输出