FTP完美操作类

using System;

using System.Collections.Generic;

using System.Text;

using System.Net;

using System.IO;

using System.Globalization;

using System.Text.RegularExpressions;

namespace System.Net.Ftp

{

    /// <summary>

    /// FTP处理操作类

    /// 功能：

    /// 下载文件

    /// 上传文件

    /// 上传文件的进度信息

    /// 下载文件的进度信息

    /// 删除文件

    /// 列出文件

    /// 列出目录

    /// 进入子目录

    /// 退出当前目录返回上一层目录

    /// 判断远程文件是否存在

    /// 判断远程文件是否存在

    /// 删除远程文件    

    /// 建立目录

    /// 删除目录

    /// 文件（目录）改名

    /// </summary>

    /// <remarks>

    /// 创建人：南疯

    /// 创建时间：2007年4月28日

    /// </remarks>

    #region 文件信息结构

    public struct FileStruct

    {

        public string Flags;

        public string Owner;

        public string Group;

        public bool IsDirectory;

        public DateTime CreateTime;

        public string Name;

    }

    public enum FileListStyle

    {

        UnixStyle,

        WindowsStyle,

        Unknown

    }

    #endregion

    public class clsFTP

    {

        #region 属性信息

        /// <summary>

        /// FTP请求对象

        /// </summary>

        FtpWebRequest Request = null;

        /// <summary>

        /// FTP响应对象

        /// </summary>

        FtpWebResponse Response = null;

        /// <summary>

        /// FTP服务器地址

        /// </summary>

        private Uri _Uri;

        /// <summary>

        /// FTP服务器地址

        /// </summary>

        public Uri Uri

        {

            get

            {

                if (_DirectoryPath == "/")

                {

                    return _Uri;

                }

                else

                {

                    string strUri = _Uri.ToString();

                    if (strUri.EndsWith("/"))

                    {

                        strUri = strUri.Substring(0, strUri.Length - 1);

                    }

                    return new Uri(strUri + this.DirectoryPath);

                }

            }

            set

            {

                if (value.Scheme != Uri.UriSchemeFtp)

                {

                    throw new Exception("Ftp 地址格式错误!");

                }

                _Uri = new Uri(value.GetLeftPart(UriPartial.Authority));

                _DirectoryPath = value.AbsolutePath;

                if (!_DirectoryPath.EndsWith("/"))

                {

                    _DirectoryPath += "/";

                }

            }

        }

        /// <summary>

        /// 当前工作目录

        /// </summary>

        private string _DirectoryPath;

        /// <summary>

        /// 当前工作目录

        /// </summary>

        public string DirectoryPath

        {

            get { return _DirectoryPath; }

            set { _DirectoryPath = value; }

        }

        /// <summary>

        /// FTP登录用户

        /// </summary>

        private string _UserName;

        /// <summary>

        /// FTP登录用户

        /// </summary>

        public string UserName

        {

            get { return _UserName; }

            set { _UserName = value; }

        }

        /// <summary>

        /// 错误信息

        /// </summary>

        private string _ErrorMsg;

        /// <summary>

        /// 错误信息

        /// </summary>

        public string ErrorMsg

        {

            get { return _ErrorMsg; }

            set { _ErrorMsg = value; }

        }

        /// <summary>

        /// FTP登录密码

        /// </summary>

        private string _Password;

        /// <summary>

        /// FTP登录密码

        /// </summary>

        public string Password

        {

            get { return _Password; }

            set { _Password = value; }

        }

        /// <summary>

        /// 连接FTP服务器的代理服务

        /// </summary>

        private WebProxy _Proxy = null;

        /// <summary>

        /// 连接FTP服务器的代理服务

        /// </summary>

        public WebProxy Proxy

        {

            get

            {

                return _Proxy;

            }

            set

            {

                _Proxy = value;

            }

        }

        /// <summary>

        /// 是否需要删除临时文件

        /// </summary>

        private bool _isDeleteTempFile = false;

        /// <summary>

        /// 异步上传所临时生成的文件

        /// </summary>

        private string _UploadTempFile = "";

        #endregion

        #region 事件

        public delegate void De_DownloadProgressChanged(object sender, DownloadProgressChangedEventArgs e);

        public delegate void De_DownloadDataCompleted(object sender, System.ComponentModel.AsyncCompletedEventArgs e);

        public delegate void De_UploadProgressChanged(object sender, UploadProgressChangedEventArgs e);

        public delegate void De_UploadFileCompleted(object sender, UploadFileCompletedEventArgs e);

        /// <summary>

        /// 异步下载进度发生改变触发的事件

        /// </summary>

        public event De_DownloadProgressChanged DownloadProgressChanged;

        /// <summary>

        /// 异步下载文件完成之后触发的事件

        /// </summary>

        public event De_DownloadDataCompleted DownloadDataCompleted;

        /// <summary>

        /// 异步上传进度发生改变触发的事件

        /// </summary>

        public event De_UploadProgressChanged UploadProgressChanged;

        /// <summary>

        /// 异步上传文件完成之后触发的事件

        /// </summary>

        public event De_UploadFileCompleted UploadFileCompleted;

        #endregion

        #region 构造析构函数

        /// <summary>

        /// 构造函数

        /// </summary>

        /// <param name="FtpUri">FTP地址</param>

        /// <param name="strUserName">登录用户名</param>

        /// <param name="strPassword">登录密码</param>

        public clsFTP(Uri FtpUri, string strUserName, string strPassword)

        {

            this._Uri = new Uri(FtpUri.GetLeftPart(UriPartial.Authority));

            _DirectoryPath = FtpUri.AbsolutePath;

            if (!_DirectoryPath.EndsWith("/"))

            {

                _DirectoryPath += "/";

            }

            this._UserName = strUserName;

            this._Password = strPassword;

            this._Proxy = null;

        }

        /// <summary>

        /// 构造函数

        /// </summary>

        /// <param name="FtpUri">FTP地址</param>

        /// <param name="strUserName">登录用户名</param>

        /// <param name="strPassword">登录密码</param>

        /// <param name="objProxy">连接代理</param>

        public clsFTP(Uri FtpUri, string strUserName, string strPassword, WebProxy objProxy)

        {

            this._Uri = new Uri(FtpUri.GetLeftPart(UriPartial.Authority));

            _DirectoryPath = FtpUri.AbsolutePath;

            if (!_DirectoryPath.EndsWith("/"))

            {

                _DirectoryPath += "/";

            }

            this._UserName = strUserName;

            this._Password = strPassword;

            this._Proxy = objProxy;

        }

        /// <summary>

        /// 构造函数

        /// </summary>

        public clsFTP()

        {

            this._UserName = "anonymous";  //匿名用户

            this._Password = "@anonymous";

            this._Uri = null;

            this._Proxy = null;

        }

        /// <summary>

        /// 析构函数

        /// </summary>

        ~clsFTP()

        {

            if (Response != null)

            {

                Response.Close();

                Response = null;

            }

            if (Request != null)

            {

                Request.Abort();

                Request = null;

            }

        }

        #endregion

        #region 建立连接

        /// <summary>

        /// 建立FTP链接,返回响应对象

        /// </summary>

        /// <param name="uri">FTP地址</param>

        /// <param name="FtpMathod">操作命令</param>

        private FtpWebResponse Open(Uri uri, string FtpMathod)

        {

            try

            {

                Request = (FtpWebRequest)WebRequest.Create(uri);

                Request.Method = FtpMathod;

                Request.UseBinary = true;

                Request.Credentials = new NetworkCredential(this.UserName, this.Password);

                if (this.Proxy != null)

                {

                    Request.Proxy = this.Proxy;

                }

                return (FtpWebResponse)Request.GetResponse();

            }

            catch (Exception ep)

            {

                ErrorMsg = ep.ToString();

                throw ep;

            }

        }

        /// <summary>

        /// 建立FTP链接,返回请求对象

        /// </summary>

        /// <param name="uri">FTP地址</param>

        /// <param name="FtpMathod">操作命令</param>

        private FtpWebRequest OpenRequest(Uri uri, string FtpMathod)

        {

            try

            {

                Request = (FtpWebRequest)WebRequest.Create(uri);

                Request.Method = FtpMathod;

                Request.UseBinary = true;

                Request.Credentials = new NetworkCredential(this.UserName, this.Password);

                if (this.Proxy != null)

                {

                    Request.Proxy = this.Proxy;

                }

                return Request;

            }

            catch (Exception ep)

            {

                ErrorMsg = ep.ToString();

                throw ep;

            }

        }

        #endregion

        #region 下载文件

        /// <summary>

        /// 从FTP服务器下载文件，使用与远程文件同名的文件名来保存文件

        /// </summary>

        /// <param name="RemoteFileName">远程文件名</param>

        /// <param name="LocalPath">本地路径</param>

        public bool DownloadFile(string RemoteFileName, string LocalPath)

        {

            return DownloadFile(RemoteFileName, LocalPath, RemoteFileName);

        }

        /// <summary>

        /// 从FTP服务器下载文件，指定本地路径和本地文件名

        /// </summary>

        /// <param name="RemoteFileName">远程文件名</param>

        /// <param name="LocalPath">本地路径</param>

        /// <param name="LocalFilePath">保存文件的本地路径,后面带有"\"</param>

        /// <param name="LocalFileName">保存本地的文件名</param>

        public bool DownloadFile(string RemoteFileName, string LocalPath, string LocalFileName)

        {

            byte[] bt = null;

            try

            {

                if (!IsValidFileChars(RemoteFileName) || !IsValidFileChars(LocalFileName) || !IsValidPathChars(LocalPath))

                {

                    throw new Exception("非法文件名或目录名!");

                }

                if (!Directory.Exists(LocalPath))

                {

                    throw new Exception("本地文件路径不存在!");

                }

                string LocalFullPath = Path.Combine(LocalPath, LocalFileName);

                if (File.Exists(LocalFullPath))

                {

                    throw new Exception("当前路径下已经存在同名文件！");

                }

                bt = DownloadFile(RemoteFileName);

                if (bt != null)

                {

                    FileStream stream = new FileStream(LocalFullPath, FileMode.Create);

                    stream.Write(bt, 0, bt.Length);

                    stream.Flush();

                    stream.Close();

                    return true;

                }

                else

                {

                    return false;

                }

            }

            catch (Exception ep)

            {

                ErrorMsg = ep.ToString();

                throw ep;

            }

        }

        /// <summary>

        /// 从FTP服务器下载文件，返回文件二进制数据

        /// </summary>

        /// <param name="RemoteFileName">远程文件名</param>

        public byte[] DownloadFile(string RemoteFileName)

        {

            try

            {

                if (!IsValidFileChars(RemoteFileName))

                {

                    throw new Exception("非法文件名或目录名!");

                }

                Response = Open(new Uri(this.Uri.ToString() + RemoteFileName), WebRequestMethods.Ftp.DownloadFile);

                Stream Reader = Response.GetResponseStream();

                MemoryStream mem = new MemoryStream(1024 * 500);

                byte[] buffer = new byte[1024];

                int bytesRead = 0;

                int TotalByteRead = 0;

                while (true)

                {

                    bytesRead = Reader.Read(buffer, 0, buffer.Length);

                    TotalByteRead += bytesRead;

                    if (bytesRead == 0)

                        break;

                    mem.Write(buffer, 0, bytesRead);

                }

                if (mem.Length > 0)

                {

                    return mem.ToArray();

                }

                else

                {

                    return null;

                }

            }

            catch (Exception ep)

            {

                ErrorMsg = ep.ToString();

                throw ep;

            }

        }

        #endregion

        #region 异步下载文件

        /// <summary>

        /// 从FTP服务器异步下载文件，指定本地路径和本地文件名

        /// </summary>

        /// <param name="RemoteFileName">远程文件名</param>        

        /// <param name="LocalPath">保存文件的本地路径,后面带有"\"</param>

        /// <param name="LocalFileName">保存本地的文件名</param>

        public void DownloadFileAsync(string RemoteFileName, string LocalPath, string LocalFileName)

        {

            byte[] bt = null;

            try

            {

                if (!IsValidFileChars(RemoteFileName) || !IsValidFileChars(LocalFileName) || !IsValidPathChars(LocalPath))

                {

                    throw new Exception("非法文件名或目录名!");

                }

                if (!Directory.Exists(LocalPath))

                {

                    throw new Exception("本地文件路径不存在!");

                }

                string LocalFullPath = Path.Combine(LocalPath, LocalFileName);

                if (File.Exists(LocalFullPath))

                {

                    throw new Exception("当前路径下已经存在同名文件！");

                }

                DownloadFileAsync(RemoteFileName, LocalFullPath);

            }

            catch (Exception ep)

            {

                ErrorMsg = ep.ToString();

                throw ep;

            }

        }

        /// <summary>

        /// 从FTP服务器异步下载文件，指定本地完整路径文件名

        /// </summary>

        /// <param name="RemoteFileName">远程文件名</param>

        /// <param name="LocalFullPath">本地完整路径文件名</param>

        public void DownloadFileAsync(string RemoteFileName, string LocalFullPath)

        {

            try

            {

                if (!IsValidFileChars(RemoteFileName))

                {

                    throw new Exception("非法文件名或目录名!");

                }

                if (File.Exists(LocalFullPath))

                {

                    throw new Exception("当前路径下已经存在同名文件！");

                }

                MyWebClient client = new MyWebClient();

                client.DownloadProgressChanged += new DownloadProgressChangedEventHandler(client_DownloadProgressChanged);

                client.DownloadFileCompleted += new System.ComponentModel.AsyncCompletedEventHandler(client_DownloadFileCompleted);

                client.Credentials = new NetworkCredential(this.UserName, this.Password);

                if (this.Proxy != null)

                {

                    client.Proxy = this.Proxy;

                }

                client.DownloadFileAsync(new Uri(this.Uri.ToString() + RemoteFileName), LocalFullPath);

            }

            catch (Exception ep)

            {

                ErrorMsg = ep.ToString();

                throw ep;

            }

        }

        /// <summary>

        /// 异步下载文件完成之后触发的事件

        /// </summary>

        /// <param name="sender">下载对象</param>

        /// <param name="e">数据信息对象</param>

        void client_DownloadFileCompleted(object sender, System.ComponentModel.AsyncCompletedEventArgs e)

        {

            if (DownloadDataCompleted != null)

            {

                DownloadDataCompleted(sender, e);

            }

        }

        /// <summary>

        /// 异步下载进度发生改变触发的事件

        /// </summary>

        /// <param name="sender">下载对象</param>

        /// <param name="e">进度信息对象</param>

        void client_DownloadProgressChanged(object sender, DownloadProgressChangedEventArgs e)

        {

            if (DownloadProgressChanged != null)

            {

                DownloadProgressChanged(sender, e);

            }

        }

        #endregion

        #region 上传文件

        /// <summary>

        /// 上传文件到FTP服务器

        /// </summary>

        /// <param name="LocalFullPath">本地带有完整路径的文件名</param>

        public bool UploadFile(string LocalFullPath)

        {

            return UploadFile(LocalFullPath, Path.GetFileName(LocalFullPath), false);

        }

        /// <summary>

        /// 上传文件到FTP服务器

        /// </summary>

        /// <param name="LocalFullPath">本地带有完整路径的文件</param>

        /// <param name="OverWriteRemoteFile">是否覆盖远程服务器上面同名的文件</param>

        public bool UploadFile(string LocalFullPath, bool OverWriteRemoteFile)

        {

            return UploadFile(LocalFullPath, Path.GetFileName(LocalFullPath), OverWriteRemoteFile);

        }

        /// <summary>

        /// 上传文件到FTP服务器

        /// </summary>

        /// <param name="LocalFullPath">本地带有完整路径的文件</param>

        /// <param name="RemoteFileName">要在FTP服务器上面保存文件名</param>

        public bool UploadFile(string LocalFullPath, string RemoteFileName)

        {

            return UploadFile(LocalFullPath, RemoteFileName, false);

        }

        /// <summary>

        /// 上传文件到FTP服务器

        /// </summary>

        /// <param name="LocalFullPath">本地带有完整路径的文件名</param>

        /// <param name="RemoteFileName">要在FTP服务器上面保存文件名</param>

        /// <param name="OverWriteRemoteFile">是否覆盖远程服务器上面同名的文件</param>

        public bool UploadFile(string LocalFullPath, string RemoteFileName, bool OverWriteRemoteFile)

        {

            try

            {

                if (!IsValidFileChars(RemoteFileName) || !IsValidFileChars(Path.GetFileName(LocalFullPath)) || !IsValidPathChars(Path.GetDirectoryName(LocalFullPath)))

                {

                    throw new Exception("非法文件名或目录名!");

                }

                if (File.Exists(LocalFullPath))

                {

                    FileStream Stream = new FileStream(LocalFullPath, FileMode.Open, FileAccess.Read);

                    byte[] bt = new byte[Stream.Length];

                    Stream.Read(bt, 0, (Int32)Stream.Length);   //注意，因为Int32的最大限制，最大上传文件只能是大约2G多一点

                    Stream.Close();

                    return UploadFile(bt, RemoteFileName, OverWriteRemoteFile);

                }

                else

                {

                    throw new Exception("本地文件不存在!");

                }

            }

            catch (Exception ep)

            {

                ErrorMsg = ep.ToString();

                throw ep;

            }

        }

        /// <summary>

        /// 上传文件到FTP服务器

        /// </summary>

        /// <param name="FileBytes">上传的二进制数据</param>

        /// <param name="RemoteFileName">要在FTP服务器上面保存文件名</param>

        public bool UploadFile(byte[] FileBytes, string RemoteFileName)

        {

            if (!IsValidFileChars(RemoteFileName))

            {

                throw new Exception("非法文件名或目录名!");

            }

            return UploadFile(FileBytes, RemoteFileName, false);

        }

        /// <summary>

        /// 上传文件到FTP服务器

        /// </summary>

        /// <param name="FileBytes">文件二进制内容</param>

        /// <param name="RemoteFileName">要在FTP服务器上面保存文件名</param>

        /// <param name="OverWriteRemoteFile">是否覆盖远程服务器上面同名的文件</param>

        public bool UploadFile(byte[] FileBytes, string RemoteFileName, bool OverWriteRemoteFile)

        {

            try

            {

                if (!IsValidFileChars(RemoteFileName))

                {

                    throw new Exception("非法文件名！");

                }

                if (!OverWriteRemoteFile && FileExist(RemoteFileName))

                {

                    throw new Exception("FTP服务上面已经存在同名文件！");

                }

                Response = Open(new Uri(this.Uri.ToString() + RemoteFileName), WebRequestMethods.Ftp.UploadFile);

                Stream requestStream = Request.GetRequestStream();

                MemoryStream mem = new MemoryStream(FileBytes);

                byte[] buffer = new byte[1024];

                int bytesRead = 0;

                int TotalRead = 0;

                while (true)

                {

                    bytesRead = mem.Read(buffer, 0, buffer.Length);

                    if (bytesRead == 0)

                        break;

                    TotalRead += bytesRead;

                    requestStream.Write(buffer, 0, bytesRead);

                }

                requestStream.Close();

                Response = (FtpWebResponse)Request.GetResponse();

                mem.Close();

                mem.Dispose();

                FileBytes = null;

                return true;

            }

            catch (Exception ep)

            {

                ErrorMsg = ep.ToString();

                throw ep;

            }

        }

        #endregion

        #region 异步上传文件

        /// <summary>

        /// 异步上传文件到FTP服务器

        /// </summary>

        /// <param name="LocalFullPath">本地带有完整路径的文件名</param>

        public void UploadFileAsync(string LocalFullPath)

        {

            UploadFileAsync(LocalFullPath, Path.GetFileName(LocalFullPath), false);

        }

        /// <summary>

        /// 异步上传文件到FTP服务器

        /// </summary>

        /// <param name="LocalFullPath">本地带有完整路径的文件</param>

        /// <param name="OverWriteRemoteFile">是否覆盖远程服务器上面同名的文件</param>

        public void UploadFileAsync(string LocalFullPath, bool OverWriteRemoteFile)

        {

            UploadFileAsync(LocalFullPath, Path.GetFileName(LocalFullPath), OverWriteRemoteFile);

        }

        /// <summary>

        /// 异步上传文件到FTP服务器

        /// </summary>

        /// <param name="LocalFullPath">本地带有完整路径的文件</param>

        /// <param name="RemoteFileName">要在FTP服务器上面保存文件名</param>

        public void UploadFileAsync(string LocalFullPath, string RemoteFileName)

        {

            UploadFileAsync(LocalFullPath, RemoteFileName, false);

        }

        /// <summary>

        /// 异步上传文件到FTP服务器

        /// </summary>

        /// <param name="LocalFullPath">本地带有完整路径的文件名</param>

        /// <param name="RemoteFileName">要在FTP服务器上面保存文件名</param>

        /// <param name="OverWriteRemoteFile">是否覆盖远程服务器上面同名的文件</param>

        public void UploadFileAsync(string LocalFullPath, string RemoteFileName, bool OverWriteRemoteFile)

        {

            try

            {

                if (!IsValidFileChars(RemoteFileName) || !IsValidFileChars(Path.GetFileName(LocalFullPath)) || !IsValidPathChars(Path.GetDirectoryName(LocalFullPath)))

                {

                    throw new Exception("非法文件名或目录名!");

                }

                if (!OverWriteRemoteFile && FileExist(RemoteFileName))

                {

                    throw new Exception("FTP服务上面已经存在同名文件！");

                }

                if (File.Exists(LocalFullPath))

                {

                    MyWebClient client = new MyWebClient();

                    client.UploadProgressChanged += new UploadProgressChangedEventHandler(client_UploadProgressChanged);

                    client.UploadFileCompleted += new UploadFileCompletedEventHandler(client_UploadFileCompleted);

                    client.Credentials = new NetworkCredential(this.UserName, this.Password);

                    if (this.Proxy != null)

                    {

                        client.Proxy = this.Proxy;

                    }

                    client.UploadFileAsync(new Uri(this.Uri.ToString() + RemoteFileName), LocalFullPath);

                }

                else

                {

                    throw new Exception("本地文件不存在!");

                }

            }

            catch (Exception ep)

            {

                ErrorMsg = ep.ToString();

                throw ep;

            }

        }

        /// <summary>

        /// 异步上传文件到FTP服务器

        /// </summary>

        /// <param name="FileBytes">上传的二进制数据</param>

        /// <param name="RemoteFileName">要在FTP服务器上面保存文件名</param>

        public void UploadFileAsync(byte[] FileBytes, string RemoteFileName)

        {

            if (!IsValidFileChars(RemoteFileName))

            {

                throw new Exception("非法文件名或目录名!");

            }

            UploadFileAsync(FileBytes, RemoteFileName, false);

        }

        /// <summary>

        /// 异步上传文件到FTP服务器

        /// </summary>

        /// <param name="FileBytes">文件二进制内容</param>

        /// <param name="RemoteFileName">要在FTP服务器上面保存文件名</param>

        /// <param name="OverWriteRemoteFile">是否覆盖远程服务器上面同名的文件</param>

        public void UploadFileAsync(byte[] FileBytes, string RemoteFileName, bool OverWriteRemoteFile)

        {

            try

            {

                if (!IsValidFileChars(RemoteFileName))

                {

                    throw new Exception("非法文件名！");

                }

                if (!OverWriteRemoteFile && FileExist(RemoteFileName))

                {

                    throw new Exception("FTP服务上面已经存在同名文件！");

                }

                string TempPath = System.Environment.GetFolderPath(Environment.SpecialFolder.Templates);

                if (!TempPath.EndsWith("\\"))

                {

                    TempPath += "\\";

                }

                string TempFile = TempPath + Path.GetRandomFileName();

                TempFile = Path.ChangeExtension(TempFile, Path.GetExtension(RemoteFileName));

                FileStream Stream = new FileStream(TempFile, FileMode.CreateNew, FileAccess.Write);

                Stream.Write(FileBytes, 0, FileBytes.Length);   //注意，因为Int32的最大限制，最大上传文件只能是大约2G多一点

                Stream.Flush();

                Stream.Close();

                Stream.Dispose();

                _isDeleteTempFile = true;

                _UploadTempFile = TempFile;

                FileBytes = null;

                UploadFileAsync(TempFile, RemoteFileName, OverWriteRemoteFile);

            }

            catch (Exception ep)

            {

                ErrorMsg = ep.ToString();

                throw ep;

            }

        }

        /// <summary>

        /// 异步上传文件完成之后触发的事件

        /// </summary>

        /// <param name="sender">下载对象</param>

        /// <param name="e">数据信息对象</param>

        void client_UploadFileCompleted(object sender, UploadFileCompletedEventArgs e)

        {

            if (_isDeleteTempFile)

            {

                if (File.Exists(_UploadTempFile))

                {

                    File.SetAttributes(_UploadTempFile, FileAttributes.Normal);

                    File.Delete(_UploadTempFile);

                }

                _isDeleteTempFile = false;

            }

            if (UploadFileCompleted != null)

            {

                UploadFileCompleted(sender, e);

            }

        }

        /// <summary>

        /// 异步上传进度发生改变触发的事件

        /// </summary>

        /// <param name="sender">下载对象</param>

        /// <param name="e">进度信息对象</param>

        void client_UploadProgressChanged(object sender, UploadProgressChangedEventArgs e)

        {

            if (UploadProgressChanged != null)

            {

                UploadProgressChanged(sender, e);

            }

        }

        #endregion

        #region 列出目录文件信息

        /// <summary>

        /// 列出FTP服务器上面当前目录的所有文件和目录

        /// </summary>

        public FileStruct[] ListFilesAndDirectories()

        {

            Response = Open(this.Uri, WebRequestMethods.Ftp.ListDirectoryDetails);

            StreamReader stream = new StreamReader(Response.GetResponseStream(), Encoding.Default);

            string Datastring = stream.ReadToEnd();

            FileStruct[] list = GetList(Datastring);

            return list;

        }

        /// <summary>

        /// 列出FTP服务器上面当前目录的所有文件

        /// </summary>

        public FileStruct[] ListFiles()

        {

            FileStruct[] listAll = ListFilesAndDirectories();

            List<FileStruct> listFile = new List<FileStruct>();

            foreach (FileStruct file in listAll)

            {

                if (!file.IsDirectory)

                {

                    listFile.Add(file);

                }

            }

            return listFile.ToArray();

        }

        /// <summary>

        /// 列出FTP服务器上面当前目录的所有的目录

        /// </summary>

        public FileStruct[] ListDirectories()

        {

            FileStruct[] listAll = ListFilesAndDirectories();

            List<FileStruct> listDirectory = new List<FileStruct>();

            foreach (FileStruct file in listAll)

            {

                if (file.IsDirectory)

                {

                    listDirectory.Add(file);

                }

            }

            return listDirectory.ToArray();

        }

        /// <summary>

        /// 获得文件和目录列表

        /// </summary>

        /// <param name="datastring">FTP返回的列表字符信息</param>

        private FileStruct[] GetList(string datastring)

        {

            List<FileStruct> myListArray = new List<FileStruct>();

            string[] dataRecords = datastring.Split('\n');

            FileListStyle _directoryListStyle = GuessFileListStyle(dataRecords);

            foreach (string s in dataRecords)

            {

                if (_directoryListStyle != FileListStyle.Unknown && s != "")

                {

                    FileStruct f = new FileStruct();

                    f.Name = "..";

                    switch (_directoryListStyle)

                    {

                        case FileListStyle.UnixStyle:

                            f = ParseFileStructFromUnixStyleRecord(s);

                            break;

                        case FileListStyle.WindowsStyle:

                            f = ParseFileStructFromWindowsStyleRecord(s);

                            break;

                    }

                    if (!(f.Name == "." || f.Name == ".."))

                    {

                        myListArray.Add(f);

                    }

                }

            }

            return myListArray.ToArray();

        }

        /// <summary>

        /// 从Windows格式中返回文件信息

        /// </summary>

        /// <param name="Record">文件信息</param>

        private FileStruct ParseFileStructFromWindowsStyleRecord(string Record)

        {

            FileStruct f = new FileStruct();

            string processstr = Record.Trim();

            string dateStr = processstr.Substring(0, 8);

            processstr = (processstr.Substring(8, processstr.Length - 8)).Trim();

            string timeStr = processstr.Substring(0, 7);

            processstr = (processstr.Substring(7, processstr.Length - 7)).Trim();

            DateTimeFormatInfo myDTFI = new CultureInfo("en-US", false).DateTimeFormat;

            myDTFI.ShortTimePattern = "t";

            f.CreateTime = DateTime.Parse(dateStr + " " + timeStr, myDTFI);

            if (processstr.Substring(0, 5) == "<DIR>")

            {

                f.IsDirectory = true;

                processstr = (processstr.Substring(5, processstr.Length - 5)).Trim();

            }

            else

            {

                string[] strs = processstr.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);   // true);

                processstr = strs[1];

                f.IsDirectory = false;

            }

            f.Name = processstr;

            return f;

        }

        /// <summary>

        /// 判断文件列表的方式Window方式还是Unix方式

        /// </summary>

        /// <param name="recordList">文件信息列表</param>

        private FileListStyle GuessFileListStyle(string[] recordList)

        {

            foreach (string s in recordList)

            {

                if (s.Length > 10

                 && Regex.IsMatch(s.Substring(0, 10), "(-|d)(-|r)(-|w)(-|x)(-|r)(-|w)(-|x)(-|r)(-|w)(-|x)"))

                {

                    return FileListStyle.UnixStyle;

                }

                else if (s.Length > 8

                 && Regex.IsMatch(s.Substring(0, 8), "[0-9][0-9]-[0-9][0-9]-[0-9][0-9]"))

                {

                    return FileListStyle.WindowsStyle;

                }

            }

            return FileListStyle.Unknown;

        }

        /// <summary>

        /// 从Unix格式中返回文件信息

        /// </summary>

        /// <param name="Record">文件信息</param>

        private FileStruct ParseFileStructFromUnixStyleRecord(string Record)

        {

            FileStruct f = new FileStruct();

            string processstr = Record.Trim();

            f.Flags = processstr.Substring(0, 10);

            f.IsDirectory = (f.Flags[0] == 'd');

            processstr = (processstr.Substring(11)).Trim();

            _cutSubstringFromStringWithTrim(ref processstr, ' ', 0);   //跳过一部分

            f.Owner = _cutSubstringFromStringWithTrim(ref processstr, ' ', 0);

            f.Group = _cutSubstringFromStringWithTrim(ref processstr, ' ', 0);

            _cutSubstringFromStringWithTrim(ref processstr, ' ', 0);   //跳过一部分

            string yearOrTime = processstr.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)[2];

            if (yearOrTime.IndexOf(":") >= 0)  //time

            {

                processstr = processstr.Replace(yearOrTime, DateTime.Now.Year.ToString());

            }

            f.CreateTime = DateTime.Parse(_cutSubstringFromStringWithTrim(ref processstr, ' ', 8));

            f.Name = processstr;   //最后就是名称

            return f;

        }

        /// <summary>

        /// 按照一定的规则进行字符串截取

        /// </summary>

        /// <param name="s">截取的字符串</param>

        /// <param name="c">查找的字符</param>

        /// <param name="startIndex">查找的位置</param>

        private string _cutSubstringFromStringWithTrim(ref string s, char c, int startIndex)

        {

            int pos1 = s.IndexOf(c, startIndex);

            string retString = s.Substring(0, pos1);

            s = (s.Substring(pos1)).Trim();

            return retString;

        }

        #endregion

        #region 目录或文件存在的判断

        /// <summary>

        /// 判断当前目录下指定的子目录是否存在

        /// </summary>

        /// <param name="RemoteDirectoryName">指定的目录名</param>

        public bool DirectoryExist(string RemoteDirectoryName)

        {

            try

            {

                if (!IsValidPathChars(RemoteDirectoryName))

                {

                    throw new Exception("目录名非法！");

                }

                FileStruct[] listDir = ListDirectories();

                foreach (FileStruct dir in listDir)

                {

                    if (dir.Name == RemoteDirectoryName)

                    {

                        return true;

                    }

                }

                return false;

            }

            catch (Exception ep)

            {

                ErrorMsg = ep.ToString();

                throw ep;

            }

        }

        /// <summary>

        /// 判断一个远程文件是否存在服务器当前目录下面

        /// </summary>

        /// <param name="RemoteFileName">远程文件名</param>

        public bool FileExist(string RemoteFileName)

        {

            try

            {

                if (!IsValidFileChars(RemoteFileName))

                {

                    throw new Exception("文件名非法！");

                }

                FileStruct[] listFile = ListFiles();

                foreach (FileStruct file in listFile)

                {

                    if (file.Name == RemoteFileName)

                    {

                        return true;

                    }

                }

                return false;

            }

            catch (Exception ep)

            {

                ErrorMsg = ep.ToString();

                throw ep;

            }

        }

        #endregion

        #region 删除文件

        /// <summary>

        /// 从FTP服务器上面删除一个文件

        /// </summary>

        /// <param name="RemoteFileName">远程文件名</param>

        public void DeleteFile(string RemoteFileName)

        {

            try

            {

                if (!IsValidFileChars(RemoteFileName))

                {

                    throw new Exception("文件名非法！");

                }

                Response = Open(new Uri(this.Uri.ToString() + RemoteFileName), WebRequestMethods.Ftp.DeleteFile);

            }

            catch (Exception ep)

            {

                ErrorMsg = ep.ToString();

                throw ep;

            }

        }

        #endregion

        #region 重命名文件

        /// <summary>

        /// 更改一个文件的名称或一个目录的名称

        /// </summary>

        /// <param name="RemoteFileName">原始文件或目录名称</param>

        /// <param name="NewFileName">新的文件或目录的名称</param>

        public bool ReName(string RemoteFileName, string NewFileName)

        {

            try

            {

                if (!IsValidFileChars(RemoteFileName) || !IsValidFileChars(NewFileName))

                {

                    throw new Exception("文件名非法！");

                }

                if (RemoteFileName == NewFileName)

                {

                    return true;

                }

                if (FileExist(RemoteFileName))

                {

                    Request = OpenRequest(new Uri(this.Uri.ToString() + RemoteFileName), WebRequestMethods.Ftp.Rename);

                    Request.RenameTo = NewFileName;

                    Response = (FtpWebResponse)Request.GetResponse();

                }

                else

                {

                    throw new Exception("文件在服务器上不存在！");

                }

                return true;

            }

            catch (Exception ep)

            {

                ErrorMsg = ep.ToString();

                throw ep;

            }

        }

        #endregion

        #region 拷贝、移动文件

        /// <summary>

        /// 把当前目录下面的一个文件拷贝到服务器上面另外的目录中，注意，拷贝文件之后，当前工作目录还是文件原来所在的目录

        /// </summary>

        /// <param name="RemoteFile">当前目录下的文件名</param>

        /// <param name="DirectoryName">新目录名称。

        /// 说明：如果新目录是当前目录的子目录，则直接指定子目录。如: SubDirectory1/SubDirectory2 ；

        /// 如果新目录不是当前目录的子目录，则必须从根目录一级一级的指定。如： ./NewDirectory/SubDirectory1/SubDirectory2

        /// </param>

        /// <returns></returns>

        public bool CopyFileToAnotherDirectory(string RemoteFile, string DirectoryName)

        {

            string CurrentWorkDir = this.DirectoryPath;

            try

            {

                byte[] bt = DownloadFile(RemoteFile);

                GotoDirectory(DirectoryName);

                bool Success = UploadFile(bt, RemoteFile, false);

                this.DirectoryPath = CurrentWorkDir;

                return Success;

            }

            catch (Exception ep)

            {

                this.DirectoryPath = CurrentWorkDir;

                ErrorMsg = ep.ToString();

                throw ep;

            }

        }

        /// <summary>

        /// 把当前目录下面的一个文件移动到服务器上面另外的目录中，注意，移动文件之后，当前工作目录还是文件原来所在的目录

        /// </summary>

        /// <param name="RemoteFile">当前目录下的文件名</param>

        /// <param name="DirectoryName">新目录名称。

        /// 说明：如果新目录是当前目录的子目录，则直接指定子目录。如: SubDirectory1/SubDirectory2 ；

        /// 如果新目录不是当前目录的子目录，则必须从根目录一级一级的指定。如： ./NewDirectory/SubDirectory1/SubDirectory2

        /// </param>

        /// <returns></returns>

        public bool MoveFileToAnotherDirectory(string RemoteFile, string DirectoryName)

        {

            string CurrentWorkDir = this.DirectoryPath;

            try

            {

                if (DirectoryName == "")

                    return false;

                if (!DirectoryName.StartsWith("/"))

                    DirectoryName = "/" + DirectoryName;

                if (!DirectoryName.EndsWith("/"))

                    DirectoryName += "/";

                bool Success = ReName(RemoteFile, DirectoryName + RemoteFile);

                this.DirectoryPath = CurrentWorkDir;

                return Success;

            }

            catch (Exception ep)

            {

                this.DirectoryPath = CurrentWorkDir;

                ErrorMsg = ep.ToString();

                throw ep;

            }

        }

        #endregion

        #region 建立、删除子目录

        /// <summary>

        /// 在FTP服务器上当前工作目录建立一个子目录

        /// </summary>

        /// <param name="DirectoryName">子目录名称</param>

        public bool MakeDirectory(string DirectoryName)

        {

            try

            {

                if (!IsValidPathChars(DirectoryName))

                {

                    throw new Exception("目录名非法！");

                }

                if (DirectoryExist(DirectoryName))

                {

                    throw new Exception("服务器上面已经存在同名的文件名或目录名！");

                }

                Response = Open(new Uri(this.Uri.ToString() + DirectoryName), WebRequestMethods.Ftp.MakeDirectory);

                return true;

            }

            catch (Exception ep)

            {

                ErrorMsg = ep.ToString();

                throw ep;

            }

        }

        /// <summary>

        /// 从当前工作目录中删除一个子目录

        /// </summary>

        /// <param name="DirectoryName">子目录名称</param>

        public bool RemoveDirectory(string DirectoryName)

        {

            try

            {

                if (!IsValidPathChars(DirectoryName))

                {

                    throw new Exception("目录名非法！");

                }

                if (!DirectoryExist(DirectoryName))

                {

                    throw new Exception("服务器上面不存在指定的文件名或目录名！");

                }

                Response = Open(new Uri(this.Uri.ToString() + DirectoryName), WebRequestMethods.Ftp.RemoveDirectory);

                return true;

            }

            catch (Exception ep)

            {

                ErrorMsg = ep.ToString();

                throw ep;

            }

        }

        #endregion

        #region 文件、目录名称有效性判断

        /// <summary>

        /// 判断目录名中字符是否合法

        /// </summary>

        /// <param name="DirectoryName">目录名称</param>

        public bool IsValidPathChars(string DirectoryName)

        {

            char[] invalidPathChars = Path.GetInvalidPathChars();

            char[] DirChar = DirectoryName.ToCharArray();

            foreach (char C in DirChar)

            {

                if (Array.BinarySearch(invalidPathChars, C) >= 0)

                {

                    return false;

                }

            }

            return true;

        }

        /// <summary>

        /// 判断文件名中字符是否合法

        /// </summary>

        /// <param name="FileName">文件名称</param>

        public bool IsValidFileChars(string FileName)

        {

            char[] invalidFileChars = Path.GetInvalidFileNameChars();

            char[] NameChar = FileName.ToCharArray();

            foreach (char C in NameChar)

            {

                if (Array.BinarySearch(invalidFileChars, C) >= 0)

                {

                    return false;

                }

            }

            return true;

        }

        #endregion

        #region 目录切换操作

        /// <summary>

        /// 进入一个目录

        /// </summary>

        /// <param name="DirectoryName">

        /// 新目录的名字。 

        /// 说明：如果新目录是当前目录的子目录，则直接指定子目录。如: SubDirectory1/SubDirectory2 ； 

        /// 如果新目录不是当前目录的子目录，则必须从根目录一级一级的指定。如： ./NewDirectory/SubDirectory1/SubDirectory2

        /// </param>

        public bool GotoDirectory(string DirectoryName)

        {

            string CurrentWorkPath = this.DirectoryPath;

            try

            {

                DirectoryName = DirectoryName.Replace("\\", "/");

                string[] DirectoryNames = DirectoryName.Split(new char[] { '/' });

                if (DirectoryNames[0] == ".")

                {

                    this.DirectoryPath = "/";

                    if (DirectoryNames.Length == 1)

                    {

                        return true;

                    }

                    Array.Clear(DirectoryNames, 0, 1);

                }

                bool Success = false;

                foreach (string dir in DirectoryNames)

                {

                    if (dir != null)

                    {

                        Success = EnterOneSubDirectory(dir);

                        if (!Success)

                        {

                            this.DirectoryPath = CurrentWorkPath;

                            return false;

                        }

                    }

                }

                return Success;

            }

            catch (Exception ep)

            {

                this.DirectoryPath = CurrentWorkPath;

                ErrorMsg = ep.ToString();

                throw ep;

            }

        }

        /// <summary>

        /// 从当前工作目录进入一个子目录

        /// </summary>

        /// <param name="DirectoryName">子目录名称</param>

        private bool EnterOneSubDirectory(string DirectoryName)

        {

            try

            {

                if (DirectoryName.IndexOf("/") >= 0 || !IsValidPathChars(DirectoryName))

                {

                    throw new Exception("目录名非法!");

                }

                if (DirectoryName.Length > 0 && DirectoryExist(DirectoryName))

                {

                    if (!DirectoryName.EndsWith("/"))

                    {

                        DirectoryName += "/";

                    }

                    _DirectoryPath += DirectoryName;

                    return true;

                }

                else

                {

                    return false;

                }

            }

            catch (Exception ep)

            {

                ErrorMsg = ep.ToString();

                throw ep;

            }

        }

        /// <summary>

        /// 从当前工作目录往上一级目录

        /// </summary>

        public bool ComeoutDirectory()

        {

            if (_DirectoryPath == "/")

            {

                ErrorMsg = "当前目录已经是根目录！";

                throw new Exception("当前目录已经是根目录！");

            }

            char[] sp = new char[1] { '/' };

            string[] strDir = _DirectoryPath.Split(sp, StringSplitOptions.RemoveEmptyEntries);

            if (strDir.Length == 1)

            {

                _DirectoryPath = "/";

            }

            else

            {

                _DirectoryPath = String.Join("/", strDir, 0, strDir.Length - 1);

            }

            return true;

        }

        #endregion

        #region 重载WebClient，支持FTP进度

        internal class MyWebClient : WebClient

        {

            protected override WebRequest GetWebRequest(Uri address)

            {

                FtpWebRequest req = (FtpWebRequest)base.GetWebRequest(address);

                req.UsePassive = false;

                return req;

            }

        }

        #endregion

    }
}

测试调用方法

private clsFTP cf;

        private void button1_Click(object sender, EventArgs e)

        {

          

            this.label1.Text = "正在上传文件，请等待...";

            cf = new clsFTP(new Uri("ftp://121.41.76.132"), "test", "test");

            /*string localFile = @"F:\星星知我心\常用工具\jdk-8u45-windows-x64.exe";

            cf.UploadProgressChanged += new clsFTP.De_UploadProgressChanged(cf_UploadProgressChanged);

            cf.UploadFileCompleted += new clsFTP.De_UploadFileCompleted(cf_UploadFileCompleted);

            cf.UploadFileAsync(localFile, true);  //调用异步传输，若有文件存在则覆盖。*/

            //bool flag=cf.DirectoryExist("style1");

            bool flag = cf.RemoveDirectory("111");

            MessageBox.Show(flag.ToString());

        }

        public void cf_UploadProgressChanged(object sender, UploadProgressChangedEventArgs e)

        {

            this.progressBar1.Maximum = (int)e.TotalBytesToSend;

            this.progressBar1.Value = (int)e.BytesSent;

            label1.Text = string.Format("文件总大小：{0}k，已经上传： {1}k。", e.TotalBytesToSend / 1024, e.BytesSent / 1024);

        }

        public void cf_UploadFileCompleted(object sender, UploadFileCompletedEventArgs e)

        {

            try

            {

                label1.Text = "文件上传成功！";

                

            }

            catch

            {

                label1.Text = e.Error.Message.ToString();

            }

        }