在这篇文章中，我们将带领您了解【C#】工具类-FTP操作封装类FTPHelper的全貌，包括ftp封装的五个步骤的相关情况。同时，我们还将为您介绍有关asp.net操作FTP作为数据中转-Helper
在这篇文章中，我们将带领您了解【C#】工具类-FTP操作封装类FTPHelper的全貌，包括ftp封装的五个步骤的相关情况。同时，我们还将为您介绍有关asp.net 操作FTP作为数据中转-Helper.cs、C# FtpHelper实现ftp服务器文件读写操作、C# 文件下载工具类FileDownHelper、C#实现自定义FTP操作封装类实例的知识，以帮助您更好地理解这个主题。
本文目录一览：- 【C#】工具类-FTP操作封装类FTPHelper（ftp封装的五个步骤）
- asp.net 操作FTP作为数据中转-Helper.cs
- C# FtpHelper实现ftp服务器文件读写操作
- C# 文件下载工具类FileDownHelper
- C#实现自定义FTP操作封装类实例
【C#】工具类-FTP操作封装类FTPHelper（ftp封装的五个步骤）
C# FTPHelper实现FTP服务器文件读写操作，支持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.Text;
namespace FTPTest
{
public class FTPHelper
{
#region 变量
/// <summary>
/// FTP请求对象
/// </summary>
FtpWebRequest request = null;
/// <summary>
/// FTP响应对象
/// </summary>
FtpWebResponse response = null;
/// <summary>
/// FTP服务器长地址
/// </summary>
public string FtpURI { get; private set; }
/// <summary>
/// FTP服务器IP
/// </summary>
public string ServerIP { get; private set; }
/// <summary>
/// FTP端口
/// </summary>
public int ServerPort { get; private set; }
/// <summary>
/// FTP用户
/// </summary>
public string Username { get; private set; }
/// <summary>
/// FTP密码
/// </summary>
public string Password { get; private set; }
/// <summary>
/// 是否启用SSL
/// </summary>
public bool EnableSsl { get; private set; }
#endregion
#region 构造
/// <summary>
/// 初始化
/// </summary>
/// <param name="FtpServerIP">IP</param>
/// <param name="ftpServerPort">端口</param>
/// <param name="FtpUserID">用户名</param>
/// <param name="FtpPassword">密码</param>
public FTPHelper(string ftpServerIP, int ftpServerPort, string ftpUsername, string ftpPassword, bool ftpEnableSsl = false)
{
ServerIP = ftpServerIP;
ServerPort = ftpServerPort;
Username = ftpUsername;
Password = ftpPassword;
EnableSsl = ftpEnableSsl;
FtpURI = string.Format("ftp://{0}:{1}/", ftpServerIP, ftpServerPort);
}
~FTPHelper()
{
if (response != null)
{
response.Close();
response = null;
}
if (request != null)
{
request.Abort();
request = null;
}
}
#endregion
#region 方法
/// <summary>
/// 建立FTP链接,返回响应对象
/// </summary>
/// <param name="uri">FTP地址</param>
/// <param name="ftpMethod">操作命令</param>
private FtpWebResponse Open(Uri uri, string ftpMethod)
{
try
{
request = (FtpWebRequest)FtpWebRequest.Create(uri);
request.Method = ftpMethod;
request.UseBinary = true;
request.KeepAlive = false;
request.UsePassive = true;//被动模式
request.EnableSsl = EnableSsl;
request.Credentials = new NetworkCredential(Username, Password);
request.Timeout = 30000;
//首次连接FTP Server时，会有一个证书分配过程。
//根据验证过程，远程证书无效。
ServicePoint sp = request.ServicePoint;
ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(ValidateServerCertificate);
return (FtpWebResponse)request.GetResponse();
}
catch (Exception ex)
{
return null;
}
}
/// <summary>
/// 建立FTP链接,返回请求对象
/// </summary>
/// <param name="uri">FTP地址</param>
/// <param name="ftpMethod">操作命令</param>
private FtpWebRequest OpenRequest(Uri uri, string ftpMethod)
{
try
{
request = (FtpWebRequest)WebRequest.Create(uri);
request.Method = ftpMethod;
request.UseBinary = true;
request.KeepAlive = false;
request.UsePassive = true;//被动模式
request.EnableSsl = EnableSsl;
request.Credentials = new NetworkCredential(Username, Password);
request.Timeout = 30000;
ServicePoint sp = request.ServicePoint;
ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(ValidateServerCertificate);
return request;
}
catch (Exception ex)
{
return null;
}
}
/// <summary>
/// 证书验证回调
/// </summary>
private bool ValidateServerCertificate(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
{
return true;
}
/// <summary>
/// 下载文件
/// </summary>
/// <param name="remoteFileName">远程文件</param>
/// <param name="localFileName">本地文件</param>
public bool Get(string remoteFileName, string localFileName)
{
response = Open(new Uri(FtpURI + remoteFileName), WebRequestMethods.Ftp.DownloadFile);
if (response == null) return false;
try
{
using (FileStream outputStream = new FileStream(localFileName, FileMode.Create))
{
using (Stream ftpStream = response.GetResponseStream())
{
long length = 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);
}
}
}
return true;
}
catch
{
return false;
}
}
/// <summary>
/// 文件上传
/// </summary>
/// <param name="localFileName">本地文件</param>
/// <param name="localFileName">远程文件</param>
public bool Put(string localFileName, string remoteFileName)
{
FileInfo fi = new FileInfo(localFileName);
if (fi.Exists == false) return false;
request = OpenRequest(new Uri(FtpURI + remoteFileName), WebRequestMethods.Ftp.UploadFile);
if (request == null) return false;
request.ContentLength = fi.Length;
int buffLength = 2048;
byte[] buff = new byte[buffLength];
int contentLen;
try
{
using (var fs = fi.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);
}
}
}
return true;
}
catch
{
return false;
}
}
/// <summary>
/// 删除文件
/// </summary>
public bool DeleteFile(string fileName)
{
response = Open(new Uri(FtpURI + fileName), WebRequestMethods.Ftp.DeleteFile);
return response == null ? false : true;
}
/// <summary>
/// 创建目录
/// </summary>
public bool CreateDirectory(string dirName)
{
response = Open(new Uri(FtpURI + dirName), WebRequestMethods.Ftp.MakeDirectory);
return response == null ? false : true;
}
/// <summary>
/// 删除目录(包括下面所有子目录和子文件)
/// </summary>
public bool DeleteDirectory(string dirName)
{
var listAll = GetDirectoryAndFiles(dirName);
if (listAll == null) return false;
foreach (var m in listAll)
{
if (m.IsDirectory)
DeleteDirectory(m.Path);
else
DeleteFile(m.Path);
}
response = Open(new Uri(FtpURI + dirName), WebRequestMethods.Ftp.RemoveDirectory);
return response == null ? false : true;
}
/// <summary>
/// 获取目录的文件和一级子目录信息
/// </summary>
public List<FileStruct> GetDirectoryAndFiles(string dirName)
{
var fileList = new List<FileStruct>();
response = Open(new Uri(FtpURI + dirName), WebRequestMethods.Ftp.ListDirectoryDetails);
if (response == null) return fileList;
try
{
using (var stream = response.GetResponseStream())
{
using (var sr = new StreamReader(stream, Encoding.Default))
{
string line = null;
while ((line = sr.ReadLine()) != null)
{
//line的格式如下：serv-u(文件夹为第1位为d)
//drw-rw-rw- 1 user group 0 Jun 10 2019 BStatus
//-rw-rw-rw- 1 user group 625 Dec 7 2018 FTP文档.txt
string[] arr = line.Split('' '');
if (arr.Length < 12) continue;//remotePath不为空时，第1行返回值为：total 10715
var model = new FileStruct()
{
IsDirectory = line.Substring(0, 3) == "drw" ? true : false,
Name = arr[arr.Length - 1],
Path = dirName + "/" + arr[arr.Length - 1]
};
if (model.Name != "." && model.Name != "..")//排除.和..
{
fileList.Add(model);
}
}
}
}
return fileList;
}
catch
{
return fileList;
}
}
/// <summary>
/// 获取目录的文件
/// </summary>
public List<FileStruct> GetFiles(string dirName)
{
var fileList = new List<FileStruct>();
response = Open(new Uri(FtpURI + dirName), WebRequestMethods.Ftp.ListDirectory);
if (response == null) return fileList;
try
{
using (var stream = response.GetResponseStream())
{
using (var sr = new StreamReader(stream, Encoding.Default))
{
string line = null;
while ((line = sr.ReadLine()) != null)
{
var model = new FileStruct()
{
Name = line,
Path = dirName + "/" + line
};
fileList.Add(model);
}
}
}
return fileList;
}
catch
{
return fileList;
}
}
/// <summary>
/// 获得远程文件大小
/// </summary>
public long GetFileSize(string fileName)
{
response = Open(new Uri(FtpURI + fileName), WebRequestMethods.Ftp.GetFileSize);
return response == null ? -1 : response.ContentLength;
}
/// <summary>
/// 文件是否存在
/// </summary>
public bool FileExist(string fileName)
{
long length = GetFileSize(fileName);
return length == -1 ? false : true;
}
/// <summary>
/// 目录是否存在
/// </summary>
public bool DirectoryExist(string dirName)
{
var list = GetDirectoryAndFiles(Path.GetDirectoryName(dirName));
return list.Count(m => m.IsDirectory == true && m.Name == dirName) > 0 ? true : false;
}
/// <summary>
/// 更改目录或文件名
/// </summary>
/// <param name="oldName">老名称</param>
/// <param name="newName">新名称</param>
public bool ReName(string oldName, string newName)
{
request = OpenRequest(new Uri(FtpURI + oldName), WebRequestMethods.Ftp.Rename);
request.RenameTo = newName;
try
{
response = (FtpWebResponse)request.GetResponse();
return response == null ? false : true;
}
catch
{
return false;
}
}
#endregion
}
/// <summary>
/// FTP文件类
/// </summary>
public class FileStruct
{
/// <summary>
/// 是否为目录
/// </summary>
public bool IsDirectory { get; set; }
/// <summary>
/// 创建时间(FTP上无法获得时间)
/// </summary>
//public DateTime CreateTime { get; set; }
/// <summary>
/// 文件或目录名称
/// </summary>
public string Name { get; set; }
/// <summary>
/// 路径
/// </summary>
public string Path { get; set; }
}
}SSL测试调用代码
var ftp = new FTPHelper("192.168.0.36", 21, "test", "1", true);
var list = ftp.GetFiles("");任何地方如有纰漏，欢迎诸位道友指教。
asp.net 操作FTP作为数据中转-Helper.cs
总结
以上是小编为你收集整理的asp.net 操作FTP作为数据中转-Helper.cs全部内容。
如果觉得小编网站内容还不错，欢迎将小编网站推荐给好友。
C# FtpHelper实现ftp服务器文件读写操作
最近做了一个项目，需要读取ftp服务器上的文件，于是参考了网上提供的一些帮组方法，使用过程中，出现一些小细节问题，于是本人做了一些修改，拿来分享一下
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net;
using System.IO;
using System.Threading;
using System.Configuration;
namespace FtpSyn
{
public class FtpHelper
{
//基本设置 ftp://400:ZOina2017@192.168.10.17/400backup
static private string path = @"ftp://" + ConfigurationManager.AppSettings["FtpServerIP"].ToString() + "/"; //目标路径
static private string ftpip = ConfigurationManager.AppSettings["FtpServerIP"].ToString(); //ftp IP地址
static private string username = ConfigurationManager.AppSettings["FtpUserName"].ToString(); //ftp用户名
static private string password = ConfigurationManager.AppSettings["FtpPassWord"].ToString(); //ftp密码
//获取ftp上面的文件和文件夹
public static string[] GetFileList(string dir)
{
string[] downloadFiles;
StringBuilder result = new StringBuilder();
FtpWebRequest request;
try
{
request = (FtpWebRequest)FtpWebRequest.Create(new Uri(path + dir));
request.UseBinary = true;
request.Credentials = new NetworkCredential(username, password);//设置用户名和密码
request.Method = WebRequestMethods.Ftp.ListDirectory;
request.UseBinary = true;
request.UsePassive = false; //选择主动还是被动模式 , 这句要加上的。
request.KeepAlive = false;//一定要设置此属性，否则一次性下载多个文件的时候，会出现异常。
WebResponse response = request.GetResponse();
StreamReader reader = new StreamReader(response.GetResponseStream());
string line = reader.ReadLine();
while (line != null)
{
result.Append(line);
result.Append("\n");
line = reader.ReadLine();
}
result.Remove(result.ToString().LastIndexOf(''\n''), 1);
reader.Close();
response.Close();
return result.ToString().Split(''\n'');
}
catch (Exception ex)
{
LogHelper.writeErrorLog("获取ftp上面的文件和文件夹：" + ex.Message);
downloadFiles = null;
return downloadFiles;
}
}
/// <summary>
/// 从ftp服务器上获取文件并将内容全部转换成string返回
/// </summary>
/// <param name="fileName"></param>
/// <param name="dir"></param>
/// <returns></returns>
public static string GetFileStr(string fileName, string dir)
{
FtpWebRequest reqFTP;
try
{
reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri(path + dir + "/" + fileName));
reqFTP.Method = WebRequestMethods.Ftp.DownloadFile;
reqFTP.UseBinary = true;
reqFTP.Credentials = new NetworkCredential(username, password);
reqFTP.UsePassive = false; //选择主动还是被动模式 , 这句要加上的。
reqFTP.KeepAlive = false;//一定要设置此属性，否则一次性下载多个文件的时候，会出现异常。
FtpWebResponse response = (FtpWebResponse)reqFTP.GetResponse();
Stream ftpStream = response.GetResponseStream();
StreamReader reader = new StreamReader(ftpStream);
string fileStr = reader.ReadToEnd();
reader.Close();
ftpStream.Close();
response.Close();
return fileStr;
}
catch (Exception ex)
{
LogHelper.writeErrorLog("获取ftp文件并读取内容失败：" + ex.Message);
return null;
}
}
/// <summary>
/// 获取文件大小
/// </summary>
/// <param name="file">ip服务器下的相对路径</param>
/// <returns>文件大小</returns>
public static int GetFileSize(string file)
{
StringBuilder result = new StringBuilder();
FtpWebRequest request;
try
{
request = (FtpWebRequest)FtpWebRequest.Create(new Uri(path + file));
request.UseBinary = true;
request.Credentials = new NetworkCredential(username, password);//设置用户名和密码
request.Method = WebRequestMethods.Ftp.GetFileSize;
int dataLength = (int)request.GetResponse().ContentLength;
return dataLength;
}
catch (Exception ex)
{
Console.WriteLine("获取文件大小出错：" + ex.Message);
return -1;
}
}
/// <summary>
/// 文件上传
/// </summary>
/// <param name="filePath">原路径（绝对路径）包括文件名</param>
/// <param name="objPath">目标文件夹：服务器下的相对路径 不填为根目录</param>
public static void FileUpLoad(string filePath,string objPath="")
{
try
{
string url = path;
if(objPath!="")
url += objPath + "/";
try
{
FtpWebRequest reqFTP = null;
//待上传的文件 （全路径）
try
{
FileInfo fileInfo = new FileInfo(filePath);
using (FileStream fs = fileInfo.OpenRead())
{
long length = fs.Length;
reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri(url + fileInfo.Name));
//设置连接到FTP的帐号密码
reqFTP.Credentials = new NetworkCredential(username, password);
//设置请求完成后是否保持连接
reqFTP.KeepAlive = false;
//指定执行命令
reqFTP.Method = WebRequestMethods.Ftp.UploadFile;
//指定数据传输类型
reqFTP.UseBinary = true;
using (Stream stream = reqFTP.GetRequestStream())
{
//设置缓冲大小
int BufferLength = 5120;
byte[] b = new byte[BufferLength];
int i;
while ((i = fs.Read(b, 0, BufferLength)) > 0)
{
stream.Write(b, 0, i);
}
Console.WriteLine("上传文件成功");
}
}
}
catch (Exception ex)
{
Console.WriteLine("上传文件失败错误为" + ex.Message);
}
finally
{
}
}
catch (Exception ex)
{
Console.WriteLine("上传文件失败错误为" + ex.Message);
}
finally
{
}
}
catch (Exception ex)
{
Console.WriteLine("上传文件失败错误为" + ex.Message);
}
}
/// <summary>
/// 删除文件
/// </summary>
/// <param name="fileName">服务器下的相对路径 包括文件名</param>
public static void DeleteFileName(string fileName)
{
try
{
FileInfo fileInf = new FileInfo(ftpip +""+ fileName);
string uri = path + fileName;
FtpWebRequest reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri(uri));
// 指定数据传输类型
reqFTP.UseBinary = true;
// ftp用户名和密码
reqFTP.Credentials = new NetworkCredential(username, password);
// 默认为true，连接不会被关闭
// 在一个命令之后被执行
reqFTP.KeepAlive = false;
// 指定执行什么命令
reqFTP.Method = WebRequestMethods.Ftp.DeleteFile;
FtpWebResponse response = (FtpWebResponse)reqFTP.GetResponse();
response.Close();
}
catch (Exception ex)
{
Console.WriteLine("删除文件出错：" + ex.Message);
}
}
/// <summary>
/// 新建目录 上一级必须先存在
/// </summary>
/// <param name="dirName">服务器下的相对路径</param>
public static void MakeDir(string dirName)
{
try
{
string uri = path + dirName;
FtpWebRequest reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri(uri));
// 指定数据传输类型
reqFTP.UseBinary = true;
// ftp用户名和密码
reqFTP.Credentials = new NetworkCredential(username, password);
reqFTP.Method = WebRequestMethods.Ftp.MakeDirectory;
FtpWebResponse response = (FtpWebResponse)reqFTP.GetResponse();
response.Close();
}
catch (Exception ex)
{
Console.WriteLine("创建目录出错：" + ex.Message);
}
}
/// <summary>
/// 删除目录 上一级必须先存在
/// </summary>
/// <param name="dirName">服务器下的相对路径</param>
public static void DelDir(string dirName)
{
try
{
string uri = path + dirName;
FtpWebRequest reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri(uri));
// ftp用户名和密码
reqFTP.Credentials = new NetworkCredential(username, password);
reqFTP.Method = WebRequestMethods.Ftp.RemoveDirectory;
FtpWebResponse response = (FtpWebResponse)reqFTP.GetResponse();
response.Close();
}
catch (Exception ex)
{
Console.WriteLine("删除目录出错：" + ex.Message);
}
}
/// <summary>
/// 从ftp服务器上获得文件夹列表
/// </summary>
/// <param name="RequedstPath">服务器下的相对路径</param>
/// <returns></returns>
public static List<string> GetDirctory(string RequedstPath)
{
List<string> strs = new List<string>();
try
{
string uri = path + RequedstPath; //目标路径 path为服务器地址
FtpWebRequest reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri(uri));
// ftp用户名和密码
reqFTP.Credentials = new NetworkCredential(username, password);
reqFTP.Method = WebRequestMethods.Ftp.ListDirectoryDetails;
WebResponse response = reqFTP.GetResponse();
StreamReader reader = new StreamReader(response.GetResponseStream());//中文文件名
string line = reader.ReadLine();
while (line != null)
{
if (line.Contains("<DIR>"))
{
string msg = line.Substring(line.LastIndexOf("<DIR>")+5).Trim();
strs.Add(msg);
}
line = reader.ReadLine();
}
reader.Close();
response.Close();
return strs;
}
catch (Exception ex)
{
Console.WriteLine("获取目录出错：" + ex.Message);
}
return strs;
}
/// <summary>
/// 从ftp服务器上获得文件列表
/// </summary>
/// <param name="RequedstPath">服务器下的相对路径</param>
/// <returns></returns>
public static List<string> GetFile(string RequedstPath)
{
List<string> strs = new List<string>();
try
{
string uri = path + RequedstPath; //目标路径 path为服务器地址
FtpWebRequest reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri(uri));
// ftp用户名和密码
reqFTP.Credentials = new NetworkCredential(username, password);
reqFTP.Method = WebRequestMethods.Ftp.ListDirectoryDetails;
WebResponse response = reqFTP.GetResponse();
StreamReader reader = new StreamReader(response.GetResponseStream());//中文文件名
string line = reader.ReadLine();
while (line != null)
{
if (!line.Contains("<DIR>"))
{
string msg = line.Substring(39).Trim();
strs.Add(msg);
}
line = reader.ReadLine();
}
reader.Close();
response.Close();
return strs;
}
catch (Exception ex)
{
Console.WriteLine("获取文件出错：" + ex.Message);
}
return strs;
}
}
}
C# 文件下载工具类FileDownHelper
using System;
using System.IO;
using System.Threading;
using System.Web;
namespace 落地页测试代码
{
public class FileDownHelper
{
public FileDownHelper()
{ }
public static string FileNameExtension(string FileName)
{
return Path.GetExtension(MapPathFile(FileName));
}
public static string MapPathFile(string FileName)
{
return HttpContext.Current.Server.MapPath(FileName);
}
public static bool FileExists(string FileName)
{
string destFileName = FileName;
if (File.Exists(destFileName))
{
return true;
}
else
{
return false;
}
}
public static void DownLoadold(string FileName, string name)
{
string destFileName = FileName;
if (File.Exists(destFileName))
{
FileInfo fi = new FileInfo(destFileName);
HttpContext.Current.Response.Clear();
HttpContext.Current.Response.ClearHeaders();
HttpContext.Current.Response.Buffer = false;
HttpContext.Current.Response.AppendHeader("Content-Disposition", "attachment;filename=" + HttpUtility.UrlEncode(name, System.Text.Encoding.UTF8));
HttpContext.Current.Response.AppendHeader("Content-Length", fi.Length.ToString());
HttpContext.Current.Response.ContentType = "application/octet-stream";
HttpContext.Current.Response.WriteFile(destFileName);
HttpContext.Current.Response.Flush();
HttpContext.Current.Response.End();
}
}
public static void DownLoad(string FileName)
{
string filePath = MapPathFile(FileName);
long chunkSize = 204800; //指定块大小
byte[] buffer = new byte[chunkSize]; //建立一个200K的缓冲区
long dataToRead = 0; //已读的字节数
FileStream stream = null;
try
{
//打开文件
stream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
dataToRead = stream.Length;
//添加Http头
HttpContext.Current.Response.ContentType = "application/octet-stream";
HttpContext.Current.Response.AddHeader("Content-Disposition", "attachement;filename=" + HttpUtility.UrlEncode(Path.GetFileName(filePath)));
HttpContext.Current.Response.AddHeader("Content-Length", dataToRead.ToString());
while (dataToRead > 0)
{
if (HttpContext.Current.Response.IsClientConnected)
{
int length = stream.Read(buffer, 0, Convert.ToInt32(chunkSize));
HttpContext.Current.Response.OutputStream.Write(buffer, 0, length);
HttpContext.Current.Response.Flush();
HttpContext.Current.Response.Clear();
dataToRead -= length;
}
else
{
dataToRead = -1; //防止client失去连接
}
}
}
catch (Exception ex)
{
HttpContext.Current.Response.Write("Error:" + ex.Message);
}
finally
{
if (stream != null) stream.Close();
HttpContext.Current.Response.Close();
}
}
public static bool ResponseFile(HttpRequest _Request, HttpResponse _Response, string _fileName, string _fullPath, long _speed)
{
try
{
FileStream myFile = new FileStream(_fullPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
BinaryReader br = new BinaryReader(myFile);
try
{
_Response.AddHeader("Accept-Ranges", "bytes");
_Response.Buffer = false;
long fileLength = myFile.Length;
long startBytes = 0;
int pack = 10240; //10K bytes
int sleep = (int)Math.Floor((double)(1000 * pack / _speed)) + 1;
if (_Request.Headers["Range"] != null)
{
_Response.StatusCode = 206;
string[] range = _Request.Headers["Range"].Split(new char[] { ''='', ''-'' });
startBytes = Convert.ToInt64(range[1]);
}
_Response.AddHeader("Content-Length", (fileLength - startBytes).ToString());
if (startBytes != 0)
{
_Response.AddHeader("Content-Range", string.Format(" bytes {0}-{1}/{2}", startBytes, fileLength - 1, fileLength));
}
_Response.AddHeader("Connection", "Keep-Alive");
_Response.ContentType = "application/octet-stream";
_Response.AddHeader("Content-Disposition", "attachment;filename=" + HttpUtility.UrlEncode(_fileName, System.Text.Encoding.UTF8));
br.BaseStream.Seek(startBytes, SeekOrigin.Begin);
int maxCount = (int)Math.Floor((double)((fileLength - startBytes) / pack)) + 1;
for (int i = 0; i < maxCount; i++)
{
if (_Response.IsClientConnected)
{
_Response.BinaryWrite(br.ReadBytes(pack));
Thread.Sleep(sleep);
}
else
{
i = maxCount;
}
}
}
catch
{
return false;
}
finally
{
br.Close();
myFile.Close();
}
}
catch
{
return false;
}
return true;
}
}
}
C#实现自定义FTP操作封装类实例
本文实例讲述了C#实现自定义FTP操作封装类。分享给大家供大家参考。具体如下：
这个C#类封装了FTP的常用操作，包括连接ftp服务器、列表服务器上的目录和文件，从ftp下载文件，上传文件到ftp服务器等等
using System;
using System.Text;
using System.IO;
namespace DotNet.Utilities
{
public class FTPOperater
{
#region 属性
private FTPClient ftp;
/// <summary>
/// 全局FTP访问变量
/// </summary>
public FTPClient Ftp
{
get { return ftp; }
set { ftp = value; }
}
private string _server;
/// <summary>
/// Ftp服务器
/// </summary>
public string Server
{
get { return _server; }
set { _server = value; }
}
private string _User;
/// <summary>
/// Ftp用户
/// </summary>
public string User
{
get { return _User; }
set { _User = value; }
}
private string _Pass;
/// <summary>
/// Ftp密码
/// </summary>
public string Pass
{
get { return _Pass; }
set { _Pass = value; }
}
private string _FolderZJ;
/// <summary>
/// Ftp密码
/// </summary>
public string FolderZJ
{
get { return _FolderZJ; }
set { _FolderZJ = value; }
}
private string _FolderWX;
/// <summary>
/// Ftp密码
/// </summary>
public string FolderWX
{
get { return _FolderWX; }
set { _FolderWX = value; }
}
#endregion
/// <summary>
/// 得到文件列表
/// </summary>
/// <returns></returns>
public string[] GetList(string strPath)
{
if (ftp == null) ftp = this.getFtpClient();
ftp.Connect();
ftp.ChDir(strPath);
return ftp.Dir("*");
}
/// <summary>
/// 下载文件
/// </summary>
/// <param name="ftpFolder">ftp目录</param>
/// <param name="ftpFileName">ftp文件名</param>
/// <param name="localFolder">本地目录</param>
/// <param name="localFileName">本地文件名</param>
public bool GetFile(string ftpFolder,string ftpFileName,string localFolder,string localFileName)
{
try
{
if (ftp == null) ftp = this.getFtpClient();
if (!ftp.Connected)
{
ftp.Connect();
ftp.ChDir(ftpFolder);
}
ftp.Get(ftpFileName,localFolder,localFileName);
return true;
}
catch
{
try
{
ftp.disConnect();
ftp = null;
}
catch { ftp = null; }
return false;
}
}
/// <summary>
/// 修改文件
/// </summary>
/// <param name="ftpFolder">本地目录</param>
/// <param name="ftpFileName">本地文件名temp</param>
/// <param name="localFolder">本地目录</param>
/// <param name="localFileName">本地文件名</param>
public bool AddMSCFile(string ftpFolder,string localFileName,string BscInfo)
{
string sLine = "";
string sResult = "";
string path = "获得应用程序所在的完整的路径";
path = path.Substring(0,path.LastIndexOf("\\"));
try
{
FileStream fsFile = new FileStream(ftpFolder + "\\" + ftpFileName,FileMode.Open);
FileStream fsFileWrite = new FileStream(localFolder + "\\" + localFileName,FileMode.Create);
StreamReader sr = new StreamReader(fsFile);
StreamWriter sw = new StreamWriter(fsFileWrite);
sr.BaseStream.Seek(0,SeekOrigin.Begin);
while (sr.Peek() > -1)
{
sLine = sr.ReadToEnd();
}
string[] arStr = sLine.Split(new string[] { "\n" },StringSplitOptions.RemoveEmptyEntries);
for (int i = 0; i < arStr.Length - 1; i++)
{
sResult += BscInfo + "," + arStr[i].Trim() + "\n";
}
sr.Close();
byte[] connect = new UTF8Encoding(true).GetBytes(sResult);
fsFileWrite.Write(connect,connect.Length);
fsFileWrite.Flush();
sw.Close();
fsFile.Close();
fsFileWrite.Close();
return true;
}
catch (Exception e)
{
return false;
}
}
/// <summary>
/// 删除文件
/// </summary>
/// <param name="ftpFolder">ftp目录</param>
/// <param name="ftpFileName">ftp文件名</param>
public bool DelFile(string ftpFolder,string ftpFileName)
{
try
{
if (ftp == null) ftp = this.getFtpClient();
if (!ftp.Connected)
{
ftp.Connect();
ftp.ChDir(ftpFolder);
}
ftp.Delete(ftpFileName);
return true;
}
catch
{
return false;
}
}
/// <summary>
/// 上传文件
/// </summary>
/// <param name="ftpFolder">ftp目录</param>
/// <param name="ftpFileName">ftp文件名</param>
public bool PutFile(string ftpFolder,string ftpFileName)
{
try
{
if (ftp == null) ftp = this.getFtpClient();
if (!ftp.Connected)
{
ftp.Connect();
ftp.ChDir(ftpFolder);
}
ftp.Put(ftpFileName);
return true;
}
catch
{
return false;
}
}
/// <summary>
/// 下载文件
/// </summary>
/// <param name="ftpFolder">ftp目录</param>
/// <param name="ftpFileName">ftp文件名</param>
/// <param name="localFolder">本地目录</param>
/// <param name="localFileName">本地文件名</param>
public bool GetFileNoBinary(string ftpFolder,string localFileName)
{
try
{
if (ftp == null) ftp = this.getFtpClient();
if (!ftp.Connected)
{
ftp.Connect();
ftp.ChDir(ftpFolder);
}
ftp.GetNoBinary(ftpFileName,localFileName);
return true;
}
catch
{
try
{
ftp.disConnect();
ftp = null;
}
catch
{
ftp = null;
}
return false;
}
}
/// <summary>
/// 得到FTP上文件信息
/// </summary>
/// <param name="ftpFolder">FTP目录</param>
/// <param name="ftpFileName">ftp文件名</param>
public string GetFileInfo(string ftpFolder,string ftpFileName)
{
string strResult = "";
try
{
if (ftp == null) ftp = this.getFtpClient();
if (ftp.Connected) ftp.disConnect();
ftp.Connect();
ftp.ChDir(ftpFolder);
strResult = ftp.GetFileInfo(ftpFileName);
return strResult;
}
catch
{
return "";
}
}
/// <summary>
/// 测试FTP服务器是否可登陆
/// </summary>
public bool CanConnect()
{
if (ftp == null) ftp = this.getFtpClient();
try
{
ftp.Connect();
ftp.disConnect();
return true;
}
catch
{
return false;
}
}
/// <summary>
/// 得到FTP上文件信息
/// </summary>
/// <param name="ftpFolder">FTP目录</param>
/// <param name="ftpFileName">ftp文件名</param>
public string GetFileInfoConnected(string ftpFolder,string ftpFileName)
{
string strResult = "";
try
{
if (ftp == null) ftp = this.getFtpClient();
if (!ftp.Connected)
{
ftp.Connect();
ftp.ChDir(ftpFolder);
}
strResult = ftp.GetFileInfo(ftpFileName);
return strResult;
}
catch
{
return "";
}
}
/// <summary>
/// 得到文件列表
/// </summary>
/// <param name="ftpFolder">FTP目录</param>
/// <returns>FTP通配符号</returns>
public string[] GetFileList(string ftpFolder,string strMask)
{
string[] strResult;
try
{
if (ftp == null) ftp = this.getFtpClient();
if (!ftp.Connected)
{
ftp.Connect();
ftp.ChDir(ftpFolder);
}
strResult = ftp.Dir(strMask);
return strResult;
}
catch
{
return null;
}
}
/// <summary>
///得到FTP传输对象
/// </summary>
public FTPClient getFtpClient()
{
FTPClient ft = new FTPClient();
ft.RemoteHost = this.Server;
ft.RemoteUser = this.User;
ft.RemotePass = this.Pass;
return ft;
}
}
}
希望本文所述对大家的C#程序设计有所帮助。
今天关于【C#】工具类-FTP操作封装类FTPHelper和ftp封装的五个步骤的讲解已经结束，谢谢您的阅读，如果想了解更多关于asp.net 操作FTP作为数据中转-Helper.cs、C# FtpHelper实现ftp服务器文件读写操作、C# 文件下载工具类FileDownHelper、C#实现自定义FTP操作封装类实例的相关知识，请在本站搜索。
本文标签：
