FileStream相关知识分享

一、如何理解filestream

通过前3章的学些，相信大家对于stream已经有一定的了解，但是又如何去理解filestream呢？请看下图：

 

 我们磁盘中的任何文件都是通过二进制数组组成，最为直观的就是记事本了，当我们新建一个记事本时，它的大小时0kb，我们每次输入一个数字或字母时，文件便会自动增大到4kb，可见，随着我们输入的内容越来越多，文件也会越来越大，同理，当我们删除文件内容时，文件也会相应的减小，对了，聪明的你肯定会问：谁将内容以怎样的形式放到文件中去了？

好问题，还记得第一章流的概念嘛？对了，真实世界的一群鱼可以通过河流往前往各个地方，filestream也一样，byte可以通过filestream进行传输，这样我们便能在计算机上对任何文件进行一系列操作了。

二、filestream的重要性

filestream顾名思义文件流，我们电脑上的文件都可以通过文件流进行操作，例如文件的复制、简介、粘贴、删除、本地文件上传、下载、等许多重要的功能都离不开文件流。所以文件流不仅在本机上非常重要，在如今的网络世界上也万万不能缺少的，想象一下我们开启虚拟机后，直接从本地复制一个文件到虚拟机上，时多么的方便，如果没有文件流，这个将难以想象。（大家别误解，文件流通过网络流将客户都安上传的文件传到服务器端接收，然后通过文件流进行处理，下载正好相反）

三、filestream常用构造函数介绍

1、filestream(safefilehandle safefilehandle,fileaccess fileaccess)

非托管参数safefilehandle简单介绍

safefilehandle：是一个文件安全句柄，这样的解释可能大家一头雾水，别急，大家先不要去理睬这深邃的含义，只要知道这个类型是c#非托管资源，也就是说它能够调用非托管资源的方法，而且不属于c#回收机制，所以我们必须使用gc手动或其他方式（finalize或dispose方法）进行非托管资源的回收，所以safefilehandle是一个默默无闻的保镖，一直暗中保护filestream和文件的安全，为了让大家更好的理解这个保镖，请看第一段代码：

 

1         static void main(string[] args)
2         {
3             var rootpath = environment.currentdirectory;
4             var filename = path.combine(rootpath, "textfile1.txt");//@"textfile1.txt";
5             filestream filestream = new filestream(filename, filemode.openorcreate);
6             console.readline();
7             file.delete(filename);
8             console.readkey();
9         }

我们运行一下，结果报错了，我看看一下错误：

 

 为什么会报错呢？其实程序被卡在了console.readline()这里，filestream并没有被释放，系统不知道这个文件是否还有用，所以帮我们保护这个文件（那个非托管资源safefilehandle所使用的内存还被占用着）所以safefilehandle在内部保护了这个文件从而报出了这个异常，如果我们将流关闭后，这个问题就不存在了。

所以，我们又回到了一个老问题上面，我们每次使用完filestream后都必须将他关闭并释放资源。

2、filestream(string str,filemodel model)

string 参数表示文件所在的地址，filemode是个枚举，表示确定如何打开或创建文件 。

filemodel枚举参数包含以下内容：

成员名称	说明
append	打开现有文件并查找到文件尾，或创建新文件。filemode.append 只能同 fileaccess.write 一起使用。
create	指定操作系统应创建新文件。如果文件已存在，它将被改写。这要求 fileiopermissionaccess.write。 system.io.filemode.create 等效于这样的请求：如果文件不存在，则使用 createnew；否则使用 truncate。
createnew	指定操作系统应创建新文件。此操作需要 fileiopermissionaccess.write。如果文件已存在，则将引发 ioexception。
open	指定操作系统应打开现有文件。打开文件的能力取决于 fileaccess   所指定的值。如果该文件不存在， 则引发 system.io.filenotfoundexception。
openorcreate	指定操作系统应打开文件（如果文件存在）；否则，应创建新文件。如果用 fileaccess.read   打开文件，则需要  fileiopermissionaccess.read。如果文件访问为 fileaccess.write 或 fileaccess.readwrite，则需要 fileiopermissionaccess.write。如果文件访问为 fileaccess.append，则需要 fileiopermissionaccess.append。
truncate	指定操作系统应打开现有文件。文件一旦打开，就将被截断为零字节大小。此操作需要 fileiopermissionaccess.write。 试图从使用 truncate 打开的文件中进行读取将导致异常。

 3、filestream(intptr intptr,fileaccess fileaccess,boolean ownshandle)

fileaccess参数也是一个枚举，表示对该文件的操作权限：

 

 参数ownshandle：也就是类似于前面和大家介绍的safefilehandler，有2点必须注意：（1）对于指定的文件句柄，操作系统不允许所请求的access，例如：当access为write或readwrite而文件句柄设置为只读访问的时候，会出现异常。所以ownshandle才是老大，fileaccess的权限应该在ownshandle的范围内。（2）filestream假定它的句柄有独占控制权，当filestream也持有句柄时，读取、写入或查找可能会导致数据破坏，为了数据安全，请使用句柄前调用flush，并避免在使用完句柄后调用close以外的任何方法。

4、filestream(string str,filemodel model,fileaccess,fileaccess,fileshare fileshare)

fileshare：同样时一个枚举类型，确定文件如何由进程共享。

delete	允许随后删除文件。
inheritable	使文件句柄可由子进程继承。win32 不直接支持此功能。
none	谢绝共享当前文件。文件关闭前，打开该文件的任何请求（由此进程或另一进程发出的请求）都将失败。
read	允许随后打开文件读取。如果未指定此标志，则文件关闭前，任何打开该文件以进行读取的请求（由此进程或另一进程发出的请求）都将失败。但是，即使指定了此标志，仍可能需要附加权限才能够访问该文件。
readwrite	允许随后打开文件读取或写入。如果未指定此标志，则文件关闭前，任何打开该文件以进行读取或写入的请求（由此进程或另一进程发出）都将失败。但是，即使指定了此标志，仍可能需要附加权限才能够访问该文件。
write	允许随后打开文件写入。如果未指定此标志，则文件关闭前，任何打开该文件以进行写入的请求（由此进程或另一进过程发出的请求）都将失败。但是，即使指定了此标志，仍可能需要附加权限才能够访问该文件。

5、filestream(string str,filemode mode,fileaccess fileaccess,fileshare fileshare,int32 i,boolean async)

int32:这是一个缓冲区的大小，大家可以按照自己的需要定制；

boolean async：是否异步读写，告诉filestream示例，是否采用异步读写

6、filestream(string str,filemode mode,fileshare fileshare,int32 i,fileoption fileoption)

fileoption:这是类似于filestream对于我呢见操作的高级选项

四、filestream常用属性介绍

1、canread：指示filestream是否可以读操作

2、canseek：指示filestream是否可以跟踪查找流操作

3、isasync：filestream是否同步工作还是异步工作

4、name：filestream的名字，只读属性

5、readtimeout：设置读取超时时间

6、safefilehandle：文件安全句柄，只读属性

7、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独有的方法

1、filesecurity getaccesscontrol()

这个不是很常用，filesecurity时文件安全类，直接表达当前文件的访问控制列表（acl）的复合当前文件权限的项目，acl大家有个了解就行，以后会单独和大家讨论下acl方面的知识

2、void lock(long position,long length)

这个lock方法和线程中的lock关键字很不一样，它能够锁住文件中的某一部分，非常的强悍！用了这个方法我们能够精确锁定住我们要锁住的文件的部分内容

3、void setaccesscontrol(filesecurity filesecurity)

和getaccesscontrol很相似，acl技术会再以后单独介绍

4、void unlock(long position,long length)

正好和lock方法相反，对于文件部分的解锁

七、文件的新建和拷贝（主要演示文件同步和异步操作）

首先我们尝试diy一个ifileconfig

 

1     public interface ifileconfig
2     {
3         string filename { get; set; }
4         bool isasync { get; set; }
5     }

 创建文件配置类createfileconfig，用于添加文件一些配置设置，实现添加文件的操作

 1     public class createfileconfig : ifileconfig
 2     {
 3         /// <summary>
 4         /// 文件名称
 5         /// </summary>
 6         public string filename { get; set; }
 7         /// <summary>
 8         /// 是否异步
 9         /// </summary>
10         public bool isasync { get; set; }
11         /// <summary>
12         /// 创建文件所在url
13         /// </summary>
14         public string createurl { get; set; }
15     }

让我们定义一个文件流测试类：filestreamtest来实现文件的操作。

1     /// <summary>
2     /// 文件测试类
3     /// </summary>
4     public class filestreamtest

在该类中实现一个简单的create方法，用来同步或异步的实现添加文件，filestream会根据配置类去选择相应的构造函数，实现异步或同步的添加方式

 1         /// <summary>
 2         /// 添加文件方法
 3         /// </summary>
 4         /// <param name="config"></param>
 5         public void create(ifileconfig config)
 6         {
 7             lock (_lockobject)
 8             {
 9                 //得到创建文件配置的对象
10                 var createfileconfig = config as createfileconfig;
11                 //假设创建完文件后写入一段话，实际项目中无需这么做，这里只是演示
12                 char[] insertcontent = "hellowword".tochararray();
13                 if (createfileconfig == null)
14                 {
15                     return;
16                 }
17                 //转化成byte[]
18                 byte[] bytearraycontent = encoding.default.getbytes(insertcontent, 0, insertcontent.length);
19                 //根据传入的配置文件来决定是否同步或者异步实例化stream对象
20                 filestream stream = createfileconfig.isasync
21                     ? new filestream(createfileconfig.createurl, filemode.create, fileaccess.readwrite, fileshare.none,
22                         4096, true)
23                     : new filestream(createfileconfig.createurl, filemode.create);
24                 using (stream)
25                 {
26                     //如果不注释下面代码会抛出异常，google上提示是writetimeout只支持网络流
27                     //stream.writetimeout=read_or_write_timeout;
28                     //如果流是同步并且可写
29                     if (!stream.isasync && stream.canwrite)
30                     {
31                         stream.write(bytearraycontent, 0, bytearraycontent.length);
32                     }
33                     else if (stream.canwrite)//异步可写
34                     {
35                         stream.beginwrite(bytearraycontent, 0, bytearraycontent.length, end_createfilecallback, stream);
36                     }
37                 }
38             }
39         }

如果采用异步的方式则最后会进入end_createfilecallback回调方法，result asyncstate 对象就是上图stream.beginwrite()方法的最后一个参数。还有一点必须注意的是每一次使用beginwrite()方法都要带上endwrite()方法，read方法也一样

 1         /// <summary>
 2         /// 异步写文件callback方法
 3         /// </summary>
 4         /// <param name="result"></param>
 5         private void end_createfilecallback(iasyncresult result)
 6         {
 7             //从iasyncresult对象中得到原来的filestream
 8             var stream = result.asyncstate as filestream;
 9             //结束异步写
10             if (stream != null)
11             {
12                 console.writeline("异步创建文件地址{0}", stream.name);
13                 stream.endwrite(result);
14             }
15 
16             console.readkey();
17         }

文件复制的方式思路比较相似，首先定义复制文件配置类，由于在异步回调中用到该配置类的属性，所以新增了文件流对象和相应的字节数组

 1         /// <summary>
 2         /// 异步读文件方法
 3         /// </summary>
 4         /// <param name="result"></param>
 5         private void end_readfilecallback(iasyncresult result)
 6         {
 7             //得到先前的配置文件
 8             var config = result.asyncstate as copyfileconfig;
 9             //结束异步读
10             config?.originalfilestream.endread(result);
11             //异步读后立即写入新文件地址
12             if (config != null)
13             {
14                 filestream copystream = new filestream(config.destinationfileurl, filemode.createnew, fileaccess.write, fileshare.write, 4096, true);
15                 using (copystream)
16                 {
17                     console.writeline("异步复制原文件地址：{0}", config.originalfilestream.name);
18                     console.writeline("复制后的新文件地址：{0}", config.destinationfileurl);
19                     //调用异步写方法callback方法为end_createfilecallback，参数是copystream
20                     copystream.beginwrite(config.originalfilebytes, 0, config.originalfilebytes.length,
21                         end_createfilecallback, copystream);
22                 }
23             }
24         }

然后在filestreamtest类中新增一个copy方法实现文件的复制功能

 1         /// <summary>
 2         /// 复制文件
 3         /// </summary>
 4         /// <param name="config"></param>
 5         public void copy(ifileconfig config)
 6         {
 7             lock (_lockobject)
 8             {
 9                 //得到copyfileconfig对象
10                 var copyfileconfig = config as copyfileconfig;
11                 if (copyfileconfig == null)
12                 {
13                     return;
14                 }
15                 //创建同步或异步流
16                 filestream stream = copyfileconfig.isasync
17                     ? new filestream(copyfileconfig.originalfileurl, filemode.open, fileaccess.read, fileshare.read,
18                         4096, true)
19                     : new filestream(copyfileconfig.originalfileurl, filemode.open);
20                 //定义一个byte数组接收从原文件读取的byte数据
21                 byte[] originalfilebytes = new byte[stream.length];
22                 using (stream)
23                 {
24                     //如果异步流
25                     if (stream.isasync)
26                     {
27                         //将该流和流独处的byte[]数据放入配置类，在callback中可以使用
28                         copyfileconfig.originalfilestream = stream;
29                         copyfileconfig.originalfilebytes = originalfilebytes;
30                         if (stream.canread)
31                         {
32                             //异步开始读取，读取完后进入end_readfilecallback方法，该方法接收copyfileconfig参数
33                             stream.beginread(originalfilebytes, 0, originalfilebytes.length, end_readfilecallback,
34                                 copyfileconfig);
35                         }
36                         else//否则同步读取
37                         {
38                             if (stream.canread)
39                             {
40                                 //读取原文件
41                                 stream.read(originalfilebytes, 0, originalfilebytes.length);
42                             }
43                             //定义一个写流，在新位置中创建一个文件
44                             filestream copystream = new filestream(copyfileconfig.destinationfileurl, filemode.createnew);
45                             using (copystream)
46                             {
47                                 //将原文件的内容写进新文件
48                                 copystream.write(originalfilebytes, 0, originalfilebytes.length);
49                             }
50                         }
51 
52                         console.readline();
53                     }
54                 }
55             }
56         }

最后，如果采用异步的方式，则会进入end_readfilecallback回调函数进行异步读取和异步写操作

 1         /// <summary>
 2         /// 异步读文件方法
 3         /// </summary>
 4         /// <param name="result"></param>
 5         private void end_readfilecallback(iasyncresult result)
 6         {
 7             //得到先前的配置文件
 8             var config = result.asyncstate as copyfileconfig;
 9             //结束异步读
10             config?.originalfilestream.endread(result);
11             //异步读后立即写入新文件地址
12             if (config != null)
13             {
14                 filestream copystream = new filestream(config.destinationfileurl, filemode.createnew, fileaccess.write, fileshare.write, 4096, true);
15                 using (copystream)
16                 {
17                     console.writeline("异步复制原文件地址：{0}", config.originalfilestream.name);
18                     console.writeline("复制后的新文件地址：{0}", config.destinationfileurl);
19                     //调用异步写方法callback方法为end_createfilecallback，参数是copystream
20                     copystream.beginwrite(config.originalfilebytes, 0, config.originalfilebytes.length,
21                         end_createfilecallback, copystream);
22                 }
23             }
24         }

最有让我们在main函数调用一下：

 1         static void main(string[] args)
 2         {
 3             //文件操作测试
 4             filestreamtest test = new filestreamtest();
 5             //创建文件配置类
 6             createfileconfig createfileconfig = new createfileconfig
 7             {
 8                 createurl = @"e:\自己的\mytest\word\新建的.txt",
 9                 isasync = true
10             };
11             //复制文件配置类
12             copyfileconfig copyfileconfig = new copyfileconfig
13             {
14                 originalfileurl = @"e:\自己的\mytest\word\textfile1.txt",
15                 destinationfileurl = @"e:\自己的\mytest\word\textfile1-副本.txt",
16                 isasync = true
17             };
18             //test.create(createfileconfig);
19             test.copy(copyfileconfig);
20             console.readkey();
21         }

输出结果：

 

 好了，filestream的相关知识就分享到这里了。