关于ftp的功能类——下载，上传，断点，连接

看到园子里有几篇关于c#连接ftp的文章，刚好最近刚刚完成对于这个的书写，就发出来给大家分享分享下。不会排版，第一次发，就直接贴代码了

using System;
using System.Collections.Generic;
using System.Text;
using System.Configuration;
using System.Net;
using System.IO;

namespace MirroringDownClass
{
    public class EasyononFtp
    {
        public  delegate void delegt(string s);
        public static event delegt onprogressBar;
        #region 成员
        
       
        private static string ftpServer ;  //ftp服务器地址
        private static string user;  //用户名
        private static string pwd;  //密码
        #endregion

        FtpWebRequest reqFTP;
        FtpWebResponse ftpResponse;
        #region 构造函数
        
        public EasyononFtp()
        {
        }
        public EasyononFtp(string ftpUri, string username, string password)
        {
            ftpServer = ftpUri;
            user = username;
            pwd = password;
        }

        #endregion
        #region FTP连接
        
        /// <summary>
        /// Ftp的连接
        /// </summary>
        /// <param name="url">ftp的地址</param>
        /// <returns>bool</returns>
        public  bool ftpconn()
        {
            try
            {
                reqFTP = getFTPwbRequest(ftpServer, WebRequestMethods.Ftp.ListDirectoryDetails);
                ftpResponse = (FtpWebResponse)reqFTP.GetResponse();
                return true;
            }
            catch (Exception ex)
            {
                Common.debugPrint(ex.Message.ToString());
            }
            finally
            {
                if (ftpResponse != null)
                {
                    ftpResponse.Close();
                }
            }
            return false;
        }
        #endregion
        #region 下载FTP文件函数
       /// <summary>
        /// 下载
       /// </summary>
       /// <param name="desfilePath">本地文件目录</param>
       /// <param name="ftpfilePath">FTP服务器文件目录</param>
       /// <param name="fileName">带相对路径的文件名</param>
       /// <returns></returns>
        public bool ftpGetFile(string desfilePath, string ftpfilePath, string fileName)
        {
            string Relative_path = fileName.Replace("\\", "/");
            string filenamepath = ftpfilePath + "/" + Relative_path;
            try
            {
                if (ftpconn())
                {
                    Common.debugPrint(filenamepath + "下载中");
                    reqFTP = getFTPwbRequest(filenamepath, WebRequestMethods.Ftp.DownloadFile);
                    FtpWebResponse response = (FtpWebResponse)reqFTP.GetResponse();
                    Stream ftpStream = response.GetResponseStream();//FTP数据流
                    if (outputStream(desfilePath + "\\" + fileName, ftpStream))//字符流处理方法
                    {
                        ftpStream.Close();
                        response.Close();
                        Common.debugPrint(filenamepath + "下载完成！！！");
                        return true;
                    }
                    else
                        return false;
                }
                else
                {
                    Common.debugPrint("ftpconn()连接失败");
                    return false;
                }
            }
            catch (Exception ex)
            {
                Common.debugPrint(ex.Message.ToString() + "查看ftpGetFile函数");
                return false;
            }
        }
        #endregion
        #region 重写FTP下载函数
      /// <summary>
        /// 重写下载方法
      /// </summary>
      /// <param name="localFile">本地文件全路径</param>
      /// <param name="ftpFile">ftp服务器文件全路径</param>
      /// <returns></returns>
        public bool ftpGetFile(string localFile, string ftpFile)
        {
            try
            {
                if (ftpconn())
                {
                    reqFTP = getFTPwbRequest(ftpFile, WebRequestMethods.Ftp.DownloadFile);
                    FtpWebResponse response = (FtpWebResponse)reqFTP.GetResponse();
                    Stream ftpStream = response.GetResponseStream();
                    if (outputStream(localFile, ftpStream))//字符流处理方法
                    {
                        ftpStream.Close();
                        response.Close();
                        return true;
                    }
                    else
                    {
                        ftpStream.Close();
                        response.Close();
                        return false;
                    }
                }
                else
                {
                    Common.debugPrint("ftpconn()连接失败");
                    return false;
                }
                
            }
            catch (Exception ex)
            {
                Common.debugPrint(ex.Message.ToString());
                return false;
            }
        }
       #endregion
        #region 断点续传
        
        
        /// <summary>
        /// 断点续传(下载)
        /// </summary>
        /// <param name="localFile">本地文件路径</param>
        /// <param name="ftpFile">FTP文件路径</param>
        /// <returns>bool</returns>
        public bool ftpGetBrokenFile(string localFile, string ftpFile)
        {
            try
            {
                if (File.Exists(localFile))
                {
                    FileInfo fileinfo = new FileInfo(localFile);
                    long leng = fileinfo.Length;
                    if (ftpconn())
                    {
                        if (leng < GetftpFilesLength(ftpFile) && leng < 1024 * 10000)
                        {
                            File.Delete(localFile);//删除重传
                            Common.debugPrint(localFile + "删除重传");
                            return ftpGetFile(localFile, ftpFile);//调用ftpGetFile
                        }
                        else// 断点续传                                                     
                        {
                            reqFTP = getFTPwbRequest(ftpFile, WebRequestMethods.Ftp.DownloadFile);
                            reqFTP.ContentOffset = leng;
                            FtpWebResponse response = (FtpWebResponse)reqFTP.GetResponse();
                            Stream ftpStream = response.GetResponseStream();
                            if (outputStream(localFile, ftpStream))//字符流处理方法
                            {
                                ftpStream.Close();
                                response.Close();
                                Common.debugPrint(localFile + "断点续传完成");
                                return true;
                            }
                            else
                            {
                                Common.debugPrint(localFile + "断点续传失败");
                                return false;
                            }
                        }
                    }
                    else
                    {
                        Common.debugPrint("ftpconn()连接失败");
                        return false;
                    }
                }
                else
                {
                    return ftpGetFile(localFile, ftpFile);//调用ftpGetFile
                }
            }
            catch (Exception ex)
            {
                Common.debugPrint(ex.Message.ToString()+"EasyonFtp类");
                return false;
            }
        }
        #endregion
        #region FTP上传
        /// <summary>
        ///  FTP上传方法
        /// </summary>
        /// <param name="localFile">本地文件全路径</param>
        /// <param name="ftpFile">上传到ftp服务器的指定路径</param>
        /// <param name="Breakpoint">断点处</param>
        /// <returns></returns>
        public bool ftpUpload(string localFile, string ftpFile, long Breakpoint)
        {
            if (Breakpoint > 0)
            {
                reqFTP = getFTPwbRequest(ftpFile, WebRequestMethods.Ftp.AppendFile);
            }
            else
            {
                reqFTP = getFTPwbRequest(ftpFile, WebRequestMethods.Ftp.UploadFile);
            }
            FileInfo fileinfo = new FileInfo(localFile);
            Stream strm = reqFTP.GetRequestStream();
            try
            {
                // 上传文件时通知服务器文件的大小
                reqFTP.ContentLength = fileinfo.Length;
                //这里判断是否是断点续传

                if (inputStream(localFile, strm, Breakpoint))
                {
                    return true;
                }
                else
                {
                    Common.debugPrint("outputStream处理异常");
                    return false;
                }
            }
            catch (Exception ex)
            {
                Common.debugPrint(ex.Message);
            }
            finally
            {
                strm.Close();
            }
            return false;
        }

        /// <summary>
        /// 创建文件夹   （1J目录）
        /// </summary>
        /// <param name="ftpFile"></param>
        public bool MaikDir(string ftpFile)
        {
            FtpWebResponse response = null;
            try
            {
                string uri = ftpFile;
                //Connect(uri);//连接
                reqFTP = getFTPwbRequest(ftpFile, WebRequestMethods.Ftp.MakeDirectory);
               // reqFTP.Method = WebRequestMethods.Ftp.MakeDirectory;
               response = (FtpWebResponse)reqFTP.GetResponse();       
            }
            catch (Exception ex)
            {
                return false;
               // MessageBox.Show(ex.Message);
            }
            finally
            {
                if (response != null)
                {
                    response.Close();
                }
            }
            return true;

        }
        #endregion
        #region  获取ftp上文件最后修改时间
        
        /// <summary>
        /// 获取ftp上文件最后修改时间
        /// </summary>
        /// <param name="filename"></param>
        /// <returns></returns>
        public DateTime GetftpFileslastModifiedTime(string filename)
        {
            DateTime lastmodified = new DateTime();
            try
            {
                if (ftpconn())
                {
                    reqFTP = getFTPwbRequest(filename, WebRequestMethods.Ftp.GetDateTimestamp);
                    FtpWebResponse response = (FtpWebResponse)reqFTP.GetResponse();
                    lastmodified = response.LastModified;
                    response.Close();
                }
            }
            catch (Exception ex)
            {
                Common.debugPrint(ex.Message + "EasyonFtp类 GetftpFileslastModifiedTime()");
            }
            return lastmodified;
        }
        #endregion
        #region 获取FTP文件的长度
        
        
        public long GetftpFilesLength(string filename)
        {
            long length = 0;
            try
            {
                if (ftpconn())
                {
                    reqFTP = getFTPwbRequest(filename, WebRequestMethods.Ftp.GetFileSize);
                    FtpWebResponse response = (FtpWebResponse)reqFTP.GetResponse();
                    length = response.ContentLength;
                }
            }
            catch (Exception ex)
            {
                Common.debugPrint(ex.Message + "EasyonFtp类 GetftpFilesLength() ");
            }
            return length;
        }
        #endregion
        #region 获取ftp目录下文件信息

        /// <summary>
        /// 获取ftp目录下文件和文件夹信息(只获取当前目录信息)
        /// </summary>
        /// <param name="ftpFile">ftp目录</param>
        /// <returns></returns>
        public FileStruct[] ftpListFiles(string ftpFile)
        {
          
            FileStruct[] list = null;
            try
            {
                if (ftpconn())
                {
                    reqFTP = getFTPwbRequest(ftpFile, WebRequestMethods.Ftp.ListDirectoryDetails);
                    FtpWebResponse response = (FtpWebResponse)reqFTP.GetResponse();
                    StreamReader stream = new StreamReader(response.GetResponseStream(), Encoding.Default);
                    string Datastring = stream.ReadToEnd();
                    DirectoryListParser parser = new DirectoryListParser(Datastring);
                    list = parser.FullListing;
                    response.Close();
                    //char[] seperator = { '\n' };
                    //list = Datastring.Split(seperator);
                    
                    return list;
                }
            }
            catch (Exception ex)
            {
                Common.debugPrint(ex.Message + "EasyonFtp类 GetftpFilesLength()");
            }
            return list;
        }
        #endregion
        #region FtpWebRequest请求
 
        /// <summary>
        /// 获取FtpWebRequest
        /// </summary>
        /// <param name="ftpFilepath">ftp文件/目录路径</param>
        /// <param name="Method">WebRequestMethods.Ftp.Method</param>
        /// <returns></returns>
        public FtpWebRequest getFTPwbRequest(string ftpFilepath, string Method)
        {
            try
            {
                reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri(ftpFilepath));
                reqFTP.Method = Method;
                reqFTP.KeepAlive = true;
                reqFTP.UseBinary = true;
            }
            catch (Exception ex)
            {
                Common.debugPrint(ex.Message + "EasyononFtp获取FtpWebRequest失败");
                return null;
            }
            try
            {
                reqFTP.Credentials = new NetworkCredential(user, pwd);
                
            }
            catch (Exception ex)
            {
                Common.debugPrint(ex.Message);
            }
            return reqFTP;

        }
        public FtpWebRequest getFTPwbRequest1(string ftpFilepath, string Method)
        {
            try
            {
                reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri(ftpFilepath));
                reqFTP.Method = Method;
                //reqFTP.KeepAlive = true;
                reqFTP.UseBinary = true;
            }
            catch (Exception ex)
            {
                Common.debugPrint(ex.Message + "EasyononFtp获取FtpWebRequest失败");
                return null;
            }
            try
            {
                reqFTP.Credentials = new NetworkCredential(user, pwd);

            }
            catch (Exception ex)
            {
                Common.debugPrint(ex.Message);
            }
            return reqFTP;

        }
        #endregion
        #region 下载文件流输出处理

        /// <summary>
        /// 下载文件流输出处理方法
        /// </summary>
        /// <param name="filePath">ftp文件路径</param>
        /// <param name="ftpStream">IO流</param>
        /// <returns></returns>
        private bool outputStream(string filePath, Stream ftpStream)
        {
            FileStream outputStream  = new FileStream(filePath, FileMode.Append, FileAccess.Write);
           
            int bufferSize = 2048*1000;

            int readCount;

            byte[] buffer = new byte[bufferSize];
            try
            {
                readCount = ftpStream.Read(buffer, 0, bufferSize);
                while (readCount > 0)
                {
                    outputStream.Write(buffer, 0, readCount);
                    readCount = ftpStream.Read(buffer, 0, bufferSize);
                }
                return true;
            }
            catch (Exception ex)
            {
                Common.debugPrint(ex.Message.ToString() + "EasyononFtp类下载文件流输出处理方法异常");
                return false;
            }
            finally
            {
                outputStream.Close();
            }
        }
        #endregion
        #region 上传文件流输出处理
       /// <summary>
        /// 上传文件流输出处理方法
       /// </summary>
       /// <param name="fileinfo">文件信息</param>
       /// <param name="ftpStream">IO流</param>
       /// <returns></returns>
        private bool inputStream(string filePath, Stream ftpStream, long Breakpoint)
        {
            
            // 打开一个文件流(System.IO.FileStream) 去读上传的文件
            FileStream outputStream = new FileStream(filePath, FileMode.Open);
            
            // 缓冲大小设置为kb
            int bufferSize = 2048 * 1000;

            int readCount;

            byte[] buffer = new byte[bufferSize];
            try
            {
                if (Breakpoint > 0)
                {
                    outputStream.Seek(Breakpoint, SeekOrigin.Current);
                    
                   
                }
                
                    readCount = outputStream.Read(buffer, 0, bufferSize);
                
                while (readCount > 0)
                {
                    // 把内容从file stream 写入upload stream 
                    ftpStream.Write(buffer, 0, readCount);
                    readCount = outputStream.Read(buffer, 0, bufferSize);
                  
                   // 
                }
                
                return true;
            }
            catch (Exception ex)
            {
                Common.debugPrint(ex.Message.ToString() + "上传文件流输出处理方法异常");
                return false;
            }
            finally
            {
                outputStream.Close();
            }
        }
        #endregion
       
    }
}

如果有哪位大大能给排本提供帮助，在园子逛的也蛮久了，发现很多都排的挺漂亮的。