如何去理解 FileStream ?
我们磁盘的中任何文件都是通过2进制组成，最为直观的便是记事本了，当我们新建一个记事本时，它的大小是0KB, 我们每次输入一个数字或字母时文件便会自动增大4kb,可见随着我们输入的内容越来越多，文件也会相应增大，同理当我们删除文件内容时，文件也会相应减小。你肯定会问：谁将内容以怎么样的形式放到文件中去了？好问题，还记得第一篇流的概念么？对了，真实世界的一群鱼可以通过河流来往于各个地方，FileStream也是一样，byte可以通过FileStream进行传输，这样我们便能在计算机上对任何文件进行一系列的操作了。
FileStream 的重要性
FileStream 顾名思义文件流，我们电脑上的文件都可以通过文件流进行操作，例如文件的复制，剪切，粘贴，删除, 本地文件上传，下载,等许多重要的功能都离不开文件流,所以文件流不仅在本机上非常重要，在如今的网络世界也是万万不能缺少的。
（文件流无法直接通过网络进行传输，而是通过网络流将客户端上传的文件传到服务器端接收，然后通过文件流进行处理，下载正好相反）
FileStream 常用构造函数
FileStream(SafeFileHandle, FileAccess)
参数 SafeFileHandle是当前 FileStream 对象将封装的文件的文件句柄。这样的解释可能大家一头雾水，别急，大家先不要去理睬这深邃的含义，只要知道这个类型是c#非托管资源，它能够调用非托管资源的方法，而且不属于c#回收机制，所以我们必须使用GC手动或其他方式（Finalize 或Dispose方法）进行非托管资源的回收，所以SafeFileHandle是个默默无闻的保镖 ，一直暗中保护FileStream和文件的安全。
为了能让大家更好的理解这个保镖，请看第一段代码：
static void Main(string[] args)
{
FileStream fs = new FileStream(@"d:\000.txt", FileMode.OpenOrCreate);
Console.ReadLine();
// 下面这条代码将会抛出异常
File.Delete(@"d:\000.txt");
}
会什么会报错呢？因为FileStream并没有被释放，系统不知道这个文件是否还有用﹐所以帮我们保护这个文件。(非托管资源SafeFileHandle所使用的内存还被程序占用着) 所以SafeFileHandled 在内部保护了这个文件从而报出了这个异常，如果我们将流关闭后，这个问题也就不存在了。
static void Main(string[] args)
{
FileStream fs = new FileStream(@"d:\000.txt", FileMode.OpenOrCreate);
var data = fs.SafeFileHandle;
Console.ReadLine();
fs.Close();
File.Delete(@"d:\000.txt");
}
可以看见stream.SafeFileHandle的IsClose属性变成true了，也就是说这时候可以安全的删除文件了。所以又回到了一个老问题上面，我们每次使用完FileStream后都必须将他关闭并释放资源。
FileStream(String, FileMode)
String：文件所在的地址
FIleMode：是个枚举，表示如何打开或创建文件
|
成员名称 |
说明 |
| Append | 打开现有文件并查找到文件尾，或创建新文件。FileMode.Append 只能同 FileAccess.Write 一起使用。 |
| Create | 指定操作系统应创建新文件。如果文件已存在，它将被改写。（等效于这样的请求：如果文件不存在，则使用 CreateNew；否则使用 Truncate。） |
| CreateNew | 指定操作系统应创建新文件。如果文件已存在，则将引发 IOException。 |
| Open | 指定操作系统应打开现有文件。如果该文件不存在，则引发 System.IO.FileNotFoundException。 |
| OpenOrCreate | 指定操作系统应打开文件（如果文件存在）；否则，应创建新文件。 |
| Truncate | 指定操作系统应打开现有文件。文件一旦打开，就将被截断为零字节大小。试图从使用 Truncate 打开的文件中进行读取将导致异常。 |
FileStream(IntPtr, FileAccess, Boolean ownsHandle)
FileAccess：是一个枚举, 表示对于该文件的操作权限。
| ReadWrite | 对文件的读访问和写访问。可从文件读取数据和将数据写入文件。 |
| Write | 文件的写访问。可将数据写入文件。同 Read组合即构成读写访问权。 |
| Read | 对文件的读访问。可从文件中读取数据。同 Write组合即构成读写访问权。 |
ownsHandle：类似于前面和大家介绍的SafeFileHandler。
对于指定的文件句柄，操作系统不允许所请求的 access，例如，当 access 为 Write 或 ReadWrite 而文件句柄设置为只读访问时，会报出异常。所以 ownsHandle 才是老大，FileAccess的权限应该在ownsHandle的范围之内。
FileStream(String, FileMode, FileAccess, FileShare)
FileShare：同样是个枚举类型：确定文件如何由进程共享。
| Delete | 允许随后删除文件。 |
| Inheritable | 使文件句柄可由子进程继承。Win32 不直接支持此功能。 |
| None | 谢绝共享当前文件。文件关闭前，打开该文件的任何请求（由此进程或另一进程发出的请求）都将失败。 |
| Read | 允许随后打开文件读取。如果未指定此标志，则文件关闭前，任何打开该文件以进行读取的请求（由此进程或另一进程发出的请求）都将失败。但是，即使指定了此标志，仍可能需要附加权限才能够访问该文件。 |
| ReadWrite | 允许随后打开文件读取或写入。如果未指定此标志，则文件关闭前，任何打开该文件以进行读取或写入的请求（由此进程或另一进程发出）都将失败。但是，即使指定了此标志，仍可能需要附加权限才能够访问该文件。 |
| Write | 允许随后打开文件写入。如果未指定此标志，则文件关闭前，任何打开该文件以进行写入的请求（由此进程或另一进过程发出的请求）都将失败。但是，即使指定了此标志，仍可能需要附加权限才能够访问该文件。 |
FileStream(String, FileMode, FileAccess, FileShare, Int32, Boolean async )
Int32：这是一个缓冲区的大小，大家可以按照自己的需要定制。
Boolean async：是否异步读写，告诉FileStream实例，是否采用异步读写。
FileStream(String, FileMode, FileAccess, FileShare, Int32, FileOptions)
FileOptions：这是类似于FileStream对于文件操作的高级选项。
FileStream 常用属性
CanRead ：指示FileStream是否可以读操作
CanSeek：指示FileStream是否可以跟踪查找流操作
IsAsync：FileStream是否同步工作还是异步工作
Name：FileStream的名字，只读属性
ReadTimeout ：设置读取超时时间
SafeFileHandle : 文件安全句柄，只读属性
position：当前FileStream所在的流位置
FileStream 常用方法
以下方法重写了Stream的一些虚方法（这里不再叙述）
1：IAsyncResult BeginRead 异步读取
2：IAsyncResult BeginWrite 异步写
3：void Close 关闭当前FileStream
4：void EndRead 异步读结束
5：void EndWrite 异步写结束
6：void Flush 立刻释放缓冲区，将数据全部导出到基础流（文件中）
7：int Read 一般读取
8：int ReadByte 读取单个字节
9：long Seek 跟踪查找流所在的位置
10：void SetLength 设置FileStream的长度
11：void Write 一般写
12：void WriteByte写入单个字节
FileStream独有的方法
FileSecurity GetAccessControl()
不是很常用，FileSecurity 是文件安全类，直接表达当前文件的访问控制列表（ACL）的符合当前文件权限的项目。
void Lock(long position,long length)
这个Lock方法和线程中的Look关键字很不一样，它能够锁住文件中的某一部分，非常的强悍！用了这个方法我们能够精确锁定住我们需要锁住的文件的部分内容。
void SetAccessControl(FileSecurity fileSecurity)
和GetAccessControl很相似。
void Unlock (long position,long length)
正好和lock方法相反，对于文件进行部分解锁。
示例：文件本地分段上传
将一个文件作为整体进行操作，这样会带来一个问题，当文件很大或者网络不是很稳定的时候会发生意想不到的错误。那我们该怎么解决这一问题呢？其实有种思路还是不错的，那就是分段传输：
做一下这个示例进行测试：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
namespace ConsoleApplication1
{
/// <summary>
/// 文件分段上传示例
/// </summary>
class UpFileSingleTest
{
/// <summary>
/// 定义Buffer为1000
/// </summary>
public const int BUFFER_COUNT = 1000;
/// <summary>
/// 将文件上传至服务器（本地），由于采取分段传输，
/// 所以每段必须有一个起始位置和相对应该数据段的数据
/// </summary>
/// <param name="filePath">服务器上文件地址</param>
/// <param name="startPositon">分段起始位置</param>
/// <param name="btArray">每段的数据</param>
private void WriteToServer(string filePath, int startPositon, byte[] btArray)
{
FileStream fileStream = new FileStream(filePath, FileMode.OpenOrCreate);
using (fileStream)
{
// 将流的位置设置在该段起始位置
fileStream.Position = startPositon;
// 将该段数据通过 FileStream 写入文件中，每次写一段的数据
// 就好比是个水池，分段蓄水一样，直到蓄满为止
fileStream.Write(btArray, 0, btArray.Length);
}
}
/// <summary>
/// 处理单独一段本地数据上传至服务器的逻辑
/// 根据客户端传入的startPostion和totalCount来处理相应段的数据上传至服务器（本地）
/// </summary>
/// <param name="localFilePath">本地需要上传的文件地址</param>
/// <param name="uploadFilePath">服务器（本地）目标地址</param>
/// <param name="startPostion">该段起始位置</param>
/// <param name="totalCount">该段最大数据量</param>
public void UpLoadFileFromLocal(string localFilePath, string uploadFilePath, int startPostion, int totalCount)
{
// 每次临时读取数据数
int tempReadCount = 0;
int tempBuffer = 0;
// 定义一个缓冲区数组
byte[] bufferByteArray = new byte[BUFFER_COUNT];
FileStream fileStream = new FileStream(localFilePath, FileMode.Open);
// 将流的位置设置在每段数据的初始位置
fileStream.Position = startPostion;
using (fileStream)
{
// 循环将该段数据读出再写入服务器中
while (tempReadCount < totalCount)
{
tempBuffer = BUFFER_COUNT;
// 每段起始位置+每次循环读取数据的长度
var writeStartPosition = startPostion + tempReadCount;
// 当缓冲区的数据加上临时读取数大于该段数据量时，
// 则设置缓冲区的数据为totalCount-tempReadCount 这一段的数据
if (tempBuffer + tempReadCount > totalCount)
{
// 缓冲区的数据为 totalCount - tempReadCount
tempBuffer = totalCount - tempReadCount;
// 读取该段数据放入bufferByteArray数组中
fileStream.Read(bufferByteArray, 0, tempBuffer);
if (tempBuffer > 0)
{
byte[] newTempBtArray = new byte[tempBuffer];
Array.Copy(bufferByteArray, 0, newTempBtArray, 0, tempBuffer);
// 将缓冲区的数据上传至服务器
this.WriteToServer(uploadFilePath, writeStartPosition, newTempBtArray);
}
}
// 如果缓冲区的数据量小于该段数据量，并且tempBuffer=设定BUFFER_COUNT时，通过
// while 循环每次读取一样的buffer值的数据写入服务器中，直到将该段数据全部处理完毕
else if (tempBuffer == BUFFER_COUNT)
{
fileStream.Read(bufferByteArray, 0, tempBuffer);
this.WriteToServer(uploadFilePath, writeStartPosition, bufferByteArray);
}
// 通过每次的缓冲区数据，累计增加临时读取数
tempReadCount += tempBuffer;
}
}
}
}
}
static void Main(string[] args)
{
UpFileSingleTest test = new UpFileSingleTest();
FileInfo info = new FileInfo(@"d:\902421284.rmvb");
// 取得文件总长度
var fileLegth = info.Length;
// 假设将文件切成5段
var divide = 5;
// 取到每个文件段的长度
var perFileLengh = (int)fileLegth / divide;
// 表示最后剩下的文件段长度比perFileLengh小
var restCount = (int)fileLegth % divide;
// 循环上传数据
for (int i = 0; i < divide + 1; i++)
{
// 每次定义不同的数据段,假设数据长度是500，那么每段的开始位置都是i*perFileLength
var startPosition = i * perFileLengh;
// 取得每次数据段的数据量
var totalCount = fileLegth - perFileLengh * i > perFileLengh ? perFileLengh : (int)(fileLegth - perFileLengh * i);
// 上传该段数据
test.UpLoadFileFromLocal(@"d:\902421284.rmvb", @"d:\902421284_new.rmvb", startPosition, i == divide ? divide : totalCount);
}
}
分段传输比直接传输复杂许多，再加入多线程，这样的话每段数据的传输都能通过一个线程单独处理，能够提升上传性能和速度。