stream byte

最新推荐文章于 2025-08-12 14:30:08 发布

原创最新推荐文章于 2025-08-12 14:30:08 发布 · 946 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#stream #byte #list #string #buffer #file

Stream & Byte[]

在涉及IO操作时，Stream 和 Byte[] 是最常用的，以下就做一个简单纪录。

Byte[]
=====

1. BitConverter

将基础数据类型与字节数组相互转换。注意string不是基础类型，而且该方法在不同平台间传递可能有误。

int i = 13;
byte[] bs = BitConverter.GetBytes(i);
Console.WriteLine(BitConverter.ToInt32(bs, 0));

2. Encoding

注意慎用Encoding.Default，其值取自操作系统当前的设置，因此在不同语言版本的操作系统是不相同的。建议使用UTF8或者GetEncoding("gb2312")。

string s = "abc";
byte[] bs = Encoding.UTF8.GetBytes(s);
Console.WriteLine(Encoding.UTF8.GetString(bs));

3. BinaryFormatter

以二进制格式将对象或整个连接对象图形序列化和反序列化。

using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

[Serializable]
class Data
{
  private int x = 13;

  public void Test()
  {
    Console.WriteLine(x);
  }
}

static void Main(string[] args)
{
  Data data = new Data();

  MemoryStream stream = new MemoryStream();
  BinaryFormatter formatter = new BinaryFormatter();
  formatter.Serialize(stream, data);

  byte[] bs = stream.ToArray();

  MemoryStream stream2 = new MemoryStream(bs);
  Data data2 = (Data)formatter.Deserialize(stream2);
  data2.Test();
}

Stream
=====

Stream 包含 FileStream、MemoryStream、BufferedStream、NetworkStream、CryptoStream。
常用的方法和属性包括：Close / Flush / Seek / Read / Write / CanSeek等，可参考SDK。
Stream 并不能直接操作基元和对象类型，需要将其转换成Byte[]才能进行读写操作。以下记录几种转换方式。

byte[] bs = Encoding.UTF8.GetBytes("abc");

// 1. Byte[] to Stream
MemoryStream stream = new MemoryStream(bs);

// 2. Byte[] to Stream
MemoryStream stream2 = new MemoryStream();
stream2.Write(bs, 0, bs.Length);

// 3. Byte[] to Stream
FileStream stream3 = new FileStream("a.dat", FileMode.Create, FileAccess.ReadWrite);
stream3.Write(bs, 0, bs.Length);
stream3.Close();

// 4. Stream to Byte[]
byte[] bs2 = stream.ToArray();

// 5. Stream to Byte[] (Buffer Length = 256)
byte[] bs3 = stream2.GetBuffer();

// 6. Stream to Byte[]
FileStream stream4 = new FileStream("a.dat", FileMode.Open, FileAccess.Read);
stream4.Seek(0, SeekOrigin.Begin);
byte[] bs4 = new byte[3];
stream4.Read(bs4, 0, bs4.Length);

在.Net的IO操作中经常会用到Stream和Byte[]，有两种形式：
一.Stream->Byte[]：
1.如果Stream的 Length属性可读，非常的简单，代码如下：

    1
   
     
   private
    
   byte
   [] GetBytes(Stream stream)

    2
           
   
   {
 3            if (stream.CanSeek)
 4            {
 5                Byte[] buffer = new byte[stream.Length];
 6                stream.Write(buffer, 0, buffer.Length);
 7                return buffer;
 8            }
 9            //用下面的方法
10            return null;
11        }
  

2.如果Stream的 Length属性不可读，代码如下：

    1
   
           
   private
    
   byte
   [] GetBytes(Stream stream)

    2
           
   
   {
 3            using (MemoryStream mstream = new MemoryStream())
 4            {
 5                byte[] bytes = new byte[1024]; //此处不易设置太大或太小的值，且应该为2的次方
 6                if (stream.CanRead)
 7                {
 8                    while (true)
 9                    {
10                        int length = stream.Read(bytes, 0, bytes.Length);
11                        if (length <= 0)
12                        {
13                            break;
14                        }
15                        mstream.Write(bytes, 0, length);
16                    }
17                }
18                return mstream.ToArray();
19            }
20        }
   

   21
   
  

二.bytes-Stream:
直接使用内存流即可,代码如下：

MemoryStream ms = new MemoryStream(bytes)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
using System.IO;
using ProtoBuf;

namespace WindowsFormsApplication3
{
    static class Program
    {
        /// <summary>
        /// 应用程序的主入口点。
        /// </summary>
        [STAThread]
        static void Main()
        {
           List<User> list = new List<User>();
            for (int i = 0; i < 100; i++)
            {
                list.Add(new User() { UserID = i, UserName = "u" + i.ToString() });
            }

            MemoryStream stream2 = new MemoryStream();
            byte[] b =null;
            using (stream2) {

                Serializer.Serialize<List<User>>(stream2, list);
                b= stream2.GetBuffer();
                MessageBox.Show(b.Length.ToString());
            }

MemoryStream ms = new MemoryStream(b);

List<User> list3 = new List<User>();
using(ms){

list3 = Serializer.Deserialize<List<User>>(ms);
}

            foreach (User u in list3)
            {
                Console.WriteLine(string.Format("UserID={0}, UserName={1}", u.UserID, u.UserName));
            }

            //protobuff
            string path = AppDomain.CurrentDomain.BaseDirectory + "protobuf.txt";
            using (Stream file = File.Create(path))
            {

                Serializer.Serialize<List<User>>(file, list);



                file.Close();
            }

            List<User> list2 = new List<User>();
            using (Stream file = File.OpenRead(path))
            {
                list2 = Serializer.Deserialize<List<User>>(file);
            }

            foreach (User u in list2)
            {
                Console.WriteLine(string.Format("UserID={0}, UserName={1}", u.UserID, u.UserName));
            }

          // Console.ReadKey();
        }
    }

    [ProtoContract]
    public class User
    {
        [ProtoMember(1, IsRequired = true)]
        public int UserID { get; set; }

[ProtoMember(2, IsRequired = true)]
public string UserName { get; set; }

}