.Net 2.0对文件传输协议(FTP)操作(上传,下载,新建,删除,FTP间传送文件等) 2

最新推荐文章于 2024-11-15 01:36:35 发布
最新推荐文章于 2024-11-15 01:36:35 发布
阅读量1.7k 收藏 1
点赞数
分类专栏： FTP TCP/IP 等协议 文章标签： .net ftp服务器 callback byte buffer object

在上一篇中介绍的文件上传下载都是基于同步操作.本篇将就异步操作做个总结.
本篇主要总结WebClient类异步上传实现方式和FtpWebRequest类异步上传实现方式,其实明白了异步上传,异步下载就是同样的道理实现.

1.WebClient异步上传
关键知识说明：
WebClient类提供4个异步上传方法,使用方法都是差不多的.
WebClient.UploadDataAsync方法
将数据缓冲区上载到指定的资源

WebClient.UploadFileAsync方法
将指定的本地文件上载到指定的资源

WebClient.UploadStringAsync方法
将指定的字符串上载到指定的资源

WebClient.UploadValuesAsync方法
将指定的名称/值集合上载到指定的资源

其中一个方法签名如下:
public void UploadDataAsync (
 Uri address,
 string method,
 byte[] data,
 Object userToken
)
参数
address
接收数据的资源的URI
method
用于将文件发送到资源的HTTP方法。如果为空，则对于http默认值为POST，对于ftp默认值为STOR
data
要发送到资源的数据缓冲
userToken
一个用户定义对象，此对象将被传递给完成异步操作时所调用的方法

若要在数据的上载完成时收到通知,需要实现WebClient.UploadDataCompleted事件,此事件在每次完成异步数据上载操作时引发

总结WebClient异步上传实现步骤：
第一步：定义WebClient,设置各属性
第二步：注册完成事件UploadDataCompleted,以便完成上传时回调
第三步：调用UploadDataAsync方法开始异步上传文件
第四步：上传文件完成回调完成事件UploadDataCompleted定义的方法

实例代码：
把D:/n.txt文件上传到ftp://ftp.dygs2b.com

WebClient request  =   new  WebClient ( );

 // 注册完成事件，以便上传完成时,收到通知
request.UploadDataCompleted  +=   new  UploadDataCompletedEventHandler ( request_UploadDataCompleted );

 string  ftpUser  =   " a " ;
 string  ftpPassWord  =   " b " ;
request.Credentials  =   new  NetworkCredential ( ftpUser , ftpPassWord );

FileStream myStream  =   new  FileStream (  @" D:/n.txt "  , FileMode.Open , FileAccess.Read );
 byte  [ ] dataByte  =   new   byte  [ myStream.Length ];
myStream.Read ( dataByte ,  0  , dataByte.Length );         // 写到2进制数组中
myStream.Close ( );

Uri uri  =   new  Uri (  " ftp://ftp.dygs2b.com/n.txt "  );
request.UploadDataAsync ( uri ,  " STOR "  , dataByte , dataByte );

 void  request_UploadDataCompleted (  object  sender , UploadDataCompletedEventArgs e )
{
     // 接收UploadDataAsync传递过来的用户定义对象
     byte  [ ] dataByte  =  (  byte  [ ] ) e.UserState;

     // AsyncCompletedEventArgs.Error属性,获取一个值，该值指示异步操作期间发生的错误
     if  ( e.Error  ==   null  )
    {
        MessageBox.Show (  string .Format (  " 上传成功!文件大小{0} "  , dataByte.Length ) );
    }
     else
    {
        MessageBox.Show ( e.Error.Message );
    }
}

 

 

2.FtpWebRequest异步上传
使用FtpWebRequest对象向服务器上载文件，则必须将文件内容写入请求流，同步请求流是通过调用GetRequestStream方法,而异步对应方法是BeginGetRequestStream和EndGetRequestStream方法.

其中BeginGetRequestStream方法签名如下：
public override IAsyncResult BeginGetRequestStream (
 AsyncCallback callback,
 Object state
)

参数
callback
一个 AsyncCallback 委托，它引用操作完成时要调用的方法
state
一个用户定义对象，其中包含该操作的相关信息。当操作完成时，此对象会被传递给callback委托

必须调用EndGetRequestStream方法用来完成异步操作。通常，EndGetRequestStream由callback所引用的方法调用。

总结FtpWebRequest异步上传实现步骤：
第一步：定义FtpWebRequest,并设置相关属性
第二步：调用FtpWebRequest.BeginGetRequestStream方法,定义操作完成时要调用的方法EndGetResponseCallback,开始以异步方式打开请求的内容流以便写入.
第三步：实现EndGetResponseCallback方法,在此方法中调用FtpWebRequest.EndGetRequestStream方法,结束由BeginGetRequestStream启动的挂起的异步操作,再把本地的文件流数据写到请求流(RequestStream)中,再FtpWebRequest.BeginGetResponse方法,定义操作完成时要调用的方法EndGetResponseCallback,开始以异步方式向FTP服务器发送请求并从FTP服务器接收响应.
第四步：实现EndGetResponseCallback方法,在此方法中调用FtpWebRequest.EndGetResponse方法,结束由BeginGetResponse启动的挂起的异步操作.

实例代码：
把D:/n.txt文件上传到ftp://ftp.dygs2b.com

Uri uri  =   new  Uri (  " ftp://ftp.dygs2b.com/n.txt "  );

 // 定义FtpWebRequest,并设置相关属性
FtpWebRequest uploadRequest  =  ( FtpWebRequest ) WebRequest.Create ( uri );
uploadRequest.Method  =  WebRequestMethods.Ftp.UploadFile;

 string  ftpUser  =   " a " ;
 string  ftpPassWord  =   " b " ;
uploadRequest.Credentials  =   new  NetworkCredential ( ftpUser , ftpPassWord );

 // 开始以异步方式打开请求的内容流以便写入
uploadRequest.BeginGetRequestStream (  new  AsyncCallback ( EndGetStreamCallback ) , uploadRequest );

 

private   void  EndGetStreamCallback ( IAsyncResult ar )
{
     // 用户定义对象，其中包含该操作的相关信息,在这里得到FtpWebRequest
    FtpWebRequest uploadRequest  =  ( FtpWebRequest ) ar.AsyncState;

     // 结束由BeginGetRequestStream启动的挂起的异步操作
     // 必须调用EndGetRequestStream方法来完成异步操作
     // 通常EndGetRequestStream由callback所引用的方法调用
    Stream requestStream  =  uploadRequest.EndGetRequestStream ( ar );

    FileStream fileStream  =  File.Open (  @" D:/n.txt "  , FileMode.Open );

     byte  [ ] buffer  =   new   byte  [  1024  ];
     int  bytesRead;
     while  (  true  )
    {
        bytesRead  =  fileStream.Read ( buffer ,  0  , buffer.Length );
         if  ( bytesRead  ==   0  )
             break ;

         // 本地的文件流数据写到请求流
        requestStream.Write ( buffer ,  0  , bytesRead );
    }

    requestStream.Close ( );
    fileStream.Close ( );

     // 开始以异步方式向FTP服务器发送请求并从FTP服务器接收响应
    uploadRequest.BeginGetResponse (  new  AsyncCallback ( EndGetResponseCallback ) , uploadRequest );
}

private   void  EndGetResponseCallback ( IAsyncResult ar )
{
    FtpWebRequest uploadRequest  =  ( FtpWebRequest ) ar.AsyncState;

     // 结束由BeginGetResponse启动的挂起的异步操作
    FtpWebResponse uploadResponse  =  ( FtpWebResponse ) uploadRequest.EndGetResponse ( ar );

    MessageBox.Show ( uploadResponse.StatusDescription );
    MessageBox.Show (  " Upload complete "  );
}
 
附：
  
///** <summary>
    /// FTP处理操作类
    /// 功能：
    /// 下载文件
    /// 上传文件
    /// 上传文件的进度信息
    /// 下载文件的进度信息
    /// 删除文件
    /// 列出文件
    /// 列出目录
    /// 进入子目录
    /// 退出当前目录返回上一层目录
    /// 判断远程文件是否存在
    /// 判断远程文件是否存在
    /// 删除远程文件    
    /// 建立目录
    /// 删除目录
    /// 文件（目录）改名

    #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
    }
如果异步上传，ASP.NET页面的Async属性必须设置为True
cpcpc
关注
专栏目录
.Net 对文件传输协议(FTP)操作(上传,下载,新建,删除,FTP间传送文件等)
不抛弃，不放弃
11-09 1612
 最近项目需要对FTP服务器进行操作,现把实现总结如下：打算分2篇总结:第1篇总结Ftp的一些常规的操作实现(例如：上传,下载,新建,删除,FTP间互传文件等操作)第2篇总结Ftp的操作的一些其他实现(例如：异步上传,异步下载等其他操作)Microsoft .NET Framework 2.0新增加了3个类使我们很方便的对文件传输协议(FTP)服务器进行操作FtpWebRequest类：实现文件传
python统计指定目录中文件及目录个数_python 实现统计ftp服务器指定目录下文件夹数目、文件数目及所有文件大小...
weixin_39947016的博客
11-24 789
本次主要为满足应用方核对上传到ftp服务器的文件是否缺漏。主要要求：指定目录下，文件夹数目/文件数目/所有文件大小，类似Windows如下功能：模块介绍：from ftplib import FTPftp = FTP() #设置变量ftp.set_debuglevel(2) #打开调试级别2 显示详细信息ftp.connect("IP", "port") #连接ftp, IP和端口ftp.log(...
Microsoft .NET Framework 2.0对文件传输协议(FTP)操作(异步上传,下载等)实现汇总2
weixin_34417635的博客
12-12 115
相关文章导航 Sql Server2005 Transact-SQL 新兵器学习总结之-总结 Flex,Fms3相关文章索引 FlexAir开源版-全球免费多人视频聊天室,免费网络远程多人视频会议系统((Flex,Fms3联合开发))&lt;视频聊天,会议开发实例8&gt;     在上一篇中介绍的文件上传下载都是基于同步操作.本篇将就异步操作做个总结.本篇主要总结WebCl...
FastApi中UploadFile如何支持多次读取
sunshine2853的专栏
08-28 433
pd.read_excel(file, engine='openpyxl')出现了一个很奇怪的报错：zipfile.BadZipFile: File is not a zip file。在执行到eva_task函数的时候，传进去的参数test_file.file.read()总是0bytes，导致。再进一步排查发现是UploadFile不能连续读取两次，在读取过一次后，指针已经指向了文件的末尾。方法一：将数据读取后存入BytesIO后续使用。方法，要搭配「await」使用。方法二：再次读取时使用。
【Element plus】upload上传下载（大小限制，重复上传限制，删除文件处理）
m0_67372185的博客
05-05 4097
upload组件，文件上传大小限制，重复上传限制，删除文件处理
C#webClient.DownloadFileAsync异步源码
02-27
//用于新手学习异步操作 //例子简单,下载字符串也是一个道理
使用C#WebClient类访问（上传/下载/删除/列出文件目录）
weixin_34319111的博客
01-09 806
在使用WebClient类之前，必须先引用System.Net命名空间，文件下载、上传与删除的都是使用异步编程，也可以使用同步编程， 这里以异步编程为例： 1）文件下载： static void Main(string[] args) { //定义_webClient对象 WebClient _webC...
.Net 2.0对文件传输协议(FTP)操作(上传,下载,新建,删除,FTP间传送文件等)
dianzudi1839的博客
01-21 165
最近项目需要对FTP服务器进行操作,现把实现总结如下：打算分2篇总结:第1篇总结Ftp的一些常规的操作实现(例如：上传,下载,新建,删除,FTP间互传文件等操作)第2篇总结Ftp的操作的一些其他实现(例如：异步上传,异步下载等其他操作) Microsoft .NET Framework 2.0新增加了3个类使我们很方便的对文件传输协议(FTP)服务器进行操作FtpWebRequest类...
[转]Microsoft .NET Framework 2.0对文件传输协议(FTP)操作(上传,下载,新建,删除,FTP间传送文件等)实现...
aptl84294的博客
03-15 98
http://www.cnblogs.com/aierong/archive/2008/12/08/ftp.html 转载于:https://www.cnblogs.com/hxworm/articles/1984668.html
Microsoft .NET Framework 2.0对文件传输协议(FTP)操作(上传,下载,新建,删除,FTP间传送文件等)实现汇总1...
12-08 84
http://www.cnblogs.com/aierong/archive/2008/12/08/ftp.html 转载于:https://www.cnblogs.com/HeroBeast/archive/2008/12/08/1350292.html
FTP.rar_ftp_ftp .net_ftp文件传输_文件传输
09-22
在IT行业中，文件传输协议（FTP）是一种标准的网络协议，用于在计算机之间高效地传输文件。在.NET Framework 2.0中，C#程序员可以利用内置的System.Net命名空间中的FtpWebRequest和FtpWebResponse类来实现FTP操作。...
asp.net 2.0 高级编程(第4版)
06-23
FTP是一种标准网络协议，用于在客户端和服务器之间传输文件。在ASP.NET 2.0中，可以利用FTP协议将应用程序部署到远程服务器上，这对于需要频繁更新或维护的应用程序来说非常有用。 **部署步骤：** 使用FTP进行部署...
web、ftp服务器的搭建.docx
12-24
4. 新建一个网站文件，并将其上传到 Web 服务器。 5. 网站配置，打开默认文档，然后将 index.htm 上移至第一项。 6. 最后，测试 Web 服务器，打开网页，输入 IP 地址。 在搭建 Web 服务器时，需要注意以下几点： *...
推荐一个Star超过2K的.Net轻量级的CMS开源项目
成长的足迹
11-11 904
Piranha CMS是一个轻量级且跨平台的CMS库，专为.NET 8设计。该项目提供多种模板，具备CMS基本功能，也有空模板方便从头开始构建新网站，甚至可以作为移动应用的后端。是一个完全解耦的CMS，意味着我们可以使用任何技术以任何方式构建的应用程序。
.NET 9 - BinaryFormatter移除
最新发布
limingdinghao的博客
11-15 664
NET 9 SDK正式版已经发布, 下载地址是.NET9同时.NET Conf 2024 大会已经从2024-11-13开始了，感觉Aspire和AI的内容相对挺多的，主题分享演示时候打开的网站大部分都是Blazor制作的。这次.NET Conf 2024老师也再次说明了一下，note, BinaryFormatter 存在remote code execution的安全问题BinaryFormatter 从.NET8开始，已经被标记为Obsolete。
基于.NET 9实现实时进度条功能：前后端完整示例教程
滴水成河，汇流成海
11-12 345
要在基于.NET 9的应用中实现进度条功能，我们可以通过HttpContext.Response来发送实时的进度更新到前端。以下是一个简单的示例，展示了如何在ASP.NET Core应用中实现这一功能。
TCP/IP文件传输协议FTP详解
在实际应用中，FTP通常用于上传、下载大文件或批量文件操作，如网站内容的更新、软件的分发等。由于FTP的明文传输特性，现代网络环境中往往使用更安全的SFTP（SSH文件传输协议）或FTPS（FTP over SSL/TLS）来保护...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值