[转载]C#流，字节数组，字符串

下面将用到的一些简单的转换操作贴上来，方便记忆 

流：二进制

字节：无符号整数

字符：Unicode编码字符

字符串：多个Unicode编码字符

那么在.net下它们之间如何转化呢？

一般是遵守以下规则：

流->字节数组->字符数组->字符串

下面就来具体谈谈转化的语法

流->字节数组

MemoryStream ms = new MemoryStream();
byte[] buffer = new byte[ms.Length];
ms.Read(buffer, 0, (int)ms.Length);

字节数组->流

byte[] buffer = new byte[10];
MemoryStream ms = new MemoryStream(buffer);

字节数组->字符数组

1.

byte[] buffer = new byte[10];
char[] ch = new ASCIIEncoding().GetChars(buffer);
//或者：char[] ch = Encoding.UTF8.GetChars(buffer)
2.
byte[] buffer = new byte[10];
char[] ch = new char[10];
for(int i=0; i<buffer.Length; i++)
{
    ch[i] = Convert.ToChar(buffer[i]);
}

字符数组->字节数组

1.
char[] ch = new char[10];
byte[] buffer = new ASCIIEncoding().GetBytes(ch);
//或者：byte[] buffer = Encoding.UTF8.GetBytes(ch)
2.
char[] ch = new char[10];
byte[] buffer = new byte[10];
for(int i=0; i<ch.Length; i++)
{
    buffer[i] = Convert.ToByte(ch[i]);
}
 

字符数组->字符串

har[] ch = new char[10];
string str = new string(ch);
 
 字符串->字符数组
string str = "abcde";
char[] ch=str .ToCharArray();
 
字节数组->字符串
byte[] buffer = new byte[10];
string str = System.Text.Encoding.UTF8.GetString(buffer);
//或者：string str = new ASCIIEncoding().GetString(buffer);
 
字符串->字节数组
string str = "abcde";
byte[] buffer=System.Text.Encoding.UTF8.GetBytes(str);
//或者：byte[] buffer= new ASCIIEncoding().GetBytes(str);

说明：主要就是用到了Convert类和System.Text命名空间下的类，Encoding是静态类,ASCIIEncoding是实体类，方法都是一样的！

下面介绍如何用BinaryReader来读写文件流

1. 写文件

 using (FileStream fs = File.Open("test.txt", FileMode.OpenOrCreate))
            {
                BinaryWriter bw = new BinaryWriter(fs, Encoding.UTF8);
                for (int i = 0; i < 10000000; i++)　　// 写入一千万行数据
                {
                    bw.Write(100.8); // 写入一个Double
                    bw.Write("abdef");　　// 写入一个String
                    bw.Write("poiu");　　// 再写一个String
                    bw.Write((float)88.9);　　　　// 写入一个float
                }
            }

2. 读取上面写入的文件,注意要对应写入数据类型要相匹配,读取顺序要相匹配

  using (FileStream fs = File.Open("test.txt", FileMode.Open))
            {
                BinaryReader br = new BinaryReader(fs, Encoding.UTF8);
                while (br.BaseStream.Length > br.BaseStream.Position) // 判断是否已读完
                {
                    Console.WriteLine(br.ReadDouble());
                    Console.WriteLine(br.ReadString());
                    Console.WriteLine(br.ReadString());
                    Console.WriteLine(br.ReadSingle());
                }
            }

引用：

你平时是怎么读取文件的？使用流读取。是的没错，C#给我们提供了非常强大的类库（又一次吹捧了.NET一番），里面封装了几乎所有我们可以想到的和我们没有想到的类，流是读取文件的一般手段，那么你真的会用它读取文件中的数据了么？真的能读完全么？

通常我们读取一个文件使用如下的步骤：

1、声明并使用File的OpenRead实例化一个文件流对象，就像下面这样

       FileStream fs = File.OpenRead(filename);

或者

       FileStream fs = FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read);

2、准备一个存放文件内容的字节数组，fs.Length将得到文件的实际大小，就像下面这样

       byte[] data = new byte[fs.Length];

3、哇！开始读了，调用一个文件流的一个方法读取数据到data数组中

       fs.Read (data, 0, data.Length);

呵呵！我们只写了3句就可以把文件里面的内容原封不动的读出来，真是太简洁了！可以这段代码真的能像你预期的那样工作么？答案是：几乎可以！在大部分情况下上面的代码工作的很好，但是我们应该注意Read方法是有返回值的，既然有返回值那么一定有其道理，如果按照上面的写法完全可以是一个没有返回值的函数。我想返回值的目的是，为了给我们一个机会判断实际读取文件的大小，从而来判断文件是否已经完全读完。所以上面的代码不能保证我们一定读完了文件里面的所有字节（虽然在很多情况下是读完了）。下面的方法提供了一个比上面方法更安全的方法，来保证文件被完全读出

public static void SafeRead (Stream stream, byte[] data){
    int offset=0;
    int remaining = data.Length;
       // 只要有剩余的字节就不停的读
    while (remaining > 0){
        int read = stream.Read(data, offset, remaining);
        if (read <= 0)
            throw new EndOfStreamException("文件读取到"+read.ToString()+"失败！");
              // 减少剩余的字节数
        remaining -= read;
              // 增加偏移量
        offset += read;
    }
}

有些情况下你不知道流实际的长度比如：网络流。此时可以使用类似的方法读取流直到流里面的数据完全读取出来为止。我们可以先初始化一段缓存，再将流读出来的流信息写到内存流里面，就像下面这样：

public static byte[] ReadFully (Stream stream){
       // 初始化一个32k的缓存
    byte[] buffer = new byte[32768];
    using (MemoryStream ms = new MemoryStream()){ //返回结果后会自动回收调用该对象的Dispose方法释放内存
              // 不停的读取
        while (true){
            int read = stream.Read (buffer, 0, buffer.Length);
                     // 直到读取完最后的3M数据就可以返回结果了
            if (read <= 0)
                return ms.ToArray();
            ms.Write (buffer, 0, read);
        }
    }
}

虽然上面的例子都比较简单，效果也不是很明显（大部分都是对的），也许你早就会了，没关系这篇文章本来就是写给初学者的。

下面的方法提供了一种使用指定缓存长度的方式读取流，虽然在很多情况下你可以直接使用Stream.Length得到流的长度，但是不是所有的流都可以得到。

public static byte[] Read2Buffer (Stream stream, int BufferLen){
       // 如果指定的无效长度的缓冲区，则指定一个默认的长度作为缓存大小
       if (BufferLen < 1){
              BufferLen = 0x8000;
       }
       // 初始化一个缓存区
       byte[] buffer = new byte[BufferLen];
       int read=0;  
       int block;
       // 每次从流中读取缓存大小的数据，知道读取完所有的流为止
       while ( (block = stream.Read(buffer, read, buffer.Length-read)) > 0){
              // 重新设定读取位置
              read += block;
     
              // 检查是否到达了缓存的边界，检查是否还有可以读取的信息
              if (read == buffer.Length){
                     // 尝试读取一个字节
                     int nextByte = stream.ReadByte();
         
                     // 读取失败则说明读取完成可以返回结果
                     if (nextByte==-1){
                            return buffer;
                     }
         
                     // 调整数组大小准备继续读取
                     byte[] newBuf = new byte[buffer.Length*2];
                     Array.Copy(buffer, newBuf, buffer.Length);
                     newBuf[read]=(byte)nextByte;
                     buffer = newBuf;// buffer是一个引用（指针），这里意在重新设定buffer指针指向一个更大的内存
                     read++;
              }
       }
       // 如果缓存太大则使用ret来收缩前面while读取的buffer，然后直接返回
       byte[] ret = new byte[read];
       Array.Copy(buffer, ret, read);
       return ret;
}