C# 温故而知新：Stream篇（四）上开发者社区

C# 温故而知新：Stream篇（四）上

成员名称	说明
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 打开的文件中进行读取将导致异常。

ReadWrite	对文件的读访问和写访问。可从文件读取数据和将数据写入文件
Write	文件的写访问。可将数据写入文件。同 Read组合即构成读/写访问权
Read	对文件的读访问。可从文件中读取数据。同 Write组合即构成读写访问权

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

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

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

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

/// <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();
        }

/// <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; }
    }

/// <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();
        }

/// <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();
        }

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",