/// <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",
                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>
/// 将文件上传至服务器（本地），由于采取分段传输所以，
/// 每段必须有一个起始位置和相对应该数据段的数据
/// </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) 
        {
//if(!File.Exists(localFilePath)){return;}
//每次临时读取数据数
            int tempReadCount = 0;
int tempBuffer = 0;
//定义一个缓冲区数组
            byte[] bufferByteArray = new byte[BUFFER_COUNT];
//定义一个FileStream对象
            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(@"G:\\Skyrim\20080204173728108.torrent");
//取得文件总长度
            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(@"G:\\Skyrim\\20080204173728108.torrent", @"G:\\Skyrim\\20080204173728109.torrent", startPosition, i == divide ? divide : totalCount);
            }

        }