C#的字节与流

计算机中文件有很多种，我们知道实际存在计算机中的都是二进制。这里我记录了通过流对文件的读取操作。

一、首先在这里简单涉及下位，字节，字符的概念。

位（bit）：可以表示0或1；

字节（byte）：由8位组成（bit），可以表示0-255，是256个不同的数据；

字符：字符根据编码的不同有所区别；

ANSI编码（本地化）：它是支持本地的编码方式，不同 ANSI 编码之间互不兼容。在简体中文系统下，ANSI 编码代表 GB2312 编码，在日文操作系统下，ANSI 编码代表 JIS 编码。对于字符来说ANSI以单字节存放英文字符，以双字节存放中文等字符。

Unicoide编码：Unicode下，英文和中文的字符都以双字节存放。用来给 UNICODE 字符集编码的标准有很多种，比如：UTF-8, UTF-7, UTF-16, UnicodeLittle, UnicodeBig 等。

UTF-8：是表示一个字符是可变的,有可能是用一个字节表示一个字符，也可能是两个，三个。当然最多不能超过3个字节了。反正是根据字符对应的数字大小来确定。

UTF-16：任何字符对应的数字都用两个字节来保存。

二、C# Stream流的主要用途就是与应用程序外部的文件或者数据源进行数据交互。

     有文件流FileStream，网络流NetwrokStream，访问网络时InputStream，OutputStream等。流的内部就是对二进制数据的读取。

流可以一次性读取，也可以循环读取。

一次性读取：

 public void Read()
 {
     string filePath = Environment.CurrentDirectory + "/content.txt";
     Stream source = new FileStream(filePath, FileMode.Open, FileAccess.Read);  
 
     byte[] buffer = new byte[source.Length];
     int bytesRead = source.Read(buffer, , (int)source.Length);  
 
     Output(buffer);
 } 

循环读取：

 public void ReadLoop()
  {
      string filePath = Environment.CurrentDirectory + "/content.txt";
      string fileDest = Environment.CurrentDirectory + "/dest.txt";
      Stream source = new FileStream(filePath, FileMode.Open, FileAccess.Read);
      Stream destStream = new FileStream(fileDest, FileMode.Create, FileAccess.Write);  
 
      int bufferSize = ;
      byte[] buffer = new byte[bufferSize];
     int bytesREad;
     while((bytesREad= source.Read(buffer, , bufferSize)>))
        {
            destStream.Write(buffer, , bytesREad);
        }
     source.Dispose();
     destStream.Dispose();
 } 

StreamReader， StreamWriter。StringReader， StringWriter。它们是流的包装器类，方便对流的读取。以下是示例代码：

 public void StreamReaderRead()
 {
     string filePath = Environment.CurrentDirectory + "/content.txt";
     Stream source = new FileStream(filePath, FileMode.Open, FileAccess.Read);
     StreamReader sr = new StreamReader(source);//Stream包装器类
     string text = sr.ReadToEnd();  
 
     Console.Write(text);
 } 

 public void StreamWriterWrite()
 {
     string filePath = Environment.CurrentDirectory + "/content.txt";
     string fileDest = Environment.CurrentDirectory + "/dest1.txt";  
 
     Stream source = new FileStream(filePath, FileMode.Open, FileAccess.Read);  
 
     StreamReader sr = new StreamReader(source);//Stream包装器类
     string text = sr.ReadToEnd();  
 
     StreamWriter sw = new StreamWriter(fileDest);//Stream包装器类
     sw.Write(text);
     sw.Flush();
     sw.Close();
 } 

     三、二进制字节流读写封装

完成以下功能:

• 只针对内存字节流的读写，主要应用于数据的解析和写入。
• 提供不同数据类型的读写接口，包括byte，short，int，float，string等。
• 处理了大小端数据转换的问题，所以可用于网络数据的解析和发送。

 using System.IO;
 using System.Net;
 using System;
 
 namespace Framework
 {
     public class NetStream
     {
         private MemoryStream stream;
         private BinaryReader reader;
         private BinaryWriter writer;
 
         public NetStream(byte[] buffer = null)
         {
             if (buffer == null)
             {
                 this.stream = new MemoryStream();
             }
             else
             {
                 this.stream = new MemoryStream(buffer);
             }
 
             this.reader = new BinaryReader(this.stream);
             this.writer = new BinaryWriter(this.stream);
         }
 
         public void Close()
         {
             this.stream.Close();
             this.reader.Close();
             this.writer.Close();
         }
 
 //-------------------------------------------------------------------------------
 
         public long ReadInt64()
         {
             return IPAddress.HostToNetworkOrder(this.reader.ReadInt64());
         }
 
         public int ReadInt32()
         {
             return IPAddress.HostToNetworkOrder(this.reader.ReadInt32());
         }
 
         public short ReadInt16()
         {
             return IPAddress.HostToNetworkOrder(this.reader.ReadInt16());
         }
 
         public byte ReadByte()
         {
             return this.reader.ReadByte();
         }
 
         public float ReadFloat()
         {
             return this.reader.ReadSingle();
         }
 
         public string ReadString8()
         {
             return System.Text.Encoding.UTF8.GetString(this.reader.ReadBytes(ReadByte()));
         }
 
         public string ReadString16()
         {
             return System.Text.Encoding.UTF8.GetString(this.reader.ReadBytes(ReadInt16()));
         }
 
         public long Seek(long offset)
         {
             return this.stream.Seek(offset, SeekOrigin.Begin);
         }
 
 //-------------------------------------------------------------------------------
 
         public void WriteByte(byte value)
         {
             this.writer.Write(value);
         } 
 
         public void WriteInt16(short value)
         {
             this.writer.Write(BitConverter.GetBytes(IPAddress.HostToNetworkOrder(value)));
         }
 
         public void WriteInt32(int value)
         {
             this.writer.Write(BitConverter.GetBytes(IPAddress.HostToNetworkOrder(value)));
         }
 
         public void WriteInt64(long value)
         {
             this.writer.Write(BitConverter.GetBytes(IPAddress.HostToNetworkOrder(value)));
         }
 
         public void WriteFloat(float value)
         {
             this.writer.Write(value);
         }
 
         public void WriteString8(string value)
         {
             byte[] byteArray = System.Text.Encoding.UTF8.GetBytes(value);
 
             WriteByte((byte) byteArray.Length);
 
             this.writer.Write(byteArray);
         }
 
         public void WriteString16(string value)
         {
             byte[] byteArray = System.Text.Encoding.UTF8.GetBytes(value);
 
             WriteInt16((short) byteArray.Length);
 
             this.writer.Write(byteArray);
         }
 
         public byte[] GetBuffer()
         {
             return this.stream.ToArray();
         }
 
         public int GetLength()
         {
             return (int) this.stream.Length;
         }
     }
 }

转载链接：http://blog.csdn.net/qq_26054303/article/details/53019064

　　　　  http://blog.csdn.net/tom_221x/article/details/72330107