c# FTP上传文件到服务器

基础类：LoadFileEventArgs

public class LoadFileEventArgs : CancelEventArgs
    {
        /// <summary> 是否为：传输失败后再次尝试  是|否  true|false</summary>
        public bool isAgain { get; set; }
        /// <summary> 画像检查是OK 还是 NG</summary>
        public string Result { get; set; }
        /// <summary> 创建时间</summary>
        public DateTime CreateTime { get; set; }
        /// <summary> FTP 定位到机种对应的文件夹    ftp://**.**.**.**/文件夹名</summary>
        public string Ftp_Head { get; set; }
        /// <summary> FTP 机种名 </summary>
        public string Ftp_Dir_Model { get; set; }
        /// <summary> FTP 机种对应工程 </summary>
        public string Ftp_Dir_Project { get; set; }
        /// <summary> FTP 需要新创建的文件夹名称 </summary>
        public string Ftp_Dir_Name { get; set; }
        /// <summary> 客户端 要上传的文件夹名称 </summary>
        public string Clint_Dir_Name { get; set; }
        /// <summary> 客户端 要上传的文件夹的父目录 </summary>
        public string Clint_Dir { get; set; }
        /// <summary> 客户端 要上传的文件夹的子文件夹 </summary>
        public string Clint_Dir_Next { get; set; }
        /// <summary> 客户端 要上传文件 </summary>
        public string Clint_File_Next { get; set; }
        
        #region 断点续传
        /// <summary>源文件有多大</summary>
        public Int64 SrcSize { get; set; }
        /// <summary>ftp已经上传了多少</summary>
        public Int64 DesSize { get; set; }
        /// <summary>断点续传</summary>
        public bool FileAppend { get; set; } 
        #endregion
    }

照片移动辅助类

/// <summary>
    /// 照片移动辅助类
    /// </summary>
    public class RmHelper
    {
        /// <summary>
        /// 源路径
        /// </summary>
        public string sourcePath { get; set; }
        /// <summary>
        /// 最终路径
        /// </summary>
        public string destPath { get; set; }
    }

操作结果类

/// <summary>
    /// 操作结果类
    /// </summary>
    public class ResultInfo
    {
        /// <summary>
        /// 上传结果
        /// </summary>
        public bool result { get; set; }
        /// <summary>
        /// 上传信息
        /// </summary>
        public string message { get; set; }

    }

FTPHelper类

public class FTPHelper
    {
        LogHelper log = new LogHelper();
        private static string FTPCONSTR = System.Configuration.ConfigurationManager.AppSettings["FTPCONSTR"];//FTP服务器地址  格式为ftp://192.168.1.234:8021/  写在配置文件中，方便修改
        private static string FTPUSERNAME = System.Configuration.ConfigurationManager.AppSettings["FTPUSERNAME"];//FTP服务器账号   匿名登录用账号
        private static string FTPPASSWORD = System.Configuration.ConfigurationManager.AppSettings["FTPPASSWORD"];//FTP服务器密码    匿名登录时，密码不验证，随便输就好
        private static string FTPMODEL = System.Configuration.ConfigurationManager.AppSettings["FTPMODEL"];//

        /// <summary> 上传成功后，照片移动到的路径</summary>
        private static string CLINT_DIR_UPLOADSUCC = System.Configuration.ConfigurationManager.AppSettings["Clint_Dir_UploadSucc"];//FTP服务器密码    匿名登录时，密码不验证，随便输就好
        /// <summary> 上传失败后，照片移动到的路径</summary>
        private static string CLINT_DIR_UPLOADFAIL = System.Configuration.ConfigurationManager.AppSettings["Clint_Dir_UploadFail"];//FTP服务器密码    匿名登录时，密码不验证，随便输就好
        /// <summary> 再次上传失败后，照片移动到的路径</summary>
        private static string CLINT_DIR_UPLOADFAIL_AGAIN = System.Configuration.ConfigurationManager.AppSettings["Clint_Dir_UploadFail"];//FTP服务器密码    匿名登录时，密码不验证，随便输就好
        private static FTPHelper instance = null;
        private Queue<LoadFileEventArgs> pathQueue = new Queue<LoadFileEventArgs>();


        public static FTPHelper Instance
        {
            get
            {
                if (instance == null)
                {
                    if (instance == null)
                        instance = new FTPHelper();
                }

                return instance;
            }
        }

        private delegate ResultInfo AsyncDelegate(LoadFileEventArgs args);

        /// <summary> 文件夹上传结束</summary> 
        private event EventHandler<LoadFileEventArgs> onUploadFileFinishedEvent;
        /// <summary> 文件夹上传失败</summary>
        private event EventHandler<LoadFileEventArgs> UploadFailedEvent;

        public event EventHandler onMonitorUploadEvent;
        private bool IsWorking = false;//上传工作是否在进行
        public bool CanStart = true;//true|false  开始|暂停

        private FTPHelper()
        {
            onUploadFileFinishedEvent += FtpHelper_onUploadFileFinishedEvent;
            UploadFailedEvent += FtpHelper_UploadFailedEvent;
            onMonitorUploadEvent += FtpHelper_onMonitorUploadEvent;
            this.onMonitorUploadEvent?.Invoke(null, null); 
        }


        /// <summary>
        /// 入队
        /// </summary>
        /// <param name="directoryPath">要上传的文件夹</param>
        public void InsertQueue(String directoryPath, string str = null)
        {
            bool b = false;
            if (!string.IsNullOrEmpty(str))
                b = true;
            if (!System.IO.Directory.Exists(directoryPath)) return;
            int index = directoryPath.LastIndexOf('\\');
            string project = directoryPath.Substring(0, index);
            int index2 = project.LastIndexOf('/');
            string str_Result;
            if (directoryPath.Substring(index + 1).Contains("NG"))
                str_Result = "NG";
            else
                str_Result = "OK";
            this.pathQueue.Enqueue(new LoadFileEventArgs
            {
                Ftp_Head = String.Format("ftp://{0}/{1}", FTPCONSTR, FTPMODEL),
                Ftp_Dir_Model = FTPMODEL,
                Ftp_Dir_Project = project.Substring(index2 + 1),
                Ftp_Dir_Name = directoryPath.Substring(index + 1),
                Clint_Dir_Name = directoryPath.Substring(index + 1),
                Clint_Dir = directoryPath.Substring(0, index),
                isAgain = b,
                Result = str_Result,
                CreateTime = Directory.GetCreationTime(directoryPath)
            });
        }
        

        //文件夹上传成功时调用
        private void FtpHelper_onUploadFileFinishedEvent(object sender, LoadFileEventArgs e)
        {
            this.pathQueue.Dequeue();//删除准备出栈的队列
            RmHelper rm = new RmHelper();
            rm.sourcePath = e.Clint_Dir + "/" + e.Clint_Dir_Name;
            rm.destPath = CLINT_DIR_UPLOADSUCC + "/" +e.Ftp_Dir_Project +"/"+ e.Clint_Dir_Name;
            //rm.destPath = "C:/FTP测试/工程一/" + e.Clint_Dir_Name;

            Remove_Thread(rm);
        }

        //文件夹上传失败时调用
        private void FtpHelper_UploadFailedEvent(object sender, LoadFileEventArgs e )
        {
            this.pathQueue.Dequeue();//删除准备出栈的队列
            RmHelper rm = new RmHelper();
            //失败重传 再次失败时
            if (e.isAgain)
            {
                rm.sourcePath = e.Clint_Dir + "/" + e.Clint_Dir_Name;
                rm.destPath = CLINT_DIR_UPLOADFAIL_AGAIN + "/" + e.Ftp_Dir_Project + "/" + e.Clint_Dir_Name;
            }
            //第一次传输失败时
            else
            {
                rm.sourcePath = e.Clint_Dir + "/" + e.Clint_Dir_Name;
                rm.destPath = CLINT_DIR_UPLOADFAIL + "/" + e.Ftp_Dir_Project + "/" + e.Clint_Dir_Name;
            }
            
            Remove_Thread(rm);
        }

        //实例化时开启的轮询事件
        private void FtpHelper_onMonitorUploadEvent(object sender, EventArgs e)
        {
            Task.Factory.StartNew(() =>
            {
                while (true)
                {
                    //未在上传  队列不为空
                    if (!IsWorking && this.pathQueue != null && this.pathQueue.Count > 0)
                    {
                        PerUpload();
                        System.Threading.Thread.Sleep(1000);
                    }
                    //未在上传  队列为空
                    else if (!IsWorking && (this.pathQueue == null || this.pathQueue.Count == 0))
                    {
                        System.Threading.Thread.Sleep(1000);
                    }
                    //在上传
                    else if (IsWorking)
                    {
                        System.Threading.Thread.Sleep(500);
                    }
                }
            });
        }

        //上传文件
        private void PerUpload()
        {
            Task.Factory.StartNew(() =>
            {
                try
                {
                    IsWorking = true;
                    //异步委托
                    AsyncDelegate uploadDelegate;
                    
                    while (CanStart && this.pathQueue != null && this.pathQueue.Count > 0)
                    {
                        System.Threading.Thread.Sleep(100);
                        LoadFileEventArgs args = this.pathQueue.Peek();

                        //委托绑定上传事件
                        uploadDelegate = new AsyncDelegate(instance.UpLoadDirectory);
                        //委托开始
                        IAsyncResult iasync = uploadDelegate.BeginInvoke(args, new AsyncCallback(FuncCallBack), null);
                        //执行结束后，接收返回结果
                        ResultInfo resultInfo = uploadDelegate.EndInvoke(iasync);

                        if (resultInfo.result)
                        {
                            bool b = PublicDB.InsertDirInfo(args);
                            if (b)
                            {
                                //上传成功 
                                this.onUploadFileFinishedEvent?.Invoke(null, args);
                                log.WriteLine_Log(resultInfo.message);
                            }
                            else
                            {
                                //数据库保存记录失败
                                this.UploadFailedEvent?.Invoke(null, args);
                                log.WriteLine_Log(args.Clint_Dir + "/" + args.Clint_Dir_Name+"文件上传成功，数据库保存记录失败！");
                            }
                        }
                        else
                        {
                            //上传失败
                            this.UploadFailedEvent?.Invoke(null, args);
                            log.WriteLine_Log(resultInfo.message);
                        }
                    }
                }
                catch (System.Exception ex)
                {
                    log.WriteLine_Log(ex.Message);
                }
                finally
                {
                    IsWorking = false;
                }

            });
        }

        #region 上传单个文件
        /// <summary>
        /// 上传单个文件
        /// </summary>
        /// <param name="localFile">要上传到FTP服务器的本地文件</param>
        /// <param name="ftpPath">传到服务器的哪个文件夹下</param>
        /// <returns></returns>
        public ResultInfo UpLoadFile(string localFile, string ftpPath)
        {

            ResultInfo resultInfo = new ResultInfo();
            if (!File.Exists(localFile))
            {
                resultInfo.result = false;
                resultInfo.message = "文件“" + localFile + "”不存在！上传失败！";
                //resultInfo.Lmessage.Add(DateTime.Now.ToString("[yyyy - MM - dd HH: mm:ss: ms]")+ "  文件“" + localFile + "”不存在！上传失败！\r\n");
                return resultInfo;
            }
            try
            {
                FileInfo fileInfo = new FileInfo(localFile);
                FtpWebRequest reqFtp = (FtpWebRequest)FtpWebRequest.Create(ftpPath);
                reqFtp.Credentials = new NetworkCredential(FTPUSERNAME, FTPPASSWORD);
                reqFtp.KeepAlive = false;//默认为true，连接不会被关闭  //在一个命令之后被执行
                reqFtp.Method = WebRequestMethods.Ftp.UploadFile;//指定执行什么命令
                reqFtp.UseBinary = true;//指定数据传输类型
                reqFtp.ContentLength = fileInfo.Length;//上传服务器时通知服务器文件大小；

                int buffLength = 2048;//缓冲区大小为2kb  
                byte[] buff = new byte[buffLength];
                int contentLen;

                //打开一个文件流去读要上传的文件
                FileStream fs = fileInfo.OpenRead();

                Stream stream = reqFtp.GetRequestStream();//把要上传的文件写入流
                contentLen = fs.Read(buff, 0, buffLength);//每次读取文件流的2kb

                while (contentLen != 0)//流内容未结束
                {
                    //把内容从file stream  写入到upload stream
                    stream.Write(buff, 0, contentLen);
                    contentLen = fs.Read(buff, 0, buffLength);
                }

                stream.Close();
                fs.Close();

                resultInfo.result = true;
                resultInfo.message = "文件“" + localFile + "”上传成功！";
                return resultInfo;
            }
            catch (Exception ex)
            {
                resultInfo.result = false;
                resultInfo.message = "文件“" + localFile + "”上传失败！ 失败原因：" + ex.Message;
                return resultInfo;
            }
        }


        /// <summary>
        /// 可以进行断点续传 来上传单个文件
        /// </summary>
        /// <param name="args"></param>
        /// <returns></returns>
        public ResultInfo UpLoadFile(LoadFileEventArgs arg)
        {
            //这里应该新声明一个LoadFileEventArgs  类作为参数传递时，传递的像是地址
            LoadFileEventArgs args = new LoadFileEventArgs();
            args.Clint_Dir = arg.Clint_Dir;
            args.Clint_Dir_Name = arg.Clint_Dir_Name;
            args.Clint_Dir_Next = arg.Clint_Dir_Next;
            args.Clint_File_Next = arg.Clint_File_Next;
            args.Ftp_Head = arg.Ftp_Head;
            args.Ftp_Dir_Name = arg.Ftp_Dir_Name;
            args.Ftp_Dir_Project = arg.Ftp_Dir_Project;

            string localFile = args.Clint_Dir + "/" + args.Clint_Dir_Name + "/" + args.Clint_File_Next;
            string ftpPath = args.Ftp_Head + "/" + args.Ftp_Dir_Project + "/" + args.Ftp_Dir_Name + @"/" + args.Clint_File_Next;

            args.CreateTime = File.GetCreationTime(localFile);

            Stream stream = null;
            FileInfo fileInfo = new FileInfo(localFile);

            args.SrcSize = fileInfo.Length;

            ResultInfo resultInfo = new ResultInfo();
            if (!File.Exists(localFile))
            {
                resultInfo.result = false;
                resultInfo.message = "文件“" + localFile + "”不存在！上传失败！";
                return resultInfo;
            }
            try
            {
                //先判断文件是不是已存在
                Boolean res = HandelMatchFile(args);
                if (!res)
                {
                    //FTP服务器上文件已存在
                    if (PublicDB.SelectPhotoInfo(args))
                    {
                        resultInfo.result = true;
                        resultInfo.message = "文件已上传！";
                    }
                    else
                    {
                        if (PublicDB.InsertPhotoInfo(args))
                        {
                            resultInfo.result = true;
                            resultInfo.message = "文件已上传！照片路径保存成功！";
                        }
                        else
                        {
                            resultInfo.result = false;
                            resultInfo.message = "文件已上传！照片路径保存失败！";
                        }
                    }               
                    return resultInfo;
                }
                
                FtpWebRequest reqFtp = (FtpWebRequest)FtpWebRequest.Create(ftpPath);
                reqFtp.Credentials = new NetworkCredential(FTPUSERNAME, FTPPASSWORD);
                reqFtp.KeepAlive = false;//默认为true，连接不会被关闭  //在一个命令之后被执行
                reqFtp.Method = WebRequestMethods.Ftp.UploadFile;//指定执行什么命令
                reqFtp.UseBinary = true;//指定数据传输类型
                reqFtp.ContentLength = fileInfo.Length;//上传服务器时通知服务器文件大小；

                int buffLength = 2048;//缓冲区大小为2kb  
                byte[] buff = new byte[buffLength];
                int contentLen;

                //打开一个文件流去读要上传的文件
                FileStream fs = fileInfo.OpenRead();

                if (args.FileAppend)
                {
                    reqFtp.Method = WebRequestMethods.Ftp.AppendFile;
                    reqFtp.ContentOffset = args.DesSize;
                    fs.Seek(args.SrcSize, 0);
                }
                using(stream = reqFtp.GetRequestStream())
                {
                    while (true)
                    {
                        contentLen = fs.Read(buff, 0, buffLength);
                        if(contentLen == 0)
                        {
                            break;
                        }
                        stream.Write(buff, 0, contentLen);
                    }

                    stream.Dispose();
                    stream.Close();
                    fs.Close();
                }
               
                这里调用InsertPhotoInfo
                if (PublicDB.InsertPhotoInfo(args))
                {
                    resultInfo.result = true;
                    resultInfo.message = "文件“" + localFile + "”上传成功！";
                }
                else
                {
                    resultInfo.result = false;
                    resultInfo.message = "文件“" + localFile + "”上传成功！照片路径保存失败！";
                }
                return resultInfo;
            }
            catch (Exception ex)
            {
                resultInfo.result = false;
                resultInfo.message = "文件“" + localFile + "”上传失败！ 失败原因：" + ex.Message;
                return resultInfo;
            }
        }

        /// <summary>
        /// 检查FTP服务端所匹配的文件(服务器断网、客户端断网等多种因素造成)
        /// </summary>
        private Boolean HandelMatchFile(LoadFileEventArgs args)
        {
            Boolean res = true;

            /// 1. 远程无此文件返回 --- 1
            /// 2. 远程文件比本地小 --- 2
            /// 3. 远程文件与本地大小一致 --- 3
            Tuple<int, int> tuple = CompareFileSize(args);
            
            switch (tuple.Item1)
            {
                case 1:
                    break;
                case 2:
                    //尝试断点续传服务端文件
                    args.FileAppend = true;
                    args.DesSize = tuple.Item2;
                    res = true;
                    break;
                case 3:
                    res = false;
                    break;
                default:
                    res = false;
                    break;
            }

            return res;
        }

        /// <summary>
        /// 对比远程文件大小
        /// 1. 远程无此文件返回 --- 1
        /// 2. 远程文件比本地小 --- 2
        /// 3. 远程文件与本地大小一致 --- 3
        /// </summary>
        /// <param name="args"></param>
        /// <returns></returns>
        private Tuple<int, int> CompareFileSize(LoadFileEventArgs args)
        {
            string ftpPath = args.Ftp_Head + "/" + args.Ftp_Dir_Project + "/" + args.Ftp_Dir_Name + @"/" + args.Clint_File_Next;
            String content = GetRemoteFileDetails(ftpPath);

            //远程无此文件返回 --- 1
            if (String.IsNullOrEmpty(content))
                return new Tuple<int, int>(1, 0);

            string[] strs = content.Split(' ').Where(x => x != "").ToArray();

            //这里将content转换成数组后，发现索引为2的位置是文件大小，所以直接写死了
            int fileSize = Convert.ToInt32(strs[2]);

            //远程文件比本地小 --- 2
            if (fileSize < args.SrcSize)
                return new Tuple<int, int>(2, fileSize);
            //远程文件与本地大小一致 --- 3
            return new Tuple<int, int>(3, fileSize);
        }

        /// <summary>
        /// 获取FTP服务端文件基本信息(文件名、大小)，文件不存在返回空
        /// </summary>
        /// <param name="arg"></param>
        /// <returns></returns>
        private String GetRemoteFileDetails(String uri)
        {
            StreamReader sr = null;
            String content = String.Empty;
            FtpWebResponse response = null;
            try
            {
                FtpWebRequest ftp = (FtpWebRequest)FtpWebRequest.Create(uri);
                ftp.Credentials = new NetworkCredential(FTPUSERNAME, FTPPASSWORD);
                ftp.Method = WebRequestMethods.Ftp.ListDirectoryDetails;
                ftp.UseBinary = true;
                ftp.KeepAlive = false;
                response = (FtpWebResponse)ftp.GetResponse();
                using (sr = new StreamReader(response.GetResponseStream(), Encoding.UTF8))
                {
                    content = sr.ReadLine();
                    sr.Dispose();
                    sr.Close();
                    response.Close();
                    return content;
                }
            }
            catch (System.Exception ex)
            {
                if (sr != null)
                {
                    sr.Dispose();
                    sr.Close();
                }
                if (response != null)
                {
                    response.Close();
                }
                return content;
            }
        }

        #endregion

        #region 上传文件夹
        /// <summary>
        /// 上传整个文件夹
        /// </summary>
        /// <param name="localDir">要上传的目录的上一级目录</param>
        /// <param name="ftpPath">FTP地址：FTPHelper.FTPCONSTR + "/画像FTP测试"</param>
        /// <param name="dirName">要上传的文件夹的名称</param>
        /// <returns></returns>
        public ResultInfo UpLoadDirectory(string localDir, string ftpPath, string dirName)
        {
            ResultInfo resultInfo = new ResultInfo();
            string dir = localDir + "/" + dirName;//获取当前目录（父目录在目录名）

            //检测本地是否存在
            if (!Directory.Exists(dir))
            {
                resultInfo.result = false;
                resultInfo.message = "本地目录【" + dir + "】不存在！上传失败！";
                return resultInfo;
            }
            //检测FTP的目录路径是否存在
            if (!CheckDirectoryExist(ftpPath, dirName))
            {
                resultInfo = MakeDir(ftpPath, dirName);
                if (!resultInfo.result)
                {
                    return resultInfo;
                }
            }
            List<List<string>> infos = GetDirDetails(dir); //获取当前目录下的所有文件和文件夹
            //单个上传文件
            for (int i = 0; i < infos[0].Count; i++)
            {
                resultInfo = UpLoadFile(dir + "/" + infos[0][i], ftpPath + "/" + dirName + @"/" + infos[0][i]);
                if (!resultInfo.result)
                {
                    break;
                }
            }
            //再处理文件夹  
            if (resultInfo.result) //在文件上传都成功后，开始处理文件夹
            {
                for (int i = 0; i < infos[1].Count; i++)
                {
                    resultInfo = UpLoadDirectory(dir, ftpPath + "/" + dirName, infos[1][i]);
                    if (!resultInfo.result)
                    {
                        break;
                    }
                }
            }
            if (resultInfo.result)
            {
                resultInfo.message = "文件夹【" + dir + "】上传成功！";
            }
            return resultInfo;
        }

        public ResultInfo UpLoadDirectory(LoadFileEventArgs arg)
        {
            ResultInfo resultInfo = new ResultInfo();

            LoadFileEventArgs args = new LoadFileEventArgs();
            args.Clint_Dir = arg.Clint_Dir;
            args.Clint_Dir_Name = arg.Clint_Dir_Name;
            args.Clint_Dir_Next = arg.Clint_Dir_Next;
            args.Clint_File_Next = arg.Clint_File_Next;
            args.Ftp_Head = arg.Ftp_Head;
            args.Ftp_Dir_Name = arg.Ftp_Dir_Name;
            args.Ftp_Dir_Project = arg.Ftp_Dir_Project;

            //递归处理文件夹时需要改变 操作的文件夹的路径
            if (args.Clint_Dir_Next != null && args.Clint_Dir_Next != "")
            {
                args.Ftp_Dir_Project = args.Ftp_Dir_Project + "/" + args.Ftp_Dir_Name;
                args.Ftp_Dir_Name = args.Clint_Dir_Next;
                args.Clint_Dir = args.Clint_Dir + "/" + args.Clint_Dir_Name;
                args.Clint_Dir_Name = args.Clint_Dir_Next;
            }
            string dir = args.Clint_Dir + "/" + args.Clint_Dir_Name;//获取当前目录（父目录在目录名）
            //检测本地是否存在
            if (!Directory.Exists(dir))
            {
                resultInfo.result = false;
                resultInfo.message = "本地目录【" + dir + "】不存在！上传失败！";
                return resultInfo;
            }
            //检测FTP的目录路径是否存在
            if (!CheckDirectoryExist(args.Ftp_Head + "/" + args.Ftp_Dir_Project, args.Ftp_Dir_Name))
            {
                resultInfo = MakeDir(args.Ftp_Head + "/" + args.Ftp_Dir_Project, args.Ftp_Dir_Name);
                if (!resultInfo.result)
                {
                    return resultInfo;
                }
            }
            List<List<string>> infos = GetDirDetails(dir); //获取当前目录下的所有文件和文件夹
            //单个上传文件
            for (int i = 0; i < infos[0].Count; i++)
            {
                args.Clint_File_Next = infos[0][i];
                resultInfo = UpLoadFile(args);
                if (!resultInfo.result)
                {
                    break;
                }
            }
            //再处理文件夹  
            if (resultInfo.result) //在文件上传都成功后，开始处理文件夹
            {
                for (int i = 0; i < infos[1].Count; i++)
                {
                    args.Clint_Dir_Next = infos[1][i];
                    args.Clint_File_Next = null;
                    resultInfo = UpLoadDirectory(args);
                    if (!resultInfo.result)
                    {
                        break;
                    }
                }
            }
            if (resultInfo.result)
            {
                resultInfo.message = "文件夹【" + dir + "】上传成功！";
            }
            GC.Collect();
            return resultInfo;
        }

        /// <summary>
        /// 上传结束的回调函数，暂时保留
        /// </summary>
        /// <param name="res"></param>
        void FuncCallBack(IAsyncResult res)
        {
            if (res.IsCompleted)
            {
                //暂时保留
            }
        }

        /// <summary>
        /// 检查FTP服务器上，该目录是否存在
        /// </summary>
        /// <param name="ftpPath">FTP目录名</param>
        /// <param name="dirName">目录上的文件夹名称</param>
        /// <returns></returns>
        private bool CheckDirectoryExist(string ftpPath, string dirName)
        {
            bool flag = true;
            try
            {
                //实例化FTP连接
                FtpWebRequest ftp = (FtpWebRequest)FtpWebRequest.Create(ftpPath + "/" + dirName);
                ftp.Credentials = new NetworkCredential(FTPUSERNAME, FTPPASSWORD);
                ftp.Method = WebRequestMethods.Ftp.ListDirectory;
                FtpWebResponse response = (FtpWebResponse)ftp.GetResponse();
                
                response.Close();
            }
            catch (Exception)
            {
                flag = false;
            }
            return flag;

        }

        /// <summary>
        /// 在服务器创建文件夹
        /// </summary>
        /// <param name="ftpPath">FTP路径</param>
        /// <param name="dirName">要创建的文件夹的名称</param>
        /// <returns></returns>
        public ResultInfo MakeDir(string ftpPath, string dirName)
        {
            ResultInfo resultinfo = new ResultInfo();
            //ftpPath = FTPCONSTR + ftpPath;
            FtpWebRequest reqFTP;
            try
            {
                string ui = (ftpPath + "/" + dirName).Trim();
                reqFTP = (FtpWebRequest)FtpWebRequest.Create(ui);
                reqFTP.Method = WebRequestMethods.Ftp.MakeDirectory;
                reqFTP.UseBinary = true;
                reqFTP.Credentials = new NetworkCredential(FTPUSERNAME, FTPPASSWORD);
                FtpWebResponse response = (FtpWebResponse)reqFTP.GetResponse();
                Stream ftpStream = response.GetResponseStream();
                ftpStream.Close();
                response.Close();
                resultinfo.result = true;
                resultinfo.message = "文件夹【" + dirName + "】创建成功！";
                return resultinfo;
            }
            catch (Exception ex)
            {
                resultinfo.result = false;
                resultinfo.message = "新建文件夹【" + dirName + "】时，发生错误：" + ex.Message;
                return resultinfo;
            }
        }

        /// <summary>
        /// 获取目录下的详细信息信息
        /// </summary>
        /// <param name="localDir">本机目录</param>
        /// <returns></returns>
        private List<List<string>> GetDirDetails(string localDir)
        {
            List<List<string>> infos = new List<List<string>>();
            try
            {
                infos.Add(Directory.GetFiles(localDir).ToList()); //获取当前目录的文件
                infos.Add(Directory.GetDirectories(localDir).ToList()); //获取当前目录的目录
                for (int i = 0; i < infos[0].Count; i++)
                {
                    int index = infos[0][i].LastIndexOf("\\");
                    infos[0][i] = infos[0][i].Substring(index + 1);
                }
                for (int i = 0; i < infos[1].Count; i++)
                {
                    int index = infos[1][i].LastIndexOf("\\");
                    infos[1][i] = infos[1][i].Substring(index + 1);
                }
            }
            catch (Exception ex)
            {
            }
            return infos;
        }
        #endregion

        #region 文件上传结束  数据库保存&移动本地文件
        private void Remove_Thread(RmHelper rm)
        {
            Thread th = new Thread(remove);
            th.IsBackground = true;
            th.Start(rm);
        }

        private void remove(object o)
        {
            RmHelper rm = o as RmHelper;
            //数据库保存
            if (Directory.Exists(rm.sourcePath))
            {
                try
                {
                    DirectoryInfo di = new DirectoryInfo(rm.sourcePath);
                    di.MoveTo(rm.destPath);
                }
                catch(Exception e)
                {
                    log.WriteLine_Log(e.Message);
                }
            }
        }
        #endregion

    }

上传

FTPHelper ftpHelper = FTPHelper.Instance;
ftpHelper.InsertQueue("路径", null);