csharp: FTP Client Library using System.Net.FtpWebRequest

╰半橙微兮° 2021-12-13 00:57 124阅读 0赞

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Data;
    using System.Collections;
    using Microsoft.VisualBasic;
    using System.Net;
    using System.IO;
    using System.Text.RegularExpressions;
    using System.Windows.Forms;
    //https://www.codeproject.com/Articles/56321/A-Windows-FTP-Application
    //https://www.codeproject.com/Articles/4472/Enhanced-BrowseForFolder-styled-TreeView
    //https://github.com/ChrisRichner/TreeViewFolderBrowser
    //https://www.codeproject.com/Articles/11991/An-FTP-client-library-for-NET
    //https://github.com/aybe/Windows-API-Code-Pack-1.1
    //https://github.com/dbarros/WindowsAPICodePack
    
    namespace FTPLibrary
    {
        #region "FTP client class"
        /// <summary>
        /// A wrapper class for .NET 2.0 FTP
        /// </summary>
        /// <remarks>
        /// This class does not hold open an FTP connection but
        /// instead is stateless: for each FTP request it
        /// connects, performs the request and disconnects.
        /// </remarks>
        public class FTPclient
        {
            #region Delegated & Events
            //Download Progress Changed Event
            public delegate void DownloadProgressChangedHandler(object sender, DownloadProgressChangedArgs e);
            public event DownloadProgressChangedHandler OnDownloadProgressChanged;
    
            //Download Completed Event
            public delegate void DownloadCompletedHandler(object sender, DownloadCompletedArgs e);
            public event DownloadCompletedHandler OnDownloadCompleted;
    
            //New Server Message Event
            public delegate void NewMessageHandler(object sender, NewMessageEventArgs e);
            public event NewMessageHandler OnNewMessageReceived;
    
            //Upload Progress Changed Event
            //Download Progress Changed Event
            public delegate void UploadProgressChangedHandler(object sender, UploadProgressChangedArgs e);
            public event UploadProgressChangedHandler OnUploadProgressChanged;
    
            //Upload Completed Event
            public delegate void UploadCompletedHandler(object sender, UploadCompletedArgs e);
            public event UploadCompletedHandler OnUploadCompleted;
            #endregion
    
            #region "CONSTRUCTORS"
            /// <summary>
            /// Blank constructor
            /// </summary>
            /// <remarks>Hostname, username and password must be set manually</remarks>
            public FTPclient()
            {
            }
    
            /// <summary>
            /// Constructor just taking the hostname
            /// </summary>
            /// <param name="Hostname">in either ftp://ftp.host.com or ftp.host.com form</param>
            /// <remarks></remarks>
            public FTPclient(string Hostname)
            {
                _hostname = Hostname;
            }
    
            /// <summary>
            /// Constructor taking hostname, username and password
            /// </summary>
            /// <param name="Hostname">in either ftp://ftp.host.com or ftp.host.com form</param>
            /// <param name="Username">Leave blank to use 'anonymous' but set password to your email</param>
            /// <param name="Password"></param>
            /// <remarks></remarks>
            public FTPclient(string Hostname, string Username, string Password)
            {
                _hostname = Hostname;
                _username = Username;
                _password = Password;
            }
            #endregion
    
            #region "Directory functions"
            /// <summary>
            /// Return a simple directory listing
            /// </summary>
            /// <param name="directory">Directory to list, e.g. /pub</param>
            /// <returns>A list of filenames and directories as a List(of String)</returns>
            /// <remarks>For a detailed directory listing, use ListDirectoryDetail</remarks>
            public List<string> ListDirectory(string directory)
            {
                //return a simple list of filenames in directory
                System.Net.FtpWebRequest ftp = GetRequest(GetDirectory(directory));
                //Set request to do simple list
                ftp.Method = System.Net.WebRequestMethods.Ftp.ListDirectory;
                //Give Message of Command
                NewMessageEventArgs e = new NewMessageEventArgs("COMMAND", "List Directory", "NLST");
                OnNewMessageReceived(this, e);
    
                string str = GetStringResponse(ftp);
                //replace CRLF to CR, remove last instance
                str = str.Replace("\r\n", "\r").TrimEnd('\r');
                //split the string into a list
                List<string> result = new List<string>();
                result.AddRange(str.Split('\r'));
                return result;
            }
    
            /// <summary>
            /// Return a detailed directory listing
            /// </summary>
            /// <param name="directory">Directory to list, e.g. /pub/etc</param>
            /// <returns>An FTPDirectory object</returns>
            public FTPdirectory ListDirectoryDetail(string directory)
            {
                System.Net.FtpWebRequest ftp = GetRequest(GetDirectory(directory));
                //Set request to do simple list
                ftp.Method = System.Net.WebRequestMethods.Ftp.ListDirectoryDetails;
                ftp.UseBinary = true;
                //Give Message of Command
                NewMessageEventArgs e = new NewMessageEventArgs("COMMAND", "List Directory Details", "LIST");
                OnNewMessageReceived(this, e);
                string str = GetStringResponse(ftp);
                //replace CRLF to CR, remove last instance
                str = str.Replace("\r\n", "\r").TrimEnd('\r');
                //split the string into a list
                return new FTPdirectory(str, _lastDirectory);
            }
    
            #endregion
    
            #region "Upload: File transfer TO ftp server"
            /// <summary>
            /// Copy a local file to the FTP server
            /// </summary>
            /// <param name="localFilename">Full path of the local file</param>
            /// <param name="targetFilename">Target filename, if required</param>
            /// <returns></returns>
            /// <remarks>If the target filename is blank, the source filename is used
            /// (assumes current directory). Otherwise use a filename to specify a name
            /// or a full path and filename if required.</remarks>
            public bool Upload(string localFilename, string targetFilename)
            {
                //1. check source
                if (!File.Exists(localFilename))
                {
                    throw (new ApplicationException("File " + localFilename + " not found"));
                }
                //copy to FI
                FileInfo fi = new FileInfo(localFilename);
                return Upload(fi, targetFilename);
            }
    
            #region Upload Variables
            System.Net.FtpWebRequest UploadFTPRequest = null;
            FileStream UploadFileStream = null;
            Stream UploadStream = null;
            bool UploadCanceled = false;
            FileInfo UploadFileInfo = null;
            #endregion
    
            /// <summary>
            /// Upload a local file to the FTP server
            /// </summary>
            /// <param name="fi">Source file</param>
            /// <param name="targetFilename">Target filename (optional)</param>
            /// <returns></returns>
            public bool Upload(FileInfo fi, string targetFilename)
            {
                //copy the file specified to target file: target file can be full path or just filename (uses current dir)
    
                //1. check target
                string target;
                if (targetFilename.Trim() == "")
                {
                    //Blank target: use source filename & current dir
                    target = this.CurrentDirectory + fi.Name;
                }
                else if (targetFilename.Contains("/"))
                {
                    //If contains / treat as a full path
                    target = AdjustDir(targetFilename);
                }
                else
                {
                    //otherwise treat as filename only, use current directory
                    target = CurrentDirectory + targetFilename;
                }
    
                string URI = Hostname + target;
                //perform copy
                UploadFTPRequest = GetRequest(URI);
    
                //Set request to upload a file in binary
                UploadFTPRequest.Method = System.Net.WebRequestMethods.Ftp.UploadFile;
                UploadFTPRequest.UseBinary = true;
                //Notify FTP of the expected size
                UploadFTPRequest.ContentLength = fi.Length;
                UploadFileInfo = fi;
    
                //create byte array to store: ensure at least 1 byte!
                const int BufferSize = 2048;
                byte[] content = new byte[BufferSize - 1 + 1];
                int dataRead;
    
                //open file for reading
                using (UploadFileStream = fi.OpenRead())
                {
                    try
                    {
                        //open request to send
                        using (UploadStream = UploadFTPRequest.GetRequestStream())
                        {
                            //Give Message of Command
                            NewMessageEventArgs e = new NewMessageEventArgs("COMMAND", "Upload File", "STOR");
                            OnNewMessageReceived(this, e);
    
                            //Get File Size
                            Int64 TotalBytesUploaded = 0;
                            Int64 FileSize = fi.Length;
                            do
                            {
                                if (UploadCanceled)
                                {
                                    NewMessageEventArgs CancelMessage = new NewMessageEventArgs("RESPONSE", "Upload Canceled.", "CANCEL");
                                    OnNewMessageReceived(this, CancelMessage);
                                    UploadCanceled = false;
                                    return false;
                                }
    
                                dataRead = UploadFileStream.Read(content, 0, BufferSize);
                                UploadStream.Write(content, 0, dataRead);
                                TotalBytesUploaded += dataRead;
                                //Declare Event
                                UploadProgressChangedArgs DownloadProgress = new UploadProgressChangedArgs(TotalBytesUploaded, FileSize);
    
                                //Progress changed, Raise the event.
                                OnUploadProgressChanged(this, DownloadProgress);
    
                                System.Windows.Forms.Application.DoEvents();
                            } while (!(dataRead < BufferSize));
    
                            //Get Message and Raise Event
                            NewMessageEventArgs UPloadResponse = new NewMessageEventArgs("RESPONSE", "File Uploaded!", "STOR");
                            OnNewMessageReceived(this, UPloadResponse);
    
                            //Declare Event
                            UploadCompletedArgs Args = new UploadCompletedArgs("Successful", true);
                            //Raise Event
                            OnUploadCompleted(this, Args);
    
                            UploadStream.Close();
                        }
    
                    }
                    catch (Exception ex)
                    {
                        //Declare Event
                        UploadCompletedArgs Args = new UploadCompletedArgs("Error: " + ex.Message, false);
                        //Raise Event
                        OnUploadCompleted(this, Args);
                    }
                    finally
                    {
                        //ensure file closed
                        UploadFileStream.Close();
                    }
    
                }
    
    
                UploadFTPRequest = null;
                return true;
    
            }
    
            public void CancelUpload(string UploadFileName)
            {
                if (UploadFileStream != null)
                {
                    UploadFileStream.Close();
                    UploadFTPRequest.Abort();
                    //UploadFileInfo.Delete();
                    UploadCanceled = true;
                    UploadFTPRequest = null;
                    this.FtpDelete(UploadFileName);
                    MessageBox.Show("Upload Canceled");
                }
            }
            #endregion
    
            #region "Download: File transfer FROM ftp server"
            /// <summary>
            /// Copy a file from FTP server to local
            /// </summary>
            /// <param name="sourceFilename">Target filename, if required</param>
            /// <param name="localFilename">Full path of the local file</param>
            /// <returns></returns>
            /// <remarks>Target can be blank (use same filename), or just a filename
            /// (assumes current directory) or a full path and filename</remarks>
            public bool Download(string sourceFilename, string localFilename, bool PermitOverwrite)
            {
                //2. determine target file
                FileInfo fi = new FileInfo(localFilename);
                return this.Download(sourceFilename, fi, PermitOverwrite);
            }
    
            //Version taking an FtpFileInfo
            public bool Download(FTPfileInfo file, string localFilename, bool PermitOverwrite)
            {
                return this.Download(file.FullName, localFilename, PermitOverwrite);
            }
    
            //Another version taking FtpFileInfo and FileInfo
            public bool Download(FTPfileInfo file, FileInfo localFI, bool PermitOverwrite)
            {
                return this.Download(file.FullName, localFI, PermitOverwrite);
            }
    
            #region Download Variables
            System.Net.FtpWebRequest DownloadFTPRequest = null;
            FtpWebResponse DownloadResponse = null;
            Stream DownloadResponseStream = null;   //中文亂碼
            FileStream DownloadFileStream = null;
            FileInfo TargetFileInfo = null;
            bool DownloadCanceled = false;
            #endregion
            //Version taking string/FileInfo
            public bool Download(string sourceFilename, FileInfo targetFI, bool PermitOverwrite)
            {
                //1. check target
                if (targetFI.Exists && !(PermitOverwrite))
                {
                    throw (new ApplicationException("Target file already exists"));
                }
    
                //2. check source
                string target;
                if (sourceFilename.Trim() == "")
                {
                    throw (new ApplicationException("File not specified"));
                }
                else if (sourceFilename.Contains("/"))
                {
                    //treat as a full path
                    target = AdjustDir(sourceFilename);
                }
                else
                {
                    //treat as filename only, use current directory
                    target = CurrentDirectory + sourceFilename;
                }
    
                string URI = Hostname + target;
    
                //3. perform copy
                DownloadFTPRequest = GetRequest(URI);
    
                //Set request to download a file in binary mode
                DownloadFTPRequest.Method = System.Net.WebRequestMethods.Ftp.DownloadFile;
                DownloadFTPRequest.UseBinary = true;
                TargetFileInfo = targetFI;
                //open request and get response stream
                using (DownloadResponse = (FtpWebResponse)DownloadFTPRequest.GetResponse())
                {
                    using (DownloadResponseStream = DownloadResponse.GetResponseStream())
                    {
                        //System.Security.AccessControl.FileSecurity fileSecurity = new System.Security.AccessControl.FileSecurity(targetFI.FullName, System.Security.AccessControl.AccessControlSections.All);
                        //targetFI.SetAccessControl(fileSecurity);
                        //loop to read & write to file
                        using (DownloadFileStream = new FileStream(targetFI.FullName, FileMode.OpenOrCreate, FileAccess.ReadWrite))
                        {
                            try
                            {
                                //Give Message of Command
                                NewMessageEventArgs e = new NewMessageEventArgs("COMMAND", "Download File", "RETR");
                                OnNewMessageReceived(this, e);
                                byte[] buffer = new byte[2048];
                                int read = 0;
                                Int64 TotalBytesRead = 0;
                                Int64 FileSize = this.GetFileSize(sourceFilename);
                                DownloadCanceled = false;
                                do
                                {
                                    if (DownloadCanceled)
                                    {
                                        NewMessageEventArgs CancelMessage = new NewMessageEventArgs("RESPONSE", "Download Canceled.", "CANCEL");
    
                                        DownloadCanceled = false;
                                        OnNewMessageReceived(this, CancelMessage);
                                        return false;
                                    }
    
                                    read = DownloadResponseStream.Read(buffer, 0, buffer.Length);
                                    DownloadFileStream.Write(buffer, 0, read);
                                    TotalBytesRead += read;
                                    //Declare Event
                                    DownloadProgressChangedArgs DownloadProgress = new DownloadProgressChangedArgs(TotalBytesRead, FileSize);
    
                                    //Progress changed, Raise the event.
                                    OnDownloadProgressChanged(this, DownloadProgress);
    
                                    System.Windows.Forms.Application.DoEvents();
    
                                } while (!(read == 0));
    
    
                                //Get Message and Raise Event
                                NewMessageEventArgs NewMessageArgs = new NewMessageEventArgs("RESPONSE", DownloadResponse.StatusDescription, DownloadResponse.StatusCode.ToString());
                                OnNewMessageReceived(this, NewMessageArgs);
    
                                //Declare Event
                                DownloadCompletedArgs Args = new DownloadCompletedArgs("Successful", true);
                                //Raise Event
                                OnDownloadCompleted(this, Args);
    
                                DownloadResponseStream.Close();
                                DownloadFileStream.Flush();
                                DownloadFileStream.Close();
                                DownloadFileStream = null;
                                DownloadResponseStream = null;
                            }
                            catch (Exception ex)
                            {
                                //catch error and delete file only partially downloaded
                                DownloadFileStream.Close();
                                //delete target file as it's incomplete
                                targetFI.Delete();
    
                                //Decalre Event for Error
                                DownloadCompletedArgs DownloadCompleted = new DownloadCompletedArgs("Error: " + ex.Message, false);
                                //Raise Event
                                OnDownloadCompleted(this, DownloadCompleted);
                            }
                        }
                        if (DownloadFileStream != null)
                            DownloadResponseStream.Close();
                    }
                    if (DownloadFileStream != null)
                        DownloadResponse.Close();
                }
                return true;
            }
    
            public void CancelDownload()
            {
                if (DownloadFileStream != null)
                {
                    DownloadFileStream.Close();
    
                    DownloadFTPRequest.Abort();
    
                    DownloadResponse.Close();
                    DownloadResponseStream.Close();
                    //DownloadFileStream = null;
                    //DownloadResponseStream = null;
                    TargetFileInfo.Delete();
                    DownloadCanceled = true;
                    MessageBox.Show("Download Canceled");
                }
            }
            #endregion
    
            #region "Other functions: Delete rename etc."
            /// <summary>
            /// Delete remote file
            /// </summary>
            /// <param name="filename">filename or full path</param>
            /// <returns></returns>
            /// <remarks></remarks>
            public bool FtpDelete(string filename)
            {
                //Determine if file or full path
                string URI = this.Hostname + GetFullPath(filename);
    
                System.Net.FtpWebRequest ftp = GetRequest(URI);
                //Set request to delete
                ftp.Method = System.Net.WebRequestMethods.Ftp.DeleteFile;
                try
                {
                    //get response but ignore it
                    string str = GetStringResponse(ftp);
                    //Give Message of Command
                    NewMessageEventArgs e = new NewMessageEventArgs("COMMAND", "Delete File", "DELE");
                    OnNewMessageReceived(this, e);
                }
                catch (Exception)
                {
                    return false;
                }
                return true;
            }
    
            /// <summary>
            /// Determine if file exists on remote FTP site
            /// </summary>
            /// <param name="filename">Filename (for current dir) or full path</param>
            /// <returns></returns>
            /// <remarks>Note this only works for files</remarks>
            public bool FtpFileExists(string filename)
            {
                //Try to obtain filesize: if we get error msg containing "550"
                //the file does not exist
                try
                {
                    long size = GetFileSize(filename);
                    return true;
    
                }
                catch (Exception ex)
                {
                    //only handle expected not-found exception
                    if (ex is System.Net.WebException)
                    {
                        //file does not exist/no rights error = 550
                        if (ex.Message.Contains("550"))
                        {
                            //clear
                            return false;
                        }
                        else
                        {
                            System.Windows.Forms.MessageBox.Show(ex.Message);
                            return false;
                        }
                    }
                    else
                    {
                        System.Windows.Forms.MessageBox.Show(ex.Message);
                        return false;
                    }
                }
            }
    
            /// <summary>
            /// Determine size of remote file
            /// </summary>
            /// <param name="filename"></param>
            /// <returns></returns>
            /// <remarks>Throws an exception if file does not exist</remarks>
            public long GetFileSize(string filename)
            {
                string path;
                if (filename.Contains("/"))
                {
                    path = AdjustDir(filename);
                }
                else
                {
                    path = this.CurrentDirectory + filename;
                }
                string URI = this.Hostname + path;
                System.Net.FtpWebRequest ftp = GetRequest(URI);
                //Try to get info on file/dir?
                ftp.Method = System.Net.WebRequestMethods.Ftp.GetFileSize;
                string tmp = this.GetStringResponse(ftp);
                //Give Message of Command
                NewMessageEventArgs e = new NewMessageEventArgs("COMMAND", "Get File Size", "SIZE");
                OnNewMessageReceived(this, e);
                return GetSize(ftp);
            }
    
            public bool FtpRename(string sourceFilename, string newName)
            {
                //Does file exist?
                string source = GetFullPath(sourceFilename);
                if (!FtpFileExists(source))
                {
                    throw (new FileNotFoundException("File " + source + " not found"));
                }
    
                //build target name, ensure it does not exist
                string target = GetFullPath(newName);
                if (target == source)
                {
                    throw (new ApplicationException("Source and target are the same"));
                }
                else if (FtpFileExists(target))
                {
                    throw (new ApplicationException("Target file " + target + " already exists"));
                }
    
                //perform rename
                string URI = this.Hostname + source;
    
                System.Net.FtpWebRequest ftp = GetRequest(URI);
                //Set request to delete
                ftp.Method = System.Net.WebRequestMethods.Ftp.Rename;
                ftp.RenameTo = target;
                ftp.UseBinary = true;
    
                try
                {
                    //get response but ignore it
                    string str = GetStringResponse(ftp);
                    //Give Message of Command
                    NewMessageEventArgs e = new NewMessageEventArgs("COMMAND", "File Rename", "RENAME");
                    OnNewMessageReceived(this, e);
                }
                catch (Exception)
                {
                    return false;
                }
                return true;
            }
    
            public bool FtpCreateDirectory(string dirpath)
            {
                //perform create
                string URI = this.Hostname + AdjustDir(dirpath);
                System.Net.FtpWebRequest ftp = GetRequest(URI);
                //Set request to MkDir
                ftp.Method = System.Net.WebRequestMethods.Ftp.MakeDirectory;
                try
                {
                    //get response but ignore it
                    string str = GetStringResponse(ftp);
                    //Give Message of Command
                    NewMessageEventArgs e = new NewMessageEventArgs("COMMAND", "Make Directory", "MKD");
                    OnNewMessageReceived(this, e);
                }
                catch (Exception)
                {
                    return false;
                }
                return true;
            }
    
            public bool FtpDeleteDirectory(string dirpath)
            {
                //perform remove
                string URI = this.Hostname + AdjustDir(dirpath);
                System.Net.FtpWebRequest ftp = GetRequest(URI);
                ftp.UseBinary = true;
                //Set request to RmDir
                ftp.Method = System.Net.WebRequestMethods.Ftp.RemoveDirectory;
                try
                {
                    //get response but ignore it
                    string str = GetStringResponse(ftp);
                    //Give Message of Command
                    NewMessageEventArgs e = new NewMessageEventArgs("COMMAND", "Remove Directory", "RMD");
                    OnNewMessageReceived(this, e);
                }
                catch (Exception)
                {
                    return false;
                }
                return true;
            }
            #endregion
    
            #region "private supporting fns"
            //Get the basic FtpWebRequest object with the
            //common settings and security
            private FtpWebRequest GetRequest(string URI)
            {
                //create request
                FtpWebRequest result = (FtpWebRequest)FtpWebRequest.Create(URI);
                //Set the login details
                result.Credentials = GetCredentials();
                //Do not keep alive (stateless mode)
                result.KeepAlive = false;
                result.UseBinary = true;
                return result;
            }
    
    
            /// <summary>
            /// Get the credentials from username/password
            /// </summary>
            private System.Net.ICredentials GetCredentials()
            {
                return new System.Net.NetworkCredential(Username, Password);
            }
    
            /// <summary>
            /// returns a full path using CurrentDirectory for a relative file reference
            /// </summary>
            private string GetFullPath(string file)
            {
                if (file.Contains("/"))
                {
                    return AdjustDir(file);
                }
                else
                {
                    return this.CurrentDirectory + file;
                }
            }
    
            /// <summary>
            /// Amend an FTP path so that it always starts with /
            /// </summary>
            /// <param name="path">Path to adjust</param>
            /// <returns></returns>
            /// <remarks></remarks>
            private string AdjustDir(string path)
            {
                return ((path.StartsWith("/")) ? "" : "/").ToString() + path;
            }
    
            private string GetDirectory(string directory)
            {
                string URI;
                if (directory == "")
                {
                    //build from current
                    URI = Hostname + this.CurrentDirectory;
                    _lastDirectory = this.CurrentDirectory;
                }
                else
                {
                    if (!directory.StartsWith("/"))
                    {
                        throw (new ApplicationException("Directory should start with /"));
                    }
                    URI = this.Hostname + directory;
                    _lastDirectory = directory;
                }
                return URI;
            }
    
            //stores last retrieved/set directory
            private string _lastDirectory = "";
    
            /// <summary>
            /// Obtains a response stream as a string
            /// </summary>
            /// <param name="ftp">current FTP request</param>
            /// <returns>String containing response</returns>
            /// <remarks>FTP servers typically return strings with CR and
            /// not CRLF. Use respons.Replace(vbCR, vbCRLF) to convert
            /// to an MSDOS string</remarks>
            private string GetStringResponse(FtpWebRequest ftp)
            {
                //Get the result, streaming to a string
                string result = "";
                using (FtpWebResponse response = (FtpWebResponse)ftp.GetResponse())
                {
                    long size = response.ContentLength;
                    using (Stream datastream = response.GetResponseStream())
                    {
                        // 一中文亂碼問題 涂聚文 20180801
                        using (StreamReader sr = new StreamReader(datastream, System.Text.Encoding.GetEncoding("GB2312"))) 
                        {
                            _WelcomeMessage = response.WelcomeMessage;
                            _ExitMessage = response.ExitMessage;
                            result = sr.ReadToEnd();
                            sr.Close();
                        }
                        try
                        {
                            //Declare Event
                            NewMessageEventArgs e = new NewMessageEventArgs("RESPONSE", response.StatusDescription, response.StatusCode.ToString());
                            //Raise Event
                            OnNewMessageReceived(this, e);
                        }
                        catch
                        {
    
                        }
    
                        datastream.Close();
                    }
                    response.Close();
                }
                return result;
            }
    
            /// <summary>
            /// Gets the size of an FTP request
            /// </summary>
            /// <param name="ftp"></param>
            /// <returns></returns>
            /// <remarks></remarks>
            private long GetSize(FtpWebRequest ftp)
            {
                long size;
                using (FtpWebResponse response = (FtpWebResponse)ftp.GetResponse())
                {
                    size = response.ContentLength;
                    response.Close();
                }
    
                return size;
            }
            #endregion
    
            #region "Properties"
            private string _hostname;
            /// <summary>
            /// Hostname
            /// </summary>
            /// <value></value>
            /// <remarks>Hostname can be in either the full URL format
            /// ftp://ftp.myhost.com or just ftp.myhost.com
            /// </remarks>
            public string Hostname
            {
                get
                {
                    if (_hostname.StartsWith("ftp://"))
                    {
                        return _hostname;
                    }
                    else
                    {
                        return "ftp://" + _hostname;
                    }
                }
                set
                {
                    _hostname = value;
                }
            }
            private string _username;
            /// <summary>
            /// Username property
            /// </summary>
            /// <value></value>
            /// <remarks>Can be left blank, in which case 'anonymous' is returned</remarks>
            public string Username
            {
                get
                {
                    return (_username == "" ? "anonymous" : _username);
                }
                set
                {
                    _username = value;
                }
            }
            private string _password;
            public string Password
            {
                get
                {
                    return _password;
                }
                set
                {
                    _password = value;
                }
            }
    
            /// <summary>
            /// The CurrentDirectory value
            /// </summary>
            /// <remarks>Defaults to the root '/'</remarks>
            private string _currentDirectory = "/";
            public string CurrentDirectory
            {
                get
                {
                    //return directory, ensure it ends with /
                    return _currentDirectory + ((_currentDirectory.EndsWith("/")) ? "" : "/").ToString();
                }
                set
                {
                    if (!value.StartsWith("/"))
                    {
                        throw (new ApplicationException("Directory should start with /"));
                    }
                    _currentDirectory = value;
                }
            }
    
    
            #endregion
    
            #region Server Messages
            string _WelcomeMessage, _ExitMessage;
            public string WelcomeMessage
            {
                get
                {
                    return _WelcomeMessage;
                }
                set
                {
                    _WelcomeMessage = value;
                }
            }
            public string ExitMessage
            {
                get
                {
                    return _ExitMessage;
                }
                set
                {
                    _ExitMessage = value;
                }
            }
            #endregion
    
        }
        #endregion
    
        #region "FTP file info class"
        /// <summary>
        /// Represents a file or directory entry from an FTP listing
        /// </summary>
        /// <remarks>
        /// This class is used to parse the results from a detailed
        /// directory list from FTP. It supports most formats of
        /// </remarks>
        public class FTPfileInfo
        {
    
            //Stores extended info about FTP file
    
            #region "Properties"
            public string FullName
            {
                get
                {
                    return Path + Filename;
                }
            }
            public string Filename
            {
                get
                {
                    return _filename;
                }
            }
            public string Path
            {
                get
                {
                    return _path;
                }
            }
            public DirectoryEntryTypes FileType
            {
                get
                {
                    return _fileType;
                }
            }
            public long Size
            {
                get
                {
                    return _size;
                }
            }
            public DateTime FileDateTime
            {
                get
                {
                    return _fileDateTime;
                }
            }
            public string Permission
            {
                get
                {
                    return _permission;
                }
            }
            public string Extension
            {
                get
                {
                    int i = this.Filename.LastIndexOf(".");
                    if (i >= 0 && i < (this.Filename.Length - 1))
                    {
                        return this.Filename.Substring(i + 1);
                    }
                    else
                    {
                        return "";
                    }
                }
            }
            public string NameOnly
            {
                get
                {
                    int i = this.Filename.LastIndexOf(".");
                    if (i > 0)
                    {
                        return this.Filename.Substring(0, i);
                    }
                    else
                    {
                        return this.Filename;
                    }
                }
            }
            private string _filename;
            private string _path;
            private DirectoryEntryTypes _fileType;
            private long _size;
            private DateTime _fileDateTime;
            private string _permission;
    
            #endregion
    
            /// <summary>
            /// Identifies entry as either File or Directory
            /// </summary>
            public enum DirectoryEntryTypes
            {
                File,
                Directory
            }
    
            /// <summary>
            /// Constructor taking a directory listing line and path
            /// </summary>
            /// <param name="line">The line returned from the detailed directory list</param>
            /// <param name="path">Path of the directory</param>
            /// <remarks></remarks>
            public FTPfileInfo(string line, string path)
            {
                //parse line
                Match m = GetMatchingRegex(line);
                if (m == null)
                {
                    //failed
                    throw (new ApplicationException("Unable to parse line: " + line));
                }
                else
                {
                    _filename = m.Groups["name"].Value;
                    _path = path;
    
                    Int64.TryParse(m.Groups["size"].Value, out _size);
                    //_size = System.Convert.ToInt32(m.Groups["size"].Value);
    
                    _permission = m.Groups["permission"].Value;
                    string _dir = m.Groups["dir"].Value;
                    if (_dir != "" && _dir != "-")
                    {
                        _fileType = DirectoryEntryTypes.Directory;
                    }
                    else
                    {
                        _fileType = DirectoryEntryTypes.File;
                    }
    
                    try
                    {
                        _fileDateTime = DateTime.Parse(m.Groups["timestamp"].Value);
                    }
                    catch (Exception)
                    {
                        _fileDateTime = Convert.ToDateTime(null);
                    }
    
                }
            }
    
            private Match GetMatchingRegex(string line)
            {
                Regex rx;
                Match m;
                for (int i = 0; i <= _ParseFormats.Length - 1; i++)
                {
                    rx = new Regex(_ParseFormats[i]);
                    m = rx.Match(line);
                    if (m.Success)
                    {
                        return m;
                    }
                }
                return null;
            }
    
            #region "Regular expressions for parsing LIST results"
            /// <summary>
            /// List of REGEX formats for different FTP server listing formats
            /// </summary>
            /// <remarks>
            /// The first three are various UNIX/LINUX formats, fourth is for MS FTP
            /// in detailed mode and the last for MS FTP in 'DOS' mode.
            /// I wish VB.NET had support for Const arrays like C# but there you go
            /// </remarks>
            private static string[] _ParseFormats = new string[] { 
                "(?<dir>[\\-d])(?<permission>([\\-r][\\-w][\\-xs]){3})\\s+\\d+\\s+\\w+\\s+\\w+\\s+(?<size>\\d+)\\s+(?<timestamp>\\w+\\s+\\d+\\s+\\d{4})\\s+(?<name>.+)", 
                "(?<dir>[\\-d])(?<permission>([\\-r][\\-w][\\-xs]){3})\\s+\\d+\\s+\\d+\\s+(?<size>\\d+)\\s+(?<timestamp>\\w+\\s+\\d+\\s+\\d{4})\\s+(?<name>.+)", 
                "(?<dir>[\\-d])(?<permission>([\\-r][\\-w][\\-xs]){3})\\s+\\d+\\s+\\d+\\s+(?<size>\\d+)\\s+(?<timestamp>\\w+\\s+\\d+\\s+\\d{1,2}:\\d{2})\\s+(?<name>.+)", 
                "(?<dir>[\\-d])(?<permission>([\\-r][\\-w][\\-xs]){3})\\s+\\d+\\s+\\w+\\s+\\w+\\s+(?<size>\\d+)\\s+(?<timestamp>\\w+\\s+\\d+\\s+\\d{1,2}:\\d{2})\\s+(?<name>.+)", 
                "(?<dir>[\\-d])(?<permission>([\\-r][\\-w][\\-xs]){3})(\\s+)(?<size>(\\d+))(\\s+)(?<ctbit>(\\w+\\s\\w+))(\\s+)(?<size2>(\\d+))\\s+(?<timestamp>\\w+\\s+\\d+\\s+\\d{2}:\\d{2})\\s+(?<name>.+)", 
                "(?<timestamp>\\d{2}\\-\\d{2}\\-\\d{2}\\s+\\d{2}:\\d{2}[Aa|Pp][mM])\\s+(?<dir>\\<\\w+\\>){0,1}(?<size>\\d+){0,1}\\s+(?<name>.+)" };
            #endregion
        }
        #endregion
    
        #region "FTP Directory class"
        /// <summary>
        /// Stores a list of files and directories from an FTP result
        /// </summary>
        /// <remarks></remarks>
        public class FTPdirectory : List<FTPfileInfo>
        {
    
    
            public FTPdirectory()
            {
                //creates a blank directory listing
            }
    
            /// <summary>
            /// Constructor: create list from a (detailed) directory string
            /// </summary>
            /// <param name="dir">directory listing string</param>
            /// <param name="path"></param>
            /// <remarks></remarks>
            public FTPdirectory(string dir, string path)
            {
                foreach (string line in dir.Replace("\n", "").Split(System.Convert.ToChar('\r')))
                {
                    //parse
                    if (line != "")
                    {
                        this.Add(new FTPfileInfo(line, path));
                    }
                }
            }
    
            /// <summary>
            /// Filter out only files from directory listing
            /// </summary>
            /// <param name="ext">optional file extension filter</param>
            /// <returns>FTPdirectory listing</returns>
            public FTPdirectory GetFiles(string ext)
            {
                return this.GetFileOrDir(FTPfileInfo.DirectoryEntryTypes.File, ext);
            }
    
            /// <summary>
            /// Returns a list of only subdirectories
            /// </summary>
            /// <returns>FTPDirectory list</returns>
            /// <remarks></remarks>
            public FTPdirectory GetDirectories()
            {
                return this.GetFileOrDir(FTPfileInfo.DirectoryEntryTypes.Directory, "");
            }
    
            //internal: share use function for GetDirectories/Files
            private FTPdirectory GetFileOrDir(FTPfileInfo.DirectoryEntryTypes type, string ext)
            {
                FTPdirectory result = new FTPdirectory();
                foreach (FTPfileInfo fi in this)
                {
                    if (fi.FileType == type)
                    {
                        if (ext == "")
                        {
                            result.Add(fi);
                        }
                        else if (ext == fi.Extension)
                        {
                            result.Add(fi);
                        }
                    }
                }
                return result;
    
            }
    
            public bool FileExists(string filename)
            {
                foreach (FTPfileInfo ftpfile in this)
                {
                    if (ftpfile.Filename == filename)
                    {
                        return true;
                    }
                }
                return false;
            }
    
            private const char slash = '/';
    
            public static string GetParentDirectory(string dir)
            {
                string tmp = dir.TrimEnd(slash);
                int i = tmp.LastIndexOf(slash);
                if (i > 0)
                {
                    return tmp.Substring(0, i - 1);
                }
                else
                {
                    throw (new ApplicationException("No parent for root"));
                }
            }
        }
        #endregion
    
        #region Events
        public class DownloadProgressChangedArgs : EventArgs
        {
            //Private Members
            private Int64 _BytesDownload;
            private Int64 _TotalBytes;
    
            //Constructor
            public DownloadProgressChangedArgs(Int64 BytesDownload, Int64 TotleBytes)
            {
                this._BytesDownload = BytesDownload;
                this._TotalBytes = TotleBytes;
            }
    
            //Public Members
            public Int64 BytesDownloaded { get { return _BytesDownload; } }
            public Int64 TotleBytes { get { return _TotalBytes; } }
        }
    
        public class DownloadCompletedArgs : EventArgs
        {
            //Private Members
            private bool _DownloadedCompleted;
            private string _DownloadStatus;
    
            //Constructor
            public DownloadCompletedArgs(string Status, bool Completed)
            {
                this._DownloadedCompleted = Completed;
                this._DownloadStatus = Status;
            }
    
            //Public Members
            public String DownloadStatus { get { return _DownloadStatus; } }
            public bool DownloadCompleted { get { return _DownloadedCompleted; } }
        }
    
        public class NewMessageEventArgs : EventArgs
        {
            //Private Members
            private string _Message;
            private string _StatusCode;
            private string _Type;
    
            //Constructor
            public NewMessageEventArgs(string Type, string Status, string Code)
            {
                this._Message = Status;
                this._StatusCode = Code;
                this._Type = Type;
            }
    
            //Public Members
            public string StatusMessage { get { return _Message; } }
            public string StatusCode { get { return _StatusCode; } }
            public string StatusType { get { return _Type; } }
        }
    
        public class UploadProgressChangedArgs : EventArgs
        {
            //Private Members
            private Int64 _BytesUpload;
            private Int64 _TotalBytes;
    
            //Constructor
            public UploadProgressChangedArgs(Int64 BytesUpload, Int64 TotleBytes)
            {
                this._BytesUpload = BytesUpload;
                this._TotalBytes = TotleBytes;
            }
    
            //Public Members
            public Int64 BytesUploaded { get { return _BytesUpload; } }
            public Int64 TotleBytes { get { return _TotalBytes; } }
        }
    
        public class UploadCompletedArgs : EventArgs
        {
            //Private Members
            private bool _UploadCompleted;
            private string _UploadStatus;
    
            //Constructor
            public UploadCompletedArgs(string Status, bool Completed)
            {
                this._UploadCompleted = Completed;
                this._UploadStatus = Status;
            }
    
            //Public Members
            public String UploadStatus { get { return _UploadStatus; } }
            public bool UploadCompleted { get { return _UploadCompleted; } }
        }
        #endregion
    }

测试代码：

using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Linq;
    using System.Text;
    using System.Windows.Forms;
    using System.Net;
    using FTPLibrary;
    using System.Diagnostics;
    using System.Reflection;
    using System.IO;
    
    
    namespace ftpdemo
    {
    
        /// <summary>
        /// 涂聚文 2017-08-01
        /// </summary>
        public partial class Form6 : Form
        {
            public FTPclient FtpClient;
            ListViewItem Message;
            string remotingFolder = System.Configuration.ConfigurationManager.AppSettings["remotingFolder"];  //远程ftp文件目录
            string localFolder = System.Configuration.ConfigurationManager.AppSettings["localFolder"];  //要下载到的本地目录
            string ftpServer = System.Configuration.ConfigurationManager.AppSettings["ftpServer"];  //ftp服务器
            string user = System.Configuration.ConfigurationManager.AppSettings["user"];  //用户名
            string pwd = System.Configuration.ConfigurationManager.AppSettings["pwd"];  //密码
            string port = System.Configuration.ConfigurationManager.AppSettings["port"];  //端口
    
            /// <summary>
            /// 
            /// </summary>
            /// <param name="byteCount"></param>
            /// <returns></returns>
            private string GetFileSize(double byteCount)
            {
                string size = "0 Bytes";
                if (byteCount >= 1073741824.0)
                    size = String.Format("{0:##.##}", byteCount / 1073741824.0) + " GB";
                else if (byteCount >= 1048576.0)
                    size = String.Format("{0:##.##}", byteCount / 1048576.0) + " MB";
                else if (byteCount >= 1024.0)
                    size = String.Format("{0:##.##}", byteCount / 1024.0) + " KB";
                else if (byteCount > 0 && byteCount < 1024.0)
                    size = byteCount.ToString() + " Bytes";
    
                return size;
            }
            /// <summary>
            /// Sets up the FTPClient for this Form.  Called from frmLogin.
            /// </summary>
            /// <param name="client">FTPclient on frmLogin is used to refrence the FtpClient here.</param>
            public void SetFtpClient(FTPclient client)
            {
                //Set FtpClient
                FtpClient = client;
    
                //Display the Welcome Message
                Message = new ListViewItem();
                Message.Text = DateTime.Now.ToLongTimeString() + " " + DateTime.Now.ToLongDateString();
                Message.SubItems.Add("Welcome Message");
                Message.SubItems.Add(FtpClient.WelcomeMessage);
                Message.SubItems.Add("No Code");
                Message.SubItems.Add("/");
                lstMessages.Items.Add(Message);
    
                //Setup OnMessageReceived Event
                FtpClient.OnNewMessageReceived += new FTPclient.NewMessageHandler(FtpClient_OnNewMessageReceived);
    
                //Open and Display Root Directory and Files/Folders in it
                foreach (FTPfileInfo folder in FtpClient.ListDirectoryDetail("/"))
                {
                    ListViewItem item = new ListViewItem();
                    item.Text = folder.Filename;
                    if (folder.FileType == FTPfileInfo.DirectoryEntryTypes.Directory)
                        item.SubItems.Add("Folder");
                    else
                        item.SubItems.Add("File");
    
                    item.SubItems.Add(folder.FullName);
                    item.SubItems.Add(folder.Permission);
                    item.SubItems.Add(folder.FileDateTime.ToShortTimeString() + folder.FileDateTime.ToShortDateString());
                    item.SubItems.Add(GetFileSize(folder.Size));
                    lstRemoteSiteFiles.Items.Add(item);
                }
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="myObject"></param>
            /// <param name="e"></param>
            private void FtpClient_OnNewMessageReceived(object myObject, NewMessageEventArgs e)
            {
                //Display Meesage in lstMessages
                Message = new ListViewItem();
                Message.Text = DateTime.Now.ToLongTimeString() + " " + DateTime.Now.ToLongDateString();
                Message.SubItems.Add(e.StatusType);
                Message.SubItems.Add(e.StatusMessage);
                Message.SubItems.Add(e.StatusCode);
                Message.SubItems.Add(txtRemoteDirectory.Text);
                lstMessages.Items.Add(Message);
    
                this.lstMessages.EnsureVisible(this.lstMessages.Items.Count - 1);
            }
            /// <summary>
            /// Reload all Directories and Files in Current Directory
            /// </summary>
            private void RefreshDirectory()
            {
                //Clear all items
                lstRemoteSiteFiles.Items.Clear();
    
                //Open and Display Root Directory
                foreach (FTPfileInfo folder in FtpClient.ListDirectoryDetail(txtRemoteDirectory.Text))
                {
                    ListViewItem item = new ListViewItem();
                    item.Text = folder.Filename;
                    if (folder.FileType == FTPfileInfo.DirectoryEntryTypes.Directory)
                        item.SubItems.Add("Folder");
                    else
                        item.SubItems.Add("File");
    
                    item.SubItems.Add(folder.FullName);
                    item.SubItems.Add(folder.Permission);
                    item.SubItems.Add(folder.FileDateTime.ToShortTimeString() + folder.FileDateTime.ToShortDateString());
                    item.SubItems.Add(folder.Size.ToString());
                    lstRemoteSiteFiles.Items.Add(item);
                }
            }
            /// <summary>
            /// 
            /// </summary>
            public Form6()
            {
                InitializeComponent();
    
                //Set Selected Directory
                txtRemoteDirectory.Text = "/";
                lstRemoteSiteFiles.FullRowSelect = true;  
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="sender"></param>
            /// <param name="e"></param>
            private void Form6_Load(object sender, EventArgs e)
            {
                //Set FTP
                FTPclient objFtp = new FTPclient(ftpServer, user,pwd);
                objFtp.CurrentDirectory = "/";
                SetFtpClient(objFtp);
    
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="sender"></param>
            /// <param name="e"></param>
            private void lstRemoteSiteFiles_SelectedIndexChanged(object sender, EventArgs e)
            {
    
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="sender"></param>
            /// <param name="e"></param>
            private void lstRemoteSiteFiles_MouseDoubleClick(object sender, MouseEventArgs e)
            {
                if (lstRemoteSiteFiles.Items.Count != 0)
                {
                    try
                    {
                        if (lstRemoteSiteFiles.SelectedItems[0].SubItems[1].Text == "File")
                        {
                            //Enable the buttons that are related to the FILE
                           // btnRename.Enabled = true;
                           // btnDownload.Enabled = true;
                            //Set Current Directory for Download
                            FtpClient.CurrentDirectory = txtRemoteDirectory.Text;
                            //Its a File, so Ask them if they want to Save it...
                            if (MessageBox.Show("Do you want to save this file: " + txtRemoteDirectory.Text + lstRemoteSiteFiles.SelectedItems[0].Text + "/" + "?", "Download File?", MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button1) == DialogResult.Yes)
                            {
                                //Save the File to location
                                //downloadToolStripMenuItem_Click(this, e);
                            }
                        }
                        else if (lstRemoteSiteFiles.SelectedItems[0].SubItems[1].Text == "Folder") // Its a Directory
                        {
                            //Set Directory to txtRemoteDirectory.Text + selectedItem + "/"
                            //Result - /SelectedDirecotory/  -- good for navigation, keeping user informed and code :)
                            txtRemoteDirectory.Text += lstRemoteSiteFiles.SelectedItems[0].Text + "/";
                            lstRemoteSiteFiles.Items.Clear();
    
                            //Set Current Dir
                            FtpClient.CurrentDirectory = txtRemoteDirectory.Text;
    
                            //Get Files and Folders from Selected Direcotry
                            foreach (FTPfileInfo folder in FtpClient.ListDirectoryDetail(txtRemoteDirectory.Text))
                            {
                                ListViewItem item = new ListViewItem();
                                item.Text = folder.Filename;
                                if (folder.FileType == FTPfileInfo.DirectoryEntryTypes.Directory)
                                    item.SubItems.Add("Folder");
                                else
                                    item.SubItems.Add("File");
    
                                item.SubItems.Add(folder.FullName);
                                item.SubItems.Add(folder.Permission);
                                item.SubItems.Add(folder.FileDateTime.ToShortDateString()+" "+folder.FileDateTime.ToShortTimeString());
                                item.SubItems.Add(GetFileSize(folder.Size));
                                lstRemoteSiteFiles.Items.Add(item);
                            }
                        }
                    }
                    catch { }
                }
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="sender"></param>
            /// <param name="e"></param>
            private void lstRemoteSiteFiles_ItemDrag(object sender, ItemDragEventArgs e)
            {
    
            }
        }
    }

转载于:https://www.cnblogs.com/geovindu/p/7274715.html