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

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

    /// <summary>
    /// 創(chuàng)建文件配置類
    /// </summary>
    public class CreateFileConfig : IFileConfig
    {
        // 文件名
        public string FileName { get; set; }
        //是否異步操作
        public bool IsAsync { get; set; }
        //創(chuàng)建文件所在url
        public string CreateUrl { get; set; }
    }

    /// <summary>
    /// FileStreamTest 類
    /// </summary>
    public class FileStreamTest

       /// <summary>
        /// 添加文件方法
        /// </summary>
        /// <param name="config"> 創(chuàng)建文件配置類</param>
        public void Create(IFileConfig config)
        {
            lock (_lockObject)
            {
                //得到創(chuàng)建文件配置類對象
                var createFileConfig = config as CreateFileConfig;
                //檢查創(chuàng)建文件配置類是否為空
                if (this.CheckConfigIsError(config)) return;
                //假設創(chuàng)建完文件后寫入一段話，實際項目中無需這么做，這里只是一個演示
                char[] insertContent = "HellowWorld".ToCharArray();
                //轉化成 byte[]
                byte[] byteArrayContent = Encoding.Default.GetBytes(insertContent, 0, insertContent.Length);
                 //根據(jù)傳入的配置文件中來決定是否同步或異步實例化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只支持網(wǎng)絡流
                   // 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("異步創(chuàng)建文件地址：{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; }
        //文件流，異步讀取后在回調(diào)方法內(nèi)使用
        public FileStream OriginalFileStream { get; set; }
        //原文件字節(jié)數(shù)組，異步讀取后在回調(diào)方法內(nèi)使用
        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;
                //創(chuàng)建同步或異步流
                FileStream stream = copyFileConfig.IsAsync ?
                 new FileStream(copyFileConfig.OrginalFileUrl, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, true)
                 : new FileStream(copyFileConfig.OrginalFileUrl, FileMode.Open);
                //定義一個byte數(shù)組接受從原文件讀出的byte數(shù)據(jù)
                byte[] orignalFileBytes = new byte[stream.Length];
                using (stream)
                {
                   // stream.ReadTimeout = READ_OR_WRITE_TIMEOUT;
                    //如果異步流
                    if (stream.IsAsync)
                    {
                        //將該流和讀出的byte[]數(shù)據(jù)放入配置類，在callBack中可以使用
                        copyFileConfig.OriginalFileStream = stream;
                        copyFileConfig.OriginalFileBytes = orignalFileBytes;
                        if (stream.CanRead)
                         //異步開始讀取，讀完后進入End_ReadFileCallBack方法，該方法接受copyFileConfig參數(shù)
                        stream.BeginRead(orignalFileBytes, 0, orignalFileBytes.Length, End_ReadFileCallBack, copyFileConfig);
                    }
                    else//否則同步讀取
                    {
                        if (stream.CanRead)
                        {
                            //一般讀取原文件
                            stream.Read(orignalFileBytes, 0, orignalFileBytes.Length);
                        }
                        //定義一個寫流，在新位置中創(chuàng)建一個文件
                        FileStream copyStream = new FileStream(copyFileConfig.DestinationFileUrl, FileMode.CreateNew);
                        using (copyStream)
                        {
                          //  copyStream.WriteTimeout = READ_OR_WRITE_TIMEOUT;
                            //將源文件的內(nèi)容寫進新文件
                            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);
                //調(diào)用異步寫方法CallBack方法為End_CreateFileCallBack，參數(shù)是copyStream
                copyStream.BeginWrite(config.OriginalFileBytes, 0, config.OriginalFileBytes.Length, this.End_CreateFileCallBack,copyStream);
                copyStream.Close();
       
            }
          
        }

  static void Main(string[] args)
        {
            FileStreamTest test = new FileStreamTest();
            //創(chuàng)建文件配置類
            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);
        }

/// <summary>
    /// 分段上傳例子
    /// </summary>
    public class UpFileSingleTest
    {
        //我們定義Buffer為1000
        public const int BUFFER_COUNT = 1000;

        /// <summary>
        /// 將文件上傳至服務器（本地），由于采取分段傳輸所以，
        /// 每段必須有一個起始位置和相對應該數(shù)據(jù)段的數(shù)據(jù)
        /// </summary>
        /// <param name="filePath">服務器上文件地址</param>
        /// <param name="startPositon">分段起始位置</param>
        /// <param name="btArray">每段的數(shù)據(jù)</param>
        private void WriteToServer(string filePath,int startPositon,byte[] btArray) 
        {
            FileStream fileStream = new FileStream(filePath, FileMode.OpenOrCreate);
            using (fileStream) 
            {
                //將流的位置設置在該段起始位置
                fileStream.Position = startPositon;
                //將該段數(shù)據(jù)通過FileStream寫入文件中，每次寫一段的數(shù)據(jù)，就好比是個水池，分段蓄水一樣，直到蓄滿為止
                fileStream.Write(btArray, 0, btArray.Length);
            }
        }


        /// <summary>
        /// 處理單獨一段本地數(shù)據(jù)上傳至服務器的邏輯，根據(jù)客戶端傳入的startPostion
        /// 和totalCount來處理相應段的數(shù)據(jù)上傳至服務器（本地）
        /// </summary>
        /// <param name="localFilePath">本地需要上傳的文件地址</param>
        /// <param name="uploadFilePath">服務器（本地）目標地址</param>
        /// <param name="startPostion">該段起始位置</param>
        /// <param name="totalCount">該段最大數(shù)據(jù)量</param>
        public void UpLoadFileFromLocal(string localFilePath,string uploadFilePath,int startPostion,int totalCount) 
        {
            //if(!File.Exists(localFilePath)){return;}
           //每次臨時讀取數(shù)據(jù)數(shù)
            int tempReadCount = 0;
            int tempBuffer = 0;
            //定義一個緩沖區(qū)數(shù)組
            byte[] bufferByteArray = new byte[BUFFER_COUNT];
            //定義一個FileStream對象
            FileStream fileStream = new FileStream(localFilePath,FileMode.Open);
            //將流的位置設置在每段數(shù)據(jù)的初始位置
            fileStream.Position = startPostion;
            using (fileStream)
            {
                //循環(huán)將該段數(shù)據(jù)讀出在寫入服務器中
                while (tempReadCount < totalCount)
                {
                    
                    tempBuffer = BUFFER_COUNT;
                    //每段起始位置+每次循環(huán)讀取數(shù)據(jù)的長度
                    var writeStartPosition = startPostion + tempReadCount;
                    //當緩沖區(qū)的數(shù)據(jù)加上臨時讀取數(shù)大于該段數(shù)據(jù)量時，
                    //則設置緩沖區(qū)的數(shù)據(jù)為totalCount-tempReadCount 這一段的數(shù)據(jù)
                    if (tempBuffer + tempReadCount > totalCount) 
                    {
                        //緩沖區(qū)的數(shù)據(jù)為totalCount-tempReadCount 
                        tempBuffer = totalCount-tempReadCount;
                        //讀取該段數(shù)據(jù)放入bufferByteArray數(shù)組中
                        fileStream.Read(bufferByteArray, 0, tempBuffer);
                        if (tempBuffer > 0) 
                        {
                            byte[] newTempBtArray = new byte[tempBuffer];
                            Array.Copy(bufferByteArray, 0, newTempBtArray, 0, tempBuffer);
                            //將緩沖區(qū)的數(shù)據(jù)上傳至服務器
                            this.WriteToServer(uploadFilePath, writeStartPosition, newTempBtArray);
                        }
                        
                    }
                    //如果緩沖區(qū)的數(shù)據(jù)量小于該段數(shù)據(jù)量，并且tempBuffer=設定BUFFER_COUNT時，通過
                    //while 循環(huán)每次讀取一樣的buffer值的數(shù)據(jù)寫入服務器中，直到將該段數(shù)據(jù)全部處理完畢
                    else if (tempBuffer == BUFFER_COUNT) 
                    {
                        fileStream.Read(bufferByteArray, 0, tempBuffer);
                        this.WriteToServer(uploadFilePath, writeStartPosition, bufferByteArray);
                    }
 
                    //通過每次的緩沖區(qū)數(shù)據(jù)，累計增加臨時讀取數(shù)
                    tempReadCount += tempBuffer;
                }
            }
        }

    }

 static void Main(string[] args)
        {
            UpFileSingleTest test=new UpFileSingleTest();
            FileInfo info = new FileInfo(@"G:\\Skyrim\20080204173728108.torrent");
            //取得文件總長度
            var fileLegth = info.Length;
            //假設將文件切成5段
            var divide = 5;
            //取到每個文件段的長度
            var perFileLengh = (int)fileLegth / divide;
            //表示最后剩下的文件段長度比perFileLengh小
            var restCount = (int)fileLegth % divide;
            //循環(huán)上傳數(shù)據(jù)
            for (int i = 0; i < divide+1; i++)
            {
                //每次定義不同的數(shù)據(jù)段,假設數(shù)據(jù)長度是500，那么每段的開始位置都是i*perFileLength
                var startPosition = i * perFileLengh;
                //取得每次數(shù)據(jù)段的數(shù)據(jù)量
                var totalCount = fileLegth - perFileLengh * i > perFileLengh ? perFileLengh : (int)(fileLegth - perFileLengh * i);
                //上傳該段數(shù)據(jù)
                test.UpLoadFileFromLocal(@"G:\\Skyrim\\20080204173728108.torrent", @"G:\\Skyrim\\20080204173728109.torrent", startPosition, i == divide ? divide : totalCount);
            }
         
        }