C# ftpHelper

最新推荐文章于 2024-06-25 16:06:51 发布
置顶 最新推荐文章于 2024-06-25 16:06:51 发布
阅读量1.4k 收藏 13
点赞数 12
分类专栏： C#基础知识 文章标签： c# ftp
原文链接：https://cloud.tencent.com/developer/article/1343559
版权

@C# ftp文件操作类ftpHelper

C# ftp文件操作类ftpHelper：

在C#对文件操作的时候,在百度和必应上搜索很多资料，但是没有一个很完善操作ftp文件的ftpHelper类，其他同学写的难免有些差强人意，之后自己想写一个完善的ftp文件操作类ftpHelper。这些方法在跟着阿笨一起玩NET的基础上扩展和整理，所有方法都经过验证，可以放心使用。如果其中有需要探讨的，给我留言即可。

ftpHelper操作类引用说明

1.文章的大部分类容是从https://cloud.tencent.com/developer/article/1343559这里看到的，本人在上面增加了几个方法，和优化返回内容;
2.对于所有的方法，本人已经经过验证，可以放心使用；
3.如果觉得这个ftpHelper还可以了，想给我点赞的同时，请不要忘了给我引用"跟着阿笨一起玩NET"点赞，谢谢；
4.具体的验证我上传到CSDN，0币下载，下载链接FtpHepler操作类下载；
5.如果对Windows FileHepler感兴趣，可以点击FileHepler下载

主要方法：

ftp操作的几个主要的方法

1.FTP初始化；
2.创建目录；
3.更改目录或文件名；
4.切换当前目录；
5.列出当前目录的所有文件；
6.列出当前目录的所有一级子目录；
7.判断当前目录下指定的子目录或文件是否存在；
8.判断当前目录下指定的子文件是否存在；
9.删除空目录；
10.删除目录(包括下面所有子目录和子文件)
11.删除文件；
12.下载单个文件；
13.批量下载当前目录下的所有文件与目录；
14.单个文件上传；
15.批量上传当前目录下的所有文件；
16.递归获取FTP服务器上的目录和文件信息；
17.获取当前目录下的文件和文件夹；
18.获取当前目录一级字目录和文件信息；

主要截图：

1.下载界面，0币下载
0币下载

2.验证功能界面
在这里插入图片描述
3.FtpHepler内容
在这里插入图片描述

在这里插入图片描述

代码内容

/// <summary>
    /// FTP操作类
    /// </summary>
    public class FtpHelper
    {
        /// <summary>
        /// FTP请求对象
        /// </summary>
        FtpWebRequest request = null;
        /// <summary>
        /// FTP响应对象
        /// </summary>
        FtpWebResponse response = null;

        /// <summary>
        /// 文件内容
        /// </summary>
        List<FileStruct> fileLists = new List<FileStruct>();

        /// <summary>
        /// 多个消息实体
        /// </summary>
        List<OperationResult> operationResults = new List<OperationResult>();

        /// <summary>
        /// 单个消息实体
        /// </summary>
        OperationResult operationResult = new OperationResult();

        FilesHelper filesHelper = new FilesHelper();

        public string ftpServerIP;          //FTPIP
        public string ftpServerPort;        //FTP端口
        public string ftpRemotePath;        //FTP目标目录
        public string ftpUserID;            //FTP登录名
        public string ftpPassword;          //FTP密码
        public string Ipath;                //目标文件存放路径
        public string ftpURI;               //得到的FTPUrL
        public string ftpUrls;              //得到相对的Url

        #region FTP初始化
        /// <summary>
        /// 获取FTP的URL
        /// </summary>
        /// <param name="ftpServerIP"></param>
        /// <param name="ftpServerPort"></param>
        /// <param name="ftpRemotePath"></param>
        /// <param name="ftpUserID"></param>
        /// <param name="ftpPassword"></param>
        /// <param name="Ipath"></param>
        public string getFtpHelper(string ftpServerIP, string ftpServerPort, string ftpRemotePath, string ftpUserID, string ftpPassword, string Ipath)
        {
            this.ftpServerIP = ftpServerIP;
            this.ftpRemotePath = ftpRemotePath;
            this.ftpServerPort = ftpServerPort;
            this.Ipath = Ipath;
            this.ftpUserID = ftpUserID;
            this.ftpPassword = ftpPassword;
            this.ftpUrls = "ftp://" + ftpServerIP + ":" + ftpServerPort + "/";
            this.ftpURI = "ftp://" + ftpServerIP + ":" + ftpServerPort + "/" + ftpRemotePath + "/";
            return ftpURI;
        }

        /// <summary>       
        /// 建立FTP链接,返回请求对象       
        /// </summary>      
        /// <param name="uri">FTP地址</param>       
        /// <param name="ftpMethod">操作命令</param>       
        private FtpWebRequest FTPRequest(Uri uri, string ftpMethod)
        {
            request = (FtpWebRequest)WebRequest.Create(uri);
            request.Method = ftpMethod;
            request.UseBinary = true;
            request.KeepAlive = false;
            request.Credentials = new NetworkCredential(ftpUserID, ftpPassword);
            return request;
        }

        /// <summary>
        /// 建立FTP链接,返回响应对象
        /// </summary>
        /// <param name="uri">请求的URL</param>
        /// <param name="ftpMethod">请求的方法</param>
        /// <returns></returns>
        private FtpWebResponse FTPResponse(Uri uri, string ftpMethod)
        {
            request = (FtpWebRequest)FtpWebRequest.Create(uri);
            request.Method = ftpMethod;
            request.UseBinary = true;
            request.KeepAlive = false;                                          //保持接,其他方法关闭
            request.Credentials = new NetworkCredential(ftpUserID, ftpPassword);
            return (FtpWebResponse)request.GetResponse();
        }

        /// <summary>       
        /// 析构函数关闭连接，如果不了解析构函数，可以去网上查找C#析构函数    
        /// </summary>           
        ~FtpHelper()
        {
            if (response != null)
            {
                response.Close();
                response = null;
            }
            if (request != null)
            {
                request.Abort();
                request = null;
            }
        }
        #endregion


        #region 创建目录
        /// <summary>
        /// 创建目录
        /// </summary>
        /// <param name="remoteDirectoryName">目录名称</param>
        public OperationResult CreateDirectory(string remoteDirectoryName)
        {
            bool flag=IsExist(remoteDirectoryName);
            if (!flag)
            {
                try
                {
                    response = FTPResponse(new Uri(ftpUrls + ftpRemotePath + "/"  + remoteDirectoryName), WebRequestMethods.Ftp.MakeDirectory);
                    operationResult.isOk = true;
                    operationResult.tRes = string.Format("创建目录{0}成功", remoteDirectoryName);
                }
                catch (Exception ex)
                {
                    operationResult.isOk = false;
                    operationResult.tRes = string.Format("创建目录失败，失败原因:{0}", ex.ToString());
                }
            }
            else 
            {
                operationResult.isOk = true;
                operationResult.tRes = string.Format("目录{0}已存在", remoteDirectoryName);
            }
            return operationResult;
        }
        #endregion


        #region 更改目录或文件名
        /// <summary>
        /// 更改目录或文件名
        /// </summary>
        /// <param name="currentName">当前目录或者文件名</param>
        /// <param name="newName">修改后新目录或者文件名</param>
        public OperationResult ReName(string currentName, string newName)
        {
            try
            {
                request = FTPRequest(new Uri(ftpURI + currentName), WebRequestMethods.Ftp.Rename);
                request.RenameTo = newName;
                response = (FtpWebResponse)request.GetResponse();
                operationResult.isOk = true;
                operationResult.tRes = "更改目录或文件名成功";
            }
            catch (Exception ex)
            {
                operationResult.isOk = false;
                operationResult.tRes = string.Format("更改目录或文件名失败,失败原因:{0}", ex.ToString());
            }
            return operationResult;
        }
        #endregion


        #region 切换当前目录
        /// <summary>  
        /// 切换当前目录  
        /// </summary>  
        /// <param name="IsRoot">true:绝对路径 false:相对路径</param>   
        public void GotoDirectory(string DirectoryName, bool IsRoot)
        {
            if (IsRoot)
            {
                ftpRemotePath = DirectoryName;
            }
            else
            {
                ftpRemotePath += "/" + DirectoryName;
            }
            ftpURI = "ftp://" + ftpServerIP + ":" + ftpServerPort + "/" + ftpRemotePath + "/";
        }
        #endregion


        #region 列出当前目录的所有文件
        /// <summary>
        /// 列出当前目录的所有文件
        /// </summary>
        /// <param name="remoteDirectoryName">目录名</param>
        /// <param name="IsDir">是否包含子目录</param>
        /// <returns></returns>
        public List<FileStruct> ListFiles(string remoteDirectoryName, bool IsDir)
        {
            var listAll = getAllFilesAndDirectories(remoteDirectoryName, IsDir);
            var listFile = listAll.Where(m => m.IsDirectory == false).ToList();
            return listFile;
        }
        #endregion


        #region 列出当前目录的所有一级子目录
        /// <summary>       
        /// 列出当前目录的所有一级子目录       
        /// </summary>       
        public List<FileStruct> ListDirectories()
        {
            var listAll = ListFilesAndDirectories();
            var listFile = listAll.Where(m => m.IsDirectory == true).ToList();
            return listFile;
        }
        #endregion


        #region 判断当前目录下指定的子目录或文件是否存在
        /// <summary>       
        /// 判断当前目录下指定的子目录或文件是否存在       
        /// </summary>       
        /// <param name="remoteDirName">指定的目录或文件名</param>      
        public bool IsExist(string remoteDirName)
        {
            var list = ListFilesAndDirectories();
            if (list.Count(m => m.Name == remoteDirName) > 0)
            {
                return true;
            }
            return false;
        }
        #endregion


        #region 判断当前目录下指定的子文件是否存在
        /// <summary>
        /// 判断当前目录下指定的子文件是否存在
        /// </summary>
        /// <param name="remoteDirectoryName">目录名</param>
        /// <param name="IsDir">是否包含子文件夹</param>
        /// <param name="remoteFileName">远程文件名</param>
        /// <returns></returns>
        public bool IsFileExist(string remoteDirectoryName, bool IsDir, string remoteFileName)
        {
            var listFile = ListFiles(remoteDirectoryName, IsDir);
            if (listFile.Count(m => m.Name == remoteFileName) > 0)
            {
                return true;
            }
            return false;
        } 
        #endregion


        #region 删除空目录
        /// <summary>
        /// 删除空目录
        /// </summary>
        /// <param name="remoteDirectoryName">目录相对路径</param>
        public OperationResult RemoveNullDirectory(string remoteDirectoryName)
        {
            try
            {
                GotoDirectory(remoteDirectoryName, false);
                response = FTPResponse(new Uri(ftpURI), WebRequestMethods.Ftp.RemoveDirectory);
                operationResult.isOk = true;
                operationResult.tRes = "删除空目录成功";
            }
            catch (Exception ex)
            {
                operationResult.isOk = false;
                operationResult.tRes = string.Format("删除空目录成功失败,失败原因:{0}", ex.ToString());
            }
            return operationResult;
        }
        #endregion


        #region 删除目录(包括下面所有子目录和子文件)
        /// <summary>
        /// 删除目录(包括下面所有子目录和子文件)
        /// </summary>
        /// <param name="remoteDirectoryName">目录绝对路径</param>
        /// <param name="IsDir">是否删除子目录</param>
        public OperationResult RemoveDirectory(string remoteDirectoryName,bool IsDir)
        {
            fileLists = new List<FileStruct>();
            try
            {
                var listAll = getAllFilesAndDirectories(remoteDirectoryName,IsDir);
                if (listAll.Count > 0) 
                {
                    foreach (var m in listAll)
                    {
                        if (!m.IsDirectory)
                        {
                            DeleteFile(m.Path);
                        }
                        else  //那就删除子目录
                        {
                            GotoDirectory(m.Path, true);
                            response = FTPResponse(new Uri(ftpURI), WebRequestMethods.Ftp.RemoveDirectory);
                        }
                    }
                }
                if (IsDir) 
                {
                    GotoDirectory(remoteDirectoryName, true);
                    response = FTPResponse(new Uri(ftpURI), WebRequestMethods.Ftp.RemoveDirectory);
                }
                operationResult.isOk = true;
                operationResult.tRes = String.Format("删除目录{0}成功", remoteDirectoryName);
            }
            catch (Exception ex)
            {
                operationResult.isOk = false;
                operationResult.tRes = string.Format("删除目录{0}成功失败,失败原因:{1}", remoteDirectoryName, ex.ToString());
            }
            return operationResult;
        }
        #endregion


        #region 删除文件
        /// <summary>  
        /// 删除文件  
        /// </summary>  
        /// <param name="remoteFileName">要删除的文件名,FTP+相对路径</param>
        public void DeleteFile(string remoteFileName)
        {
            response = FTPResponse(new Uri(ftpUrls+ remoteFileName), WebRequestMethods.Ftp.DeleteFile);
        }
        #endregion


        #region 下载单个文件
        /// <summary>
        /// 下载单个文件
        /// </summary>
        /// <param name="saveFilePath">下载后的保存路径</param>
        /// <param name="downloadFileName">文件名，相对路径</param>
        /// <param name="IsCreateIpath">是否要创建目录</param>
        public void DownloadSingleFile(string saveFilePath, string downloadFileName, bool IsCreateIpath)
        {
            if (IsCreateIpath)
            {
                saveFilePath += "\\" + downloadFileName;
                //判断目录是否存在，不存在就创建目录
                filesHelper.CreateDirectory(System.IO.Path.GetDirectoryName(saveFilePath));
            }
            else 
            {
                saveFilePath += "\\" + System.IO.Path.GetFileName(downloadFileName);
            }
            using (FileStream outputStream = new FileStream(saveFilePath, FileMode.Create))
            {
                response = FTPResponse(new Uri(ftpUrls + downloadFileName), WebRequestMethods.Ftp.DownloadFile);
                using (Stream ftpStream = response.GetResponseStream())
                {
                    long cl = response.ContentLength;
                    int bufferSize = 2048;
                    int readCount;
                    byte[] buffer = new byte[bufferSize];
                    readCount = ftpStream.Read(buffer, 0, bufferSize);
                    while (readCount > 0)
                    {
                        outputStream.Write(buffer, 0, readCount);
                        readCount = ftpStream.Read(buffer, 0, bufferSize);
                    }
                }
            }  
        }
        #endregion


        #region 批量下载当前目录下的所有文件与目录
        /// <summary>
        /// 批量下载当前目录下的所有文件与目录
        /// </summary>
        /// <param name="saveFilePath">下载后的保存路径</param>
        /// <param name="remoteDirectoryName">要下载的目录</param>
        /// <param name="IsDir">是否包含子目录</param>
        /// <param name="IsCreateIpath">是否创建子目录</param>
        public Tuple<OperationResult, List<FileStruct>> DownloadAllFile(string saveFilePath, string remoteDirectoryName, bool IsDir,bool IsCreateIpath)
        {
            fileLists = new List<FileStruct>();
            try
            {
                var listAll = getAllFilesAndDirectories(remoteDirectoryName,IsDir);
                if (listAll.Count > 0)
                {
                    foreach (var m in listAll)
                    {
                        if (!m.IsDirectory)
                        {
                            DownloadSingleFile(saveFilePath, m.Path, IsCreateIpath);
                        }
                    }
                }
                operationResult.isOk = true;
                operationResult.tRes = String.Format("下载当前目录{0}下的所有文件成功", remoteDirectoryName);
            }
            catch (Exception ex)
            {
                operationResult.isOk = false;
                operationResult.tRes = string.Format("下载当前目录{0}下的所有文件成功失败,失败原因:{1}", remoteDirectoryName, ex.ToString());
            }
            return new Tuple<OperationResult,List<FileStruct>>(operationResult, fileLists);
        }
        #endregion


        #region 单个文件上传
        /// <summary>
        /// 单个文件上传
        /// </summary>
        /// <param name="localFilePath">本地绝对路径</param>
        /// <param name="IsCreateIpath">是否创建目录</param>
        public void UploadSingleFile(string localFilePath,Uri ftpURI)
        {
            FileInfo fileInfo = new FileInfo(localFilePath);
            request = FTPRequest(new Uri(ftpURI + fileInfo.Name), WebRequestMethods.Ftp.UploadFile);
            request.ContentLength = fileInfo.Length;
            int buffLength = 2048;
            byte[] buff = new byte[buffLength];
            int contentLen;
            using (var fs = fileInfo.OpenRead())
            {
                using (var strm = request.GetRequestStream())
                {
                    contentLen = fs.Read(buff, 0, buffLength);
                    while (contentLen != 0)
                    {
                        strm.Write(buff, 0, contentLen);
                        contentLen = fs.Read(buff, 0, buffLength);
                    }
                }
            }
        }
        #endregion


        #region 批量上传当前目录下的所有文件
        /// <summary>
        /// 批量上传当前目录下的所有文件
        /// </summary>
        /// <param name="Ipath">Windows绝对路径</param>
        /// <param name="IsDir">是否包含子目录</param>
        /// <param name="IsCreateIpath">是否在Ftp上创建子目录</param>
        /// <returns></returns>
        public OperationResult UploadAllFile(string Ipath,bool IsDir,bool IsCreateIpath)
        {
            try
            {
                var data = filesHelper.GetDirectoryAndFile(Ipath, IsDir);
                if (data.Item1.isOk)
                {
                    foreach (var item in data.Item3.Values)
                    {
                        if (IsCreateIpath)
                        {
                            string fileRelationPath = System.IO.Path.GetDirectoryName(item).Substring(3).Replace("\\","/");
                            var data1 = CreateDirectory(fileRelationPath);
                            if (data1.isOk)
                            {
                                ftpURI = ftpUrls+ ftpRemotePath + "/" + fileRelationPath + "/";
                            }
                        }
                        UploadSingleFile(item, new Uri(ftpURI));
                    }
                }
                operationResult.isOk = true;
                operationResult.tRes = string.Format("批量上传当前目录{0}下的所有文件成功", Ipath);
            }
            catch (Exception ex) 
            {
                operationResult.isOk = false;
                operationResult.tRes = string.Format("批量上传当前目录{0}下的所有文件失败，失败原因{1}", Ipath,ex.ToString());
            }
            return operationResult;
        } 
        #endregion


        #region 递归获取FTP服务器上的目录和文件信息
        /// <summary>
        /// 递归获取FTP服务器上的目录和文件信息
        /// </summary>
        /// <param name="remoteDirectoryName">目录绝对路径</param>
        /// <param name="IsDir">是否获取子目录的文件</param>
        public List<FileStruct> getAllFilesAndDirectories(string remoteDirectoryName,bool IsDir)
        {
            try
            {
                GetListFilesAndDirectories(remoteDirectoryName,IsDir);
            }
            catch (Exception ex) 
            {
                return null;
            }
            return fileLists;
        }

        /// <summary>
        /// 获取当前目录下的文件和文件夹
        /// </summary>
        /// <param name="remoteDirectoryName">目录绝对路径</param>
        /// <param name="IsDir">是否要获取子文件夹的文件</param>
        public void GetListFilesAndDirectories(string remoteDirectoryName,bool IsDir)
        {
            GotoDirectory(remoteDirectoryName, true);
            var listAll = ListFilesAndDirectories();
            foreach (var m in listAll)
            {
                if (m.IsDirectory)
                {
                    if (IsDir)  //继续获取子文件夹
                    {
                        GetListFilesAndDirectories(m.Path,true);
                    } 
                }
                fileLists.Add(m);
            }
        } 
        #endregion


        #region 获取当前目录的一级子目录和文件信息
        /// <summary>
        /// 获取当前目录一级字目录和文件信息
        /// </summary>
        /// <param name="IsOnlyDir">是否只获取目录</param>
        /// <returns></returns>
        public List<FileStruct> ListFilesAndDirectories()
        {
            var fileList = new List<FileStruct>();
            response = FTPResponse(new Uri(ftpURI), WebRequestMethods.Ftp.ListDirectoryDetails);   
            using (var stream = response.GetResponseStream())
            {
                using (var sr = new StreamReader(stream))
                {
                    string line = null;
                    while ((line = sr.ReadLine()) != null)
                    {
                        DateTime dtDate = DateTime.ParseExact(line.Substring(0, 8), "MM-dd-yy", null);
                        DateTime dtDateTime = DateTime.Parse(dtDate.ToString("yyyy-MM-dd") + line.Substring(8, 9));
                        string[] arrs = line.Split(' ');
                        var model = new FileStruct()
                        {
                            IsDirectory = line.IndexOf("<DIR>") > 0 ? true : false,
                            CreateTime = dtDateTime,
                            Name = arrs[arrs.Length - 1],
                            Path = ftpRemotePath + "/" + arrs[arrs.Length - 1]
                        };
                        fileList.Add(model);
                    }
                }
            }
            return fileList;
        }
        #endregion
    }
种一抹馨香
关注
  • 12
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
C# FTPHelper类
04-09
FTPHelper帮助类,网上盛传的那个类不好说,反正我用过觉得不方便,因此自己花了点时间自己写了一个,方便大家使用,对新手也是个很好的学习编码的教程
C# FTP操作帮助类, FTPHelper.cs
08-17
C# FTP操作帮助类, FTPHelper.cs,已经封装好了FTP相关的各个操作的方法
C# FTP/SFTP 详解及连接 FTP/SFTP 方式示例汇总
qq_35320456的博客
05-29 1158
本文介绍了C#中如何实现FTP和SFTP的连接，并提供了一系列示例代码。通过使用第三方库，我们可以方便地在C#应用程序中实现文件传输的功能。展望未来，随着网络安全的日益重要，SFTP因其加密特性将会越来越受到重视。同时，随着云计算和大数据的发展，文件传输的需求也会不断增长，FTP和SFTP将继续在软件开发中扮演重要角色。我们可以期待更多高效、安全的文件传输工具和库的出现，以满足不断变化的需求。
FTP 在 C# 中的实现与应用
最新发布
weixin_47408699的博客
06-25 390
文件传输是各种应用程序和系统中至关重要的功能。文件传输协议（FTP）作为一种广泛使用的标准协议，为在网络环境中可靠地传输文件提供了有效的手段。
C# FTPHelper工具类
angzhuo9931的博客
05-26 155
/// <summary> /// Ftp /// </summary> public class FtpFileOperation { private string _ftpIp; private string _ftpUser; private strin...
C#一个FTP操作封装类FTPHelper
weixin_30685029的博客
04-18 166
参考了网上一些代码，作了一些调整优化。 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Net; using System.IO; public class FTPHelper { /// <summary&g...
C# FTPHelper
MeGoodtoo的专栏
06-15 541
public class FTPHelper     {         #region 字段         string ftpURI;         string ftpUserID;         string ftpServerIP;         string ftpPassword;         string ftpRemotePath;         #
C# FtpHelper 上传
09-12
FtpHelper是C#中一个常见的辅助类，用于处理FTP（File Transfer Protocol）文件传输任务。FTP是一个用于在网络上进行文件传输的标准协议，它允许用户从远程服务器上传、下载文件或管理目录。 在描述中提到的"C# ...
FtpHelper实现ftp服务器文件读写操作(C#)
12-31
最近做了一个项目，需要读取ftp服务器上的文件，于是参考了网上提供的一些帮组方法，使用过程中，出现一些小细节问题，于是本人做了一些修改，拿来分享一下 using System; using System.Collections.Generic;...
FtpHelper
Still_Waters的专栏
12-26 142
public class FtpHelper { private FTPClient ftpClient = new FTPClient(); /** * 连接到FTP服务器 * * @param hostname * 主机名 * @param port * 端口 * @param username...
C#_FTP控件
10-26
可以直接上传的FTP控件，很强大，大家试试吧！
C#.Net FTPClient组件
08-07
这可能是目前能找到的最好的.Net FtpClient组件了，功能非常之多，非常之全，要是商业化，至少也是价值上百美金的。这么好的作品，作者竟然无私的奉献出来，所以我也有义务让更多需要它的人找到它。 原作者Starksoft 网址：http://www.starksoft.com 作者好像已经停止更新了，最新版本是1.0.158 我的这份版本更新到1.0.159，增加了一个FtpClient.GetDirSize方法，可以获取目录的总大小（包括子目录和文件）。 觉得好用，记得回来给个好评哦。
【转载】C#工具类：FTP操作辅助类FTPHelper
weixin_30907523的博客
03-13 231
FTP是一个8位的客户端-服务器协议，能操作任何类型的文件而不需要进一步处理，就像MIME或Unicode一样。可以通过C#中的FtpWebRequest类、NetworkCredential类、WebRequestMethods类来实现一个FTP操作的相关辅助类FTPHelper。 先来看MSDN关于上述几个类的定义以及解释： FtpWebRequest类：实现文件传输协议 (FTP) 客户...
【C#】工具类-FTP操作封装类FTPHelper
chinaherolts2008的博客
12-16 407
C# FTPHelper实现FTP服务器文件读写c#教程 操作，支持SSL协议（FTP服务器为：Serv-U10.0）。 using System; using System.Collections.Generic; using System.IO; using System.Linq; using System.Net; using System.Net.Security; using System.Security.Cryptography.X509Certificates; using System.
C# FTPHelper 支持多层级文件上传下载
liliang119007的专栏
05-15 1757
在网上找了很多代码总觉得不能满足现有的需求 ，比如多级文件夹，一次性上传不同层级的所有文件。自己将网上找到的代码加上自己的修改。现在贴出来给大家希望呢个对大家有个小小帮助。欢迎找茬，互相进步 /// /// FTP帮助类 /// public class FTPHelper { #region 字段 string f
C#操作FTP, FTPHelper和SFTPHelper
weixin_33991727的博客
12-22 159
1. FTPHelper using System; using System.Collections.Generic; using System.IO; using System.Net; using System.Text; public class FTPHelper { /// <summary> /// 上传文...
FTP操作（FTPClient）
weixin_34416649的博客
02-16 98
//FTP开源封装的类 using System; using System.Collections.Generic; using System.Net; using System.IO; namespace FTP { /// <summary> /// FTP客户端操作类 /// </summary> ...
C# ftp上传帮助类
06-09
以下是一个基于C#的FTP上传帮助类示例： ```csharp using System; using System.IO; using System.Net; public class FtpHelper { private string ftpServerIP; private string ftpUserID; private string ftp...
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值