C# 温故而知新:Stream篇(四)上

FileStream

目录:

  • 如何去理解FileStream?
  • FileStream的重要性
  • FileStream常用构造函数(重要)
  • 非托管参数SafeFileHandle简单介绍
  • FileStream常用属性介绍
  • FileStream常用方法介绍
  • FileStream示例1:*文件的新建和拷贝(主要演示文件同步和异步操作)
  • FileStream示例2:*实现文件本地分段上传
  • 本章总结

如何去理解FileStream?

通过前3章的学习相信大家对于Stream已经有一定的了解,但是又如何去理解FileStream呢?请看下图  

我们磁盘的中任何文件都是通过2进制组成,最为直观的便是记事本了,当我们新建一个记事本时,它的大小是0KB, 我们每次输入一个数字或

字母时文件便会自动增大4kb,可见随着我们输入的内容越来越多,文件也会相应增大,同理当我们删除文件内容时,文件也会相应减小,对了,

聪明的你肯定会问:谁将内容以怎么样的形式放到文件中去了?好问题,还记得第一篇流的概念么?对了,真实世界的一群鱼可以通过河流来

往于各个地方,FileStream也是一样,byte可以通过FileStream进行传输,这样我们便能在计算机上对任何文件进行一系列的操作了。

FileStream 的重要性

FileStream 顾名思义文件流,我们电脑上的文件都可以通过文件流进行操作,例如文件的复制,剪切,粘贴,删除, 本地文件上传,下载,等许

多重要的功能都离不开文件流,所以文件流不仅在本机上非常重要,在如今的网络世界也是万万不能缺少的,想象一下我们开启虚机后,直接从本

地复制一个文件到虚机上,是多么方便,如果没有文件流,这个将难以想象。(大家别误解,文件流无法直接通过网络进行传输,而是

通过网络流将客户端上传的文件传到服务器端接收,然后通过文件流进行处理,下载正好相反)

FileStream 常用构造函数介绍(可能理解上有点复杂,请大家务必深刻理解)

*1: FileStream(SafeFileHandle, FileAccess)

非托管参数SafeFileHandle简单介绍

SafeFileHandle :是一个文件安全句柄,这样的解释可能大家一头雾水,

别急,大家先不要去理睬这深邃的含义,只要知道这个类型是c#非托管资源,

也就是说它能够调用非托管资源的方法,而且不属于c#回收机制,所以我们必须

使用GC手动或其他方式(Finalize 或Dispose方法)进行非托管资源的回收,所以

SafeFileHandle是个默默无闻的保镖 ,一直暗中保护FileStream和文件的安全

为了能让大家更好的理解这个保镖,请看第一段代码:

会什么会报错呢?其实程序被卡在 Console.ReadLine()这里,FileStream并没有

被释放,系统不知道这个文件是否还有用﹐所以帮我们保护这个文件

(那个非托管资源SafeFileHandle所使用的内存还被程序占用着)

所以SafeFileHandled 在内部保护了这个文件从而报出了这个异常

如果我们将流关闭后,这个问题也就不存在了

可以看见stream.SafeFileHandle的IsClose属性变成true了,也就是说这时候可以安全的删除文件了

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

*2: FileStream(String, FileMode)

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

FileMode枚举参数包含以下内容:

成员名称

说明

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, FileAccess, Boolean ownsHandle)

FileAccess 参数也是一个枚举, 表示对于该文件的操作权限

ReadWrite

对文件的读访问和写访问。可从文件读取数据和将数据写入文件

Write

文件的写访问。可将数据写入文件。同 Read组合即构成读/写访问权

Read

对文件的读访问。可从文件中读取数据。同 Write组合即构成读写访问权

参数ownsHandle:也就是类似于前面和大家介绍的SafeFileHandler,有2点必须注意:

1对于指定的文件句柄,操作系统不允许所请求的 access,例如,当 access 为 Write 或 ReadWrite 而文件句柄设置为只读访问时,会报出异常。

所以 ownsHandle才是老大,FileAccess的权限应该在ownsHandle的范围之内

2. FileStream 假定它对句柄有独占控制权。当 FileStream 也持有句柄时,读取、写入或查找可能会导致数据破坏。为了数据的安全,请使用

句柄前调用 Flush,并避免在使用完句柄后调用 Close 以外的任何方法。

*4: FileStream(String, FileMode, FileAccess, FileShare)

FileShare:同样是个枚举类型:确定文件如何由进程共享。   

Delete

允许随后删除文件。

Inheritable

使文件句柄可由子进程继承。Win32 不直接支持此功能。

None

谢绝共享当前文件。文件关闭前,打开该文件的任何请求(由此进程或另一进程发出的请求)都将失败。

Read

允许随后打开文件读取。如果未指定此标志,则文件关闭前,任何打开该文件以进行读取的请求(由此进程或另一进程发出的请求)都将失败。但是,即使指定了此标志,仍可能需要附加权限才能够访问该文件。

ReadWrite

允许随后打开文件读取或写入。如果未指定此标志,则文件关闭前,任何打开该文件以进行读取或写入的请求(由此进程或另一进程发出)都将失败。但是,即使指定了此标志,仍可能需要附加权限才能够访问该文件。

Write

允许随后打开文件写入。如果未指定此标志,则文件关闭前,任何打开该文件以进行写入的请求(由此进程或另一进过程发出的请求)都将失败。但是,即使指定了此标志,仍可能需要附加权限才能够访问该文件。

*5: FileStream(String, FileMode, FileAccess, FileShare, Int32, Boolean async )

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

Boolean async:是否异步读写,告诉FileStream示例,是否采用异步读写

*6: FileStream(String, FileMode, FileAccess, FileShare, Int32, FileOptions)

FileOptions:这是类似于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方法和线程中的Look关键字很不一样,它能够锁住文件中的某一部分,非常的强悍!用了这个方法我们能够精确锁定住我们需要锁住的文件的部分内容

*3: void SetAccessControl(FileSecurity fileSecurity)

和GetAccessControl很相似,ACL技术会在以后单独介绍

*4: void Unlock (long position,long length)

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

文件的新建和拷贝(主要演示文件同步和异步操作)

首先我们尝试DIY一个IFileConfig

    /// <summary>
    /// 文件配置接口
    /// </summary>
    public interface IFileConfig
    {
        string FileName { get; set; }
        bool IsAsync { get; set; }
    }

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

    /// <summary>
    /// 创建文件配置类
    /// </summary>
    public class CreateFileConfig : IFileConfig
    {
        // 文件名
        public string FileName { get; set; }
        //是否异步操作
        public bool IsAsync { get; set; }
        //创建文件所在url
        public string CreateUrl { get; set; }
    }

让我们定义一个文件流测试类:FileStreamTest 来实现文件的操作

    /// <summary>
    /// FileStreamTest 类
    /// </summary>
    public class FileStreamTest

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

/// <summary>
        /// 添加文件方法
        /// </summary>
        /// <param name="config"> 创建文件配置类</param>
        public void Create(IFileConfig config)
        {
            lock (_lockObject)
            {
                //得到创建文件配置类对象
                var createFileConfig = config as CreateFileConfig;
                //检查创建文件配置类是否为空
                if (this.CheckConfigIsError(config)) return;
                //假设创建完文件后写入一段话,实际项目中无需这么做,这里只是一个演示
                char[] insertContent = "HellowWorld".ToCharArray();
                //转化成 byte[]
                byte[] byteArrayContent = Encoding.Default.GetBytes(insertContent, 0, insertContent.Length);
                 //根据传入的配置文件中来决定是否同步或异步实例化stream对象
                FileStream stream = createFileConfig.IsAsync ?
                    new FileStream(createFileConfig.CreateUrl, FileMode.Create, FileAccess.ReadWrite, FileShare.None, 4096, true)
                    : new FileStream(createFileConfig.CreateUrl, FileMode.Create);
                using (stream)
                {
                    // 如果不注释下面代码会抛出异常,google上提示是WriteTimeout只支持网络流
                   // stream.WriteTimeout = READ_OR_WRITE_TIMEOUT;
                    //如果该流是同步流并且可写
                    if (!stream.IsAsync && stream.CanWrite)
                        stream.Write(byteArrayContent, 0, byteArrayContent.Length);
                    else if (stream.CanWrite)//异步流并且可写
                        stream.BeginWrite(byteArrayContent, 0, byteArrayContent.Length, this.End_CreateFileCallBack, stream);


                    stream.Close();
                }
            }
        }

如果采用异步的方式则最后会进入End_CreateFileCallBack回调方法,result.AsyncState对象就是上图stream.BeginWrite()方法的最后一个参数

还有一点必须注意的是每一次使用BeginWrite()方法事都要带上EndWrite()方法,Read方法也一样

/// <summary>
        ///  异步写文件callBack方法
        /// </summary>
        /// <param name="result">IAsyncResult</param>
        private void End_CreateFileCallBack(IAsyncResult result)
        {
            //从IAsyncResult对象中得到原来的FileStream
            var stream = result.AsyncState as FileStream;
            //结束异步写
 
            Console.WriteLine("异步创建文件地址:{0}", stream.Name);
            stream.EndWrite(result);
            Console.ReadLine();
        }

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

/// <summary>
    /// 文件复制
    /// </summary>
    public class CopyFileConfig : IFileConfig
    {
        // 文件名
        public string FileName { get; set; }
        //是否异步操作
        public bool IsAsync { get; set; }
        //原文件地址
        public string OrginalFileUrl { get; set; }
        //拷贝目的地址
        public string DestinationFileUrl { get; set; }
        //文件流,异步读取后在回调方法内使用
        public FileStream OriginalFileStream { get; set; }
        //原文件字节数组,异步读取后在回调方法内使用
        public byte[] OriginalFileBytes { get; set; }
    }

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

/// <summary>
        /// 复制方法
        /// </summary>
        /// <param name="config">拷贝文件复制</param>
        public void Copy(IFileConfig config)
        {
            lock (_lockObject)
            {
                //得到CopyFileConfig对象
                var copyFileConfig = config as CopyFileConfig;
                // 检查CopyFileConfig类对象是否为空或者OrginalFileUrl是否为空
                if (CheckConfigIsError(copyFileConfig) || !File.Exists(copyFileConfig.OrginalFileUrl)) return;
                //创建同步或异步流
                FileStream stream = copyFileConfig.IsAsync ?
                 new FileStream(copyFileConfig.OrginalFileUrl, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, true)
                 : new FileStream(copyFileConfig.OrginalFileUrl, FileMode.Open);
                //定义一个byte数组接受从原文件读出的byte数据
                byte[] orignalFileBytes = new byte[stream.Length];
                using (stream)
                {
                   // stream.ReadTimeout = READ_OR_WRITE_TIMEOUT;
                    //如果异步流
                    if (stream.IsAsync)
                    {
                        //将该流和读出的byte[]数据放入配置类,在callBack中可以使用
                        copyFileConfig.OriginalFileStream = stream;
                        copyFileConfig.OriginalFileBytes = orignalFileBytes;
                        if (stream.CanRead)
                         //异步开始读取,读完后进入End_ReadFileCallBack方法,该方法接受copyFileConfig参数
                        stream.BeginRead(orignalFileBytes, 0, orignalFileBytes.Length, End_ReadFileCallBack, copyFileConfig);
                    }
                    else//否则同步读取
                    {
                        if (stream.CanRead)
                        {
                            //一般读取原文件
                            stream.Read(orignalFileBytes, 0, orignalFileBytes.Length);
                        }
                        //定义一个写流,在新位置中创建一个文件
                        FileStream copyStream = new FileStream(copyFileConfig.DestinationFileUrl, FileMode.CreateNew);
                        using (copyStream)
                        {
                          //  copyStream.WriteTimeout = READ_OR_WRITE_TIMEOUT;
                            //将源文件的内容写进新文件
                            copyStream.Write(orignalFileBytes, 0, orignalFileBytes.Length);
                            copyStream.Close();
                        }
                    }
                    stream.Close();
                    Console.ReadLine();
                }
            }
        }

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

/// <summary>
        /// 异步读写文件方法
        /// </summary>
        /// <param name="result"></param>
        private void End_ReadFileCallBack(IAsyncResult result) 
        {
            //得到先前的配置文件
            var config = result.AsyncState as CopyFileConfig;
            //结束异步读
            config.OriginalFileStream.EndRead(result);
            //异步读后立即写入新文件地址
            if (File.Exists(config.DestinationFileUrl)) File.Delete(config.DestinationFileUrl);
            FileStream copyStream = new FileStream(config.DestinationFileUrl, FileMode.CreateNew);
            using (copyStream)
            {
                Console.WriteLine("异步复制原文件地址:{0}", config.OriginalFileStream.Name);
                Console.WriteLine("复制后的新文件地址:{0}", config.DestinationFileUrl);
                //调用异步写方法CallBack方法为End_CreateFileCallBack,参数是copyStream
                copyStream.BeginWrite(config.OriginalFileBytes, 0, config.OriginalFileBytes.Length, this.End_CreateFileCallBack,copyStream);
                copyStream.Close();
 
            }
 
        }

最后让我们在main函数调用下:

static void Main(string[] args)
        {
            FileStreamTest test = new FileStreamTest();
            //创建文件配置类
            CreateFileConfig createFileConfig = new CreateFileConfig { CreateUrl = @"d:\MyFile.txt", IsAsync = true };
            //复制文件配置类
            CopyFileConfig copyFileConfig = new CopyFileConfig
            {
                OrginalFileUrl = @"d:\8.jpg",
                DestinationFileUrl = @"d:\9.jpg",
                IsAsync = true
            };
            test.Create(createFileConfig);
            test.Copy(copyFileConfig);
        }

输出结果:

实现文件本地分段上传

原文发布于微信公众号 - 我为Net狂(dotNetCrazy)

原文发表时间:2016-06-29

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏MoeLove

[译]Tornado协程

Tornado 4.3于2015年11月6日发布,该版本正式支持Python3.5的async/await关键字,并且用旧版本CPython编译Tornado同...

922
来自专栏北京马哥教育

linux bash环境变量简单总结

一.环境变量简介 Linux是一个多用户的操作系统。每个用户登录系统后,都会有一个专用的运行环境。通常每个用户默认的环境都 是相同的,这个默认环境实际...

3546
来自专栏Linux驱动

42.Linux应用调试-初步制作系统调用(用户态->内核态)

1首先来讲讲应用程序如何实现系统调用(用户态->内核态)? 我们以应用程序的write()函数为例: 1)首先用户态的write()函数会进入glibc库,里面...

2435
来自专栏python学习路

二、路由、模板

一、路由系统 在settings.py文件中通过ROOT_URLCONF指定根级url的配置 urlpatterns是一个url()实例的列表 一个url()对...

3418
来自专栏北京马哥教育

使用Logstash filter grok过滤日志文件

“Eason,企业一线运维实战者,马哥教育原创作者联盟成员,热爱分享Linux应用技术的感想和原创知识。” Logstash Filter Plugin Gro...

3945
来自专栏大学生计算机视觉学习DeepLearning

c++ 网络编程(四)TCP/IP LINUX/windows下 socket 基于I/O复用的服务器端代码 解决多进程服务端创建进程资源浪费问题

原文链接:https://www.cnblogs.com/DOMLX/p/9613861.html

2255
来自专栏orientlu

FreeRTOS 消息队列

上面这几中方式中, 除了消息通知, 其他几种实现都是基于消息队列。消息队列作为主要的通信方式, 支持在任务间, 任务和中断间传递消息内容。 这一章介绍 Fre...

4892
来自专栏枕边书

PHP模拟发送POST请求之二、用PHP和JS处理URL信息

明白了HTTP请求的头信息后,我们还需要对请求地址有所了解。再者,HTTP GET请求是靠URL实现的,所以了解URL的构造,处理URL的重要性不言而喻。 在P...

2315
来自专栏york技术分享

sed 使用教程 - 通读篇(30分钟入门系列)

和上篇 awk 分享一样,作为通读性的分享,不想引入太过复杂的东西,依然从日常工作中碰到的 80% 的需求出发,重点阐述最重点的部门,工作原理等,普及一些对se...

50122
来自专栏逍遥剑客的游戏开发

Nebula3学习笔记(5): IO系统

1944

扫码关注云+社区

领取腾讯云代金券