c#一个FTP操作封装类FTPHelper

Posted Avatarx

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了c#一个FTP操作封装类FTPHelper相关的知识,希望对你有一定的参考价值。

 

  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Linq;  
  4. using System.Text;  
  5. using System.Net;  
  6. using System.IO;  
  7.   
  8. public class FTPHelper  
  9. {  
  10.     /// <summary>  
  11.     /// FTP请求对象  
  12.     /// </summary>  
  13.     FtpWebRequest request = null;  
  14.     /// <summary>  
  15.     /// FTP响应对象  
  16.     /// </summary>  
  17.     FtpWebResponse response = null;  
  18.     /// <summary>  
  19.     /// FTP服务器地址  
  20.     /// </summary>  
  21.     public string ftpURI { get; private set; }  
  22.     /// <summary>  
  23.     /// FTP服务器IP  
  24.     /// </summary>  
  25.     public string ftpServerIP { get; private set; }  
  26.     /// <summary>  
  27.     /// FTP服务器默认目录  
  28.     /// </summary>  
  29.     public string ftpRemotePath { get; private set; }  
  30.     /// <summary>  
  31.     /// FTP服务器登录用户名  
  32.     /// </summary>  
  33.     public string ftpUserID { get; private set; }  
  34.     /// <summary>  
  35.     /// FTP服务器登录密码  
  36.     /// </summary>  
  37.     public string ftpPassword { get; private set; }  
  38.   
  39.     /// <summary>    
  40.     /// 初始化  
  41.     /// </summary>    
  42.     /// <param name="FtpServerIP">FTP连接地址</param>    
  43.     /// <param name="FtpRemotePath">指定FTP连接成功后的当前目录, 如果不指定即默认为根目录</param>    
  44.     /// <param name="FtpUserID">用户名</param>    
  45.     /// <param name="FtpPassword">密码</param>    
  46.     public FTPHelper(string ftpServerIP, string ftpRemotePath, string ftpUserID, string ftpPassword)  
  47.     {  
  48.         this.ftpServerIP = ftpServerIP;  
  49.         this.ftpRemotePath = ftpRemotePath;  
  50.         this.ftpUserID = ftpUserID;  
  51.         this.ftpPassword = ftpPassword;  
  52.         this.ftpURI = "ftp://" + ftpServerIP + "/" + ftpRemotePath + "/";  
  53.     }  
  54.     ~FTPHelper()  
  55.     {  
  56.         if (response != null)  
  57.         {  
  58.             response.Close();  
  59.             response = null;  
  60.         }  
  61.         if (request != null)  
  62.         {  
  63.             request.Abort();  
  64.             request = null;  
  65.         }  
  66.     }  
  67.     /// <summary>  
  68.     /// 建立FTP链接,返回响应对象  
  69.     /// </summary>  
  70.     /// <param name="uri">FTP地址</param>  
  71.     /// <param name="ftpMethod">操作命令</param>  
  72.     /// <returns></returns>  
  73.     private FtpWebResponse Open(Uri uri, string ftpMethod)  
  74.     {  
  75.         request = (FtpWebRequest)FtpWebRequest.Create(uri);  
  76.         request.Method = ftpMethod;  
  77.         request.UseBinary = true;  
  78.         request.KeepAlive = false;  
  79.         request.Credentials = new NetworkCredential(this.ftpUserID, this.ftpPassword);  
  80.         return (FtpWebResponse)request.GetResponse();  
  81.     }  
  82.   
  83.     /// <summary>         
  84.     /// 建立FTP链接,返回请求对象         
  85.     /// </summary>        
  86.     /// <param name="uri">FTP地址</param>         
  87.     /// <param name="ftpMethod">操作命令</param>         
  88.     private FtpWebRequest OpenRequest(Uri uri, string ftpMethod)  
  89.     {  
  90.         request = (FtpWebRequest)WebRequest.Create(uri);  
  91.         request.Method = ftpMethod;  
  92.         request.UseBinary = true;  
  93.         request.KeepAlive = false;  
  94.         request.Credentials = new NetworkCredential(this.ftpUserID, this.ftpPassword);  
  95.         return request;  
  96.     }  
  97.     /// <summary>  
  98.     /// 创建目录  
  99.     /// </summary>  
  100.     /// <param name="remoteDirectoryName">目录名</param>  
  101.     public void CreateDirectory(string remoteDirectoryName)  
  102.     {  
  103.         response = Open(new Uri(ftpURI + remoteDirectoryName), WebRequestMethods.Ftp.MakeDirectory);  
  104.     }  
  105.     /// <summary>  
  106.     /// 更改目录或文件名  
  107.     /// </summary>  
  108.     /// <param name="currentName">当前名称</param>  
  109.     /// <param name="newName">修改后新名称</param>  
  110.     public void ReName(string currentName, string newName)  
  111.     {  
  112.         request = OpenRequest(new Uri(ftpURI + currentName), WebRequestMethods.Ftp.Rename);  
  113.         request.RenameTo = newName;  
  114.         response = (FtpWebResponse)request.GetResponse();  
  115.     }     
  116.     /// <summary>    
  117.     /// 切换当前目录    
  118.     /// </summary>    
  119.     /// <param name="IsRoot">true:绝对路径 false:相对路径</param>     
  120.     public void GotoDirectory(string DirectoryName, bool IsRoot)  
  121.     {  
  122.         if (IsRoot)  
  123.             ftpRemotePath = DirectoryName;  
  124.         else  
  125.             ftpRemotePath += "/" + DirectoryName;  
  126.   
  127.         ftpURI = "ftp://" + ftpServerIP + "/" + ftpRemotePath + "/";  
  128.     }         
  129.     /// <summary>  
  130.     /// 删除目录(包括下面所有子目录和子文件)  
  131.     /// </summary>  
  132.     /// <param name="remoteDirectoryName">要删除的带路径目录名:如web/test</param>  
  133.     /* 
  134.      * 例:删除test目录 
  135.      FTPHelper helper = new FTPHelper("x.x.x.x", "web", "user", "password");                   
  136.      helper.RemoveDirectory("web/test"); 
  137.      */  
  138.     public void RemoveDirectory(string remoteDirectoryName)  
  139.     {  
  140.         GotoDirectory(remoteDirectoryName, true);  
  141.         var listAll = ListFilesAndDirectories();  
  142.         foreach (var m in listAll)  
  143.         {  
  144.             if (m.IsDirectory)             
  145.                 RemoveDirectory(m.Path);             
  146.             else             
  147.                 DeleteFile(m.Name);             
  148.         }  
  149.         GotoDirectory(remoteDirectoryName, true);  
  150.         response = Open(new Uri(ftpURI), WebRequestMethods.Ftp.RemoveDirectory);  
  151.     }  
  152.     /// <summary>  
  153.     /// 文件上传  
  154.     /// </summary>  
  155.     /// <param name="localFilePath">本地文件路径</param>  
  156.     public void Upload(string localFilePath)  
  157.     {  
  158.         FileInfo fileInf = new FileInfo(localFilePath);  
  159.         request = OpenRequest(new Uri(ftpURI + fileInf.Name), WebRequestMethods.Ftp.UploadFile);  
  160.         request.ContentLength = fileInf.Length;  
  161.         int buffLength = 2048;  
  162.         byte[] buff = new byte[buffLength];  
  163.         int contentLen;  
  164.         using (var fs = fileInf.OpenRead())  
  165.         {  
  166.             using (var strm = request.GetRequestStream())  
  167.             {  
  168.                 contentLen = fs.Read(buff, 0, buffLength);  
  169.                 while (contentLen != 0)  
  170.                 {  
  171.                     strm.Write(buff, 0, contentLen);  
  172.                     contentLen = fs.Read(buff, 0, buffLength);  
  173.                 }  
  174.             }  
  175.         }  
  176.     }  
  177.     /// <summary>    
  178.     /// 删除文件    
  179.     /// </summary>    
  180.     /// <param name="remoteFileName">要删除的文件名</param>  
  181.     public void DeleteFile(string remoteFileName)  
  182.     {  
  183.         response = Open(new Uri(ftpURI + remoteFileName), WebRequestMethods.Ftp.DeleteFile);  
  184.     }  
  185.   
  186.     /// <summary>  
  187.     /// 获取当前目录的文件和一级子目录信息  
  188.     /// </summary>  
  189.     /// <returns></returns>  
  190.     public List<FileStruct> ListFilesAndDirectories()  
  191.     {  
  192.         var fileList = new List<FileStruct>();  
  193.         response = Open(new Uri(ftpURI), WebRequestMethods.Ftp.ListDirectoryDetails);  
  194.         using (var stream = response.GetResponseStream())  
  195.         {  
  196.             using (var sr = new StreamReader(stream))  
  197.             {  
  198.                 string line = null;  
  199.                 while ((line = sr.ReadLine()) != null)  
  200.                 {  
  201.                     //line的格式如下:  
  202.                     //08-18-13  11:05PM       <DIR>          aspnet_client  
  203.                     //09-22-13  11:39PM                 2946 Default.aspx  
  204.                     DateTime dtDate = DateTime.ParseExact(line.Substring(0, 8), "MM-dd-yy", null);  
  205.                     DateTime dtDateTime = DateTime.Parse(dtDate.ToString("yyyy-MM-dd") + line.Substring(8, 9));  
  206.                     string[] arrs = line.Split(‘ ‘);  
  207.                     var model = new FileStruct()  
  208.                     {  
  209.                         IsDirectory = line.IndexOf("<DIR>") > 0 ? true : false,  
  210.                         CreateTime = dtDateTime,  
  211.                         Name = arrs[arrs.Length - 1],  
  212.                         Path = ftpRemotePath + "/" + arrs[arrs.Length - 1]  
  213.                     };  
  214.                     fileList.Add(model);  
  215.                 }  
  216.             }  
  217.         }  
  218.         return fileList;  
  219.     }  
  220.     /// <summary>         
  221.     /// 列出当前目录的所有文件         
  222.     /// </summary>         
  223.     public List<FileStruct> ListFiles()  
  224.     {  
  225.         var listAll = ListFilesAndDirectories();  
  226.         var listFile = listAll.Where(m => m.IsDirectory == false).ToList();  
  227.         return listFile;  
  228.     }  
  229.     /// <summary>         
  230.     /// 列出当前目录的所有一级子目录         
  231.     /// </summary>         
  232.     public List<FileStruct> ListDirectories()  
  233.     {  
  234.         var listAll = ListFilesAndDirectories();  
  235.         var listFile = listAll.Where(m => m.IsDirectory == true).ToList();  
  236.         return listFile;  
  237.     }  
  238.     /// <summary>         
  239.     /// 判断当前目录下指定的子目录或文件是否存在         
  240.     /// </summary>         
  241.     /// <param name="remoteName">指定的目录或文件名</param>        
  242.     public bool IsExist(string remoteName)  
  243.     {  
  244.         var list = ListFilesAndDirectories();  
  245.         if (list.Count(m => m.Name == remoteName) > 0)  
  246.             return true;  
  247.         return false;  
  248.     }  
  249.     /// <summary>         
  250.     /// 判断当前目录下指定的一级子目录是否存在         
  251.     /// </summary>         
  252.     /// <param name="RemoteDirectoryName">指定的目录名</param>        
  253.     public bool IsDirectoryExist(string remoteDirectoryName)  
  254.     {  
  255.         var listDir = ListDirectories();  
  256.         if (listDir.Count(m => m.Name == remoteDirectoryName) > 0)  
  257.             return true;  
  258.         return false;  
  259.     }  
  260.     /// <summary>         
  261.     /// 判断当前目录下指定的子文件是否存在        
  262.     /// </summary>         
  263.     /// <param name="RemoteFileName">远程文件名</param>         
  264.     public bool IsFileExist(string remoteFileName)  
  265.     {  
  266.         var listFile = ListFiles();  
  267.         if (listFile.Count(m => m.Name == remoteFileName) > 0)  
  268.             return true;  
  269.         return false;  
  270.     }  
  271.   
  272.     /// <summary>  
  273.     /// 下载  
  274.     /// </summary>  
  275.     /// <param name="saveFilePath">下载后的保存路径</param>  
  276.     /// <param name="downloadFileName">要下载的文件名</param>  
  277.     public void Download(string saveFilePath, string downloadFileName)  
  278.     {  
  279.         using (FileStream outputStream = new FileStream(saveFilePath + "\\" + downloadFileName, FileMode.Create))  
  280.         {  
  281.             response = Open(new Uri(ftpURI + downloadFileName), WebRequestMethods.Ftp.DownloadFile);  
  282.             using (Stream ftpStream = response.GetResponseStream())  
  283.             {  
  284.                 long cl = response.ContentLength;  
  285.                 int bufferSize = 2048;  
  286.                 int readCount;  
  287.                 byte[] buffer = new byte[bufferSize];  
  288.                 readCount = ftpStream.Read(buffer, 0, bufferSize);  
  289.                 while (readCount > 0)  
  290.                 {  
  291.                     outputStream.Write(buffer, 0, readCount);  
  292.                     readCount = ftpStream.Read(buffer, 0, bufferSize);  
  293.                 }  
  294.             }  
  295.         }  
  296.     }  
  297.   
  298.      
  299. }  
  300.   
  301. public class FileStruct  
  302. {  
  303.     /// <summary>  
  304.     /// 是否为目录  
  305.     /// </summary>  
  306.     public bool IsDirectory { get; set; }  
  307.     /// <summary>  
  308.     /// 创建时间  
  309.     /// </summary>  
  310.     public DateTime CreateTime { get; set; }  
  311.     /// <summary>  
  312.     /// 文件或目录名称  
  313.     /// </summary>  
  314.     public string Name { get; set; }  
  315.     /// <summary>  
  316.     /// 路径  
  317.     /// </summary>  
  318.     public string Path { get; set; }  
  319. }  

以上是关于c#一个FTP操作封装类FTPHelper的主要内容,如果未能解决你的问题,请参考以下文章

FtpHelper类匿名获取FTP文件

FTPHelper类

C#封装的JS(JavaScript)操作类的代码

c# 封装的文件夹操作类之复制文件夹

静态资源上传至远程ftp服务器,ftp工具类封装

手写一个好用的Java FTP操作工具类