【转】C#下带进度条的FTP上传类

ienki

　　该类转自：http://blog.iyunv.com/byshome/article/details/5801991，稍作修改



using System;
using System.Net;
using System.Net.Sockets;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Globalization;
using System.Text.RegularExpressions;
namespace FTP
{
public class FTPHelper : IDisposable
{
#region 声明事件
///
/// 正在下载文件
///
public event FTPSendEventHandler FileDownloading;
private delegate void OnFileDownloadingDelegate(FTPConnect ftpConnect, long lTotalBytes, long lBytesTransfered);
///
/// 正在下载文件封装模式
///
private void OnFileDownloading(FTPConnect ftpConnect, long lTotalBytes, long lBytesTransfered)
{
if (this.FileDownloading != null)
{
if (lBytesTransfered > lTotalBytes)
lBytesTransfered = lTotalBytes;
System.ComponentModel.ISynchronizeInvoke aSynch = this.FileDownloading.Target as System.ComponentModel.ISynchronizeInvoke;
if (aSynch != null && aSynch.InvokeRequired)
aSynch.Invoke(new OnFileDownloadingDelegate(OnFileDownloading), new object[] { ftpConnect, lTotalBytes, lBytesTransfered });
else
this.FileDownloading(ftpConnect, new FTPSendEventArgs(lTotalBytes, lBytesTransfered));
}
}
///
/// 文件下载完成
///
public event EventHandler FileDownloadCompleted;
private delegate void OnFileDownloadCompletedDelegate(FTPConnect ftpConnect);
///
/// 文件下载完成封装模式
///
private void OnFileDownloadCompleted(FTPConnect ftpConnect)
{
if (this.FileDownloadCompleted != null)
{
System.ComponentModel.ISynchronizeInvoke aSynch = this.FileDownloadCompleted.Target as System.ComponentModel.ISynchronizeInvoke;
if (aSynch != null && aSynch.InvokeRequired)
aSynch.Invoke(new OnFileDownloadCompletedDelegate(OnFileDownloadCompleted), new object[] { ftpConnect });
else
this.FileDownloadCompleted(ftpConnect, new EventArgs());
}
}
///
/// 取消正在下载的文件
///
public event EventHandler FileDownloadCanceled;
private delegate void OnFileDownloadCanceledDelegate(FTPConnect ftpConnect);
///
/// 取消正在下载的文件封装模式
///
private void OnFileDownloadCanceled(FTPConnect ftpConnect)
{
if (this.FileDownloadCanceled != null)
{
System.ComponentModel.ISynchronizeInvoke aSynch = this.FileDownloadCanceled.Target as System.ComponentModel.ISynchronizeInvoke;
if (aSynch != null && aSynch.InvokeRequired)
aSynch.Invoke(new OnFileDownloadCanceledDelegate(OnFileDownloadCanceled), new object[] { ftpConnect });
else
this.FileDownloadCanceled(ftpConnect, new EventArgs());
}
}
///
/// 正在上传文件
///
public event FTPSendEventHandler FileUploading;
private delegate void OnFileUploadingDelegate(FTPConnect ftpConnect, long lTotalBytes, long lBytesTransfered);
///
/// 正在下载事件封装模式
///
///
///
private void OnFileUploading(FTPConnect ftpConnect, long lTotalBytes, long lBytesTransfered)
{
if (this.FileUploading != null)
{
if (lBytesTransfered > lTotalBytes)
lBytesTransfered = lTotalBytes;
System.ComponentModel.ISynchronizeInvoke aSynch = this.FileUploading.Target as System.ComponentModel.ISynchronizeInvoke;
if (aSynch != null && aSynch.InvokeRequired)
aSynch.Invoke(new OnFileUploadingDelegate(OnFileUploading), new object[] { ftpConnect, lTotalBytes, lBytesTransfered });
else
this.FileUploading(ftpConnect, new FTPSendEventArgs(lTotalBytes, lBytesTransfered));
}
}
///
/// 文件上传完成
///
public event EventHandler FileUploadCompleted;
private delegate void OnFileUploadCompletedDelegate(FTPConnect ftpConnect);
private void OnFileUploadCompleted(FTPConnect ftpConnect)
{
if (this.FileUploadCompleted != null)
{
System.ComponentModel.ISynchronizeInvoke aSynch = this.FileUploadCompleted.Target as System.ComponentModel.ISynchronizeInvoke;
if (aSynch != null && aSynch.InvokeRequired)
aSynch.Invoke(new OnFileUploadCompletedDelegate(OnFileUploadCompleted), new object[] { ftpConnect });
else
this.FileUploadCompleted(ftpConnect, new EventArgs());
}
}
///
/// 取消了上传文件
///
public event EventHandler FileUploadCanceled;
private delegate void OnFileUploadCanceledDelegate(FTPConnect ftpConnect);
private void OnFileUploadCanceled(FTPConnect ftpConnect)
{
if (this.FileUploadCanceled != null)
{
System.ComponentModel.ISynchronizeInvoke aSynch = this.FileUploadCanceled.Target as System.ComponentModel.ISynchronizeInvoke;
if (aSynch != null && aSynch.InvokeRequired)
aSynch.Invoke(new OnFileUploadCanceledDelegate(OnFileUploadCanceled), new object[] { ftpConnect });
else
this.FileUploadCanceled(ftpConnect, new EventArgs());
}
}
///
/// 传输过程发生错误事件
///
public event FTPErrorEventHandler FtpError;
private delegate void OnFtpErrorDelegate(FTPConnect ftpConnect, Exception error);
public void OnFtpError(FTPConnect ftpConnect, Exception error)
{
if (this.FtpError != null)
{
System.ComponentModel.ISynchronizeInvoke aSynch = this.FtpError.Target as System.ComponentModel.ISynchronizeInvoke;
if (aSynch != null && aSynch.InvokeRequired)
aSynch.Invoke(new OnFtpErrorDelegate(OnFtpError), new object[] { ftpConnect, error });
else
this.FtpError(ftpConnect, new FTPErrorEventArgs(error));
}
}
#endregion
#region FTPUrl结构
public class FTPUrl
{
private string m_Url = String.Empty;
private string m_RemoteHost = String.Empty;
private IPAddress m_RemoteHostIP = IPAddress.None;
private int m_RemotePort = 21;
private string m_UserName = String.Empty;
private string m_Password = String.Empty;
private string m_SubUrl = String.Empty;
public FTPUrl()
{ }
public FTPUrl(string url)
{
this.Url = url;
}
///
/// FTP的全地址
///
public string Url
{
get { return this.m_Url; }
set
{
if (value.IndexOf("@") < 0)
throw (new Exception("FTP地址路径不合法！格式应为ftp://用户名:密码@地址[:端口]/"));
string strSubUrl = "";
string strRemoteHostAndPort = value.Substring(value.IndexOf("@") + 1);
if (strRemoteHostAndPort.IndexOf("/") > 0)
{
strSubUrl = strRemoteHostAndPort.Substring(strRemoteHostAndPort.IndexOf("/"));
strRemoteHostAndPort = strRemoteHostAndPort.Substring(0, strRemoteHostAndPort.IndexOf("/"));
}
string strRemoteHost = strRemoteHostAndPort;
int iRemotePort = 21;
if (strRemoteHostAndPort.IndexOf(":") > 0)
{
strRemoteHost = strRemoteHostAndPort.Substring(0, strRemoteHostAndPort.IndexOf(":"));
string strRemotePort = strRemoteHostAndPort.Substring(strRemoteHostAndPort.IndexOf(":") + 1);
if (!int.TryParse(strRemotePort, out iRemotePort))
iRemotePort = 21;
}
string strUserNameAndPassword = value.Substring(0, value.IndexOf("@")).Trim();
if (strUserNameAndPassword.ToLower().StartsWith("ftp://"))
strUserNameAndPassword = strUserNameAndPassword.Substring(6).Trim();
if (strUserNameAndPassword == string.Empty || strUserNameAndPassword.IndexOf(":") < 0)
throw (new Exception("FTP地址路径不合法！格式应为ftp://用户名:密码@地址[:端口]/"));
string strUserName = strUserNameAndPassword.Substring(0, strUserNameAndPassword.IndexOf(":"));
string strPassword = strUserNameAndPassword.Substring(strUserNameAndPassword.IndexOf(":") + 1);
IPAddress[] ips = Dns.GetHostAddresses(strRemoteHost);
if (ips.Length == 0)
throw (new Exception("FTP地址路径中主机地址无效！"));
strSubUrl = strSubUrl.Replace("//", "/");
this.m_RemoteHostIP = ips[0];
this.m_RemoteHost = strRemoteHost;
this.m_RemotePort = iRemotePort;
this.m_UserName = strUserName;
this.m_Password = strPassword;
this.m_SubUrl = strSubUrl;
this.m_Url = value;
}
}
///
/// 主机地址
///
public string RemoteHost
{
get { return this.m_RemoteHost; }
}
///
/// 主机IP
///
public IPAddress RemoteHostIP
{
get { return this.m_RemoteHostIP; }
}
///
/// 主机端口
///
public int RemotePort
{
get { return this.m_RemotePort; }
}
public string UserName
{
get { return this.m_UserName; }
}
public string Password
{
get { return this.m_Password; }
}
public string SubUrl
{
get { return this.m_SubUrl; }
}
}
#endregion
#region 传输模式
///
/// 传输模式:二进制类型、ASCII类型
///
public enum TransferType
{
///
/// Binary
///
Binary,
///
/// ASCII
///
ASCII
};
#endregion
#region 存贮FTP的连接结构类
public class FTPConnect
{
#region 私有字段
///
/// 数据传送套接字列表
///
private List m_DataSocketList;
private string m_ID;
///
/// 唯一ID
///
public string ID
{
get { return this.m_ID; }
}
private object m_Tag = null;
///
/// 扩展标记
///
public object Tag
{
get { return this.m_Tag; }
set { this.m_Tag = value; }
}
private bool m_DataTransmitting = false;
///
/// 数据正在传输 标记
///
public bool DataTransmitting
{
get { return this.m_DataTransmitting; }
set { this.m_DataTransmitting = value; }
}
private Socket m_SocketControl;
///
/// FTPUrl
///
private FTPUrl m_FTPUrl;
///
/// 是否已经连接
///
private bool m_IsConnected;
private Encoding m_EncodeType = Encoding.Default;
///
/// 编码方式
///
public Encoding EncodeType
{
get { return this.m_EncodeType; }
set { this.m_EncodeType = value; }
}
///
/// 接收和发送数据的缓冲区
///
private static int BLOCK_SIZE = 512;
///
/// 缓冲区大小
///
private Byte[] m_Buffer;
public Byte[] Buffer
{
get { return this.m_Buffer; }
set { this.m_Buffer = value; }
}
private string m_Message;
///
/// 当前的消息
///
public string Message
{
get { return this.m_Message; }
set { this.m_Message = value; }
}
private string m_ReplyString;
///
/// 应答字符串
///
public string ReplyString
{
get { return this.m_ReplyString; }
set { this.m_ReplyString = value; }
}
private int m_ReplyCode;
///
/// 应答代码
///
public int ReplyCode
{
get { return this.m_ReplyCode; }
set { this.m_ReplyCode = value; }
}
///
/// 传输模式
///
private TransferType trType;
#endregion
public FTPConnect()
{
this.m_ID = System.Guid.NewGuid().ToString();
this.m_DataSocketList = new List();
this.m_Buffer = new Byte[BLOCK_SIZE];
}
public FTPConnect(FTPUrl ftpUrl)
{
this.m_ID = System.Guid.NewGuid().ToString();
this.m_DataSocketList = new List();
this.m_Buffer = new Byte[BLOCK_SIZE];
this.FTPUrl = ftpUrl;
}
public FTPConnect(FTPUrl ftpUrl, string ftpId)
{
if (String.IsNullOrEmpty(ftpId))
ftpId = System.Guid.NewGuid().ToString();
this.m_ID = ftpId;
this.m_DataSocketList = new List();
this.m_Buffer = new Byte[BLOCK_SIZE];
this.FTPUrl = ftpUrl;
}
#region 公共字段
///
/// 套接字连接
///
public Socket SocketControl
{
get { return this.m_SocketControl; }
set { this.m_SocketControl = value; }
}
///
/// 对应的URL
///
public FTPUrl FTPUrl
{
get { return this.m_FTPUrl; }
set { this.m_FTPUrl = value; }
}
///
/// 是否已经连接
///
public bool IsConnected
{
get { return this.m_IsConnected; }
set { this.m_IsConnected = value; }
}
#endregion
#region 公共方法
#region 取消传送数据
public void CancelDataTransmit()
{
this.m_DataTransmitting = false;
}
#endregion
#region 发送命令
///
/// 发送命令并获取应答码和最后一行应答字符串
///
/// 命令
public void SendCommand(string strCommand)
{
if (this.m_SocketControl == null)
throw (new Exception("请先连接服务器再进行操作！"));
Byte[] cmdBytes = m_EncodeType.GetBytes((strCommand + "\r\n").ToCharArray());
this.m_SocketControl.Send(cmdBytes, cmdBytes.Length, 0);
this.ReadReply();
}
#endregion
#region 读取最后一行的消息
///
/// 读取Socket返回的所有字符串
///
/// 包含应答码的字符串行
private string ReadLine()
{
if (this.m_SocketControl == null)
throw (new Exception("请先连接服务器再进行操作！"));
while (true)
{
int iBytes = this.m_SocketControl.Receive(m_Buffer, m_Buffer.Length, 0);
m_Message += m_EncodeType.GetString(m_Buffer, 0, iBytes);
if (iBytes < m_Buffer.Length)
{
break;
}
}
char[] seperator = { '\n' };
string[] mess = m_Message.Split(seperator);
if (m_Message.Length > 2)
{
m_Message = mess[mess.Length - 2];
//seperator[0]是10,换行符是由13和0组成的,分隔后10后面虽没有字符串,
//但也会分配为空字符串给后面(也是最后一个)字符串数组,
//所以最后一个mess是没用的空字符串
//但为什么不直接取mess[0],因为只有最后一行字符串应答码与信息之间有空格
}
else
{
m_Message = mess[0];
}
if (!m_Message.Substring(3, 1).Equals(" "))//返回字符串正确的是以应答码(如220开头,后面接一空格,再接问候字符串)
{
return this.ReadLine();
}
return m_Message;
}
#endregion
#region 读取应答代码
///
/// 将一行应答字符串记录在strReply和strMsg
/// 应答码记录在iReplyCode
///
public void ReadReply()
{
this.m_Message = "";
this.m_ReplyString = this.ReadLine();
this.m_ReplyCode = Int32.Parse(m_ReplyString.Substring(0, 3));
}
#endregion
#region 断开连接
///
/// 关闭连接
///
public void DisConnect()
{
this.m_DataTransmitting = false;
while (this.m_DataSocketList.Count > 0)
{
Socket socket = this.m_DataSocketList[0];
if (socket != null && socket.Connected)
socket.Close();
this.m_DataSocketList.RemoveAt(0);
}
if (this.m_IsConnected && this.m_SocketControl != null)
this.SendCommand("QUIT");
this.CloseSocketConnect();
this.m_Buffer = null;
}
///
/// 关闭socket连接(用于登录以前)
///
private void CloseSocketConnect()
{
if (this.m_SocketControl != null && this.m_SocketControl.Connected)
{
this.m_SocketControl.Close();
this.m_SocketControl = null;
}
this.m_IsConnected = false;
}
#endregion
#region 连接服务器
public void Connect()
{
this.DisConnect();//先断开现有连接
this.m_Buffer = new byte[BLOCK_SIZE];
this.m_SocketControl = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPEndPoint ep = new IPEndPoint(this.m_FTPUrl.RemoteHostIP, this.m_FTPUrl.RemotePort);
try
{
this.m_SocketControl.Connect(ep);
}
catch (Exception)
{
throw new IOException(String.Format("无法连接到远程服务器{0}！", this.m_FTPUrl.RemoteHost));
}
// 获取应答码
this.ReadReply();
if (m_ReplyCode != 220)
{
this.DisConnect();
throw new IOException(m_ReplyString.Substring(4));
}
// 登陆
this.SendCommand("USER " + this.m_FTPUrl.UserName);
if (!(m_ReplyCode == 331 || m_ReplyCode == 230))
{
this.CloseSocketConnect();//关闭连接
throw new IOException(m_ReplyString.Substring(4));
}
if (m_ReplyCode != 230)
{
this.SendCommand("PASS " + this.m_FTPUrl.Password);
if (!(m_ReplyCode == 230 || m_ReplyCode == 202))
{
this.CloseSocketConnect();//关闭连接
throw new IOException(m_ReplyString.Substring(4));
}
}
this.m_IsConnected = true;
}
#endregion
#region 改变目录
///
/// 改变目录
///
/// 新的工作目录名
public void ChangeDir(string dirName)
{
if (!this.m_IsConnected)
throw (new Exception("请先连接服务器然后再进行CWD操作！"));
if (dirName.Equals(".") || dirName.Equals(""))
return;
this.SendCommand("CWD " + dirName);
if (m_ReplyCode != 250)
throw new IOException(m_ReplyString.Substring(4));
}
#endregion
#region 传输模式
///
/// 设置传输模式
///
/// 传输模式
public void SetTransferType(TransferType ttType)
{
if (ttType == TransferType.Binary)
{
this.SendCommand("TYPE I");//binary类型传输
}
else
{
this.SendCommand("TYPE A");//ASCII类型传输
}
if (m_ReplyCode != 200)
{
throw new IOException(m_ReplyString.Substring(4));
}
else
{
trType = ttType;
}
}
///
/// 获得传输模式
///
/// 传输模式
public TransferType GetTransferType()
{
return trType;
}
#endregion
#region 建立进行数据连接的socket
///
/// 建立进行数据连接的socket
///
/// 数据连接socket
public Socket CreateDataSocket()
{
this.SendCommand("PASV");
if (this.m_ReplyCode != 227)
throw new IOException(this.m_ReplyString.Substring(4));
int index1 = this.m_ReplyString.IndexOf('(');
int index2 = this.m_ReplyString.IndexOf(')');
string ipData = this.m_ReplyString.Substring(index1 + 1, index2 - index1 - 1);
int[] parts = new int[6];
int len = ipData.Length;
int partCount = 0;
string buf = "";
for (int i = 0; i < len && partCount = 0)
strDirName = strDirName.Substring(0, strDirName.LastIndexOf("/"));
ftpConnect.ChangeDir(strDirName);
ftpConnect.SendCommand("SIZE " + Path.GetFileName(ftpUrl.SubUrl));
long lFileSize = 0;
if (ftpConnect.ReplyCode == 213)
lFileSize = Int64.Parse(ftpConnect.ReplyString.Substring(4));
else
throw new IOException(ftpConnect.ReplyString.Substring(4));
return lFileSize;
}
catch (Exception ex)
{
throw (ex);
}
finally
{
if (ftpConnect != null)
ftpConnect.DisConnect();
}
}
#endregion
#region 得到文件大小
///
/// 得到文件大小
///
/// 目标文件，包含用户名与密码。如：ftp://username:password@127.0.0.1/1.txt
/// 用户名
/// 密码
///
public DateTime GetDateTimestamp(string fileUrl)
{
FTPUrl ftpUrl = null;
FTPConnect ftpConnect = null;
try
{
ftpUrl = new FTPUrl(fileUrl);
ftpConnect = new FTPConnect(ftpUrl);
ftpConnect.Connect();
string strDirName = ftpUrl.SubUrl;
if (strDirName.IndexOf("/") >= 0)
strDirName = strDirName.Substring(0, strDirName.LastIndexOf("/"));
ftpConnect.ChangeDir(strDirName);
ftpConnect.SendCommand("MDTM " + Path.GetFileName(ftpUrl.SubUrl));
if (ftpConnect.ReplyCode == 213)
{
string strDateTime = ftpConnect.ReplyString.Substring(4);
int iYear = 0, iMonth = 0, iDay = 0, iHour = 0, iMinute = 0, iSecond = 0;
if (strDateTime.Length >= 4)
int.TryParse(strDateTime.Substring(0, 4), out iYear);
if (strDateTime.Length >= 6)
int.TryParse(strDateTime.Substring(4, 2), out iMonth);
if (strDateTime.Length >= 8)
int.TryParse(strDateTime.Substring(6, 2), out iDay);
if (strDateTime.Length >= 10)
int.TryParse(strDateTime.Substring(8, 2), out iHour);
if (strDateTime.Length >= 12)
int.TryParse(strDateTime.Substring(10, 2), out iMinute);
if (strDateTime.Length >= 14)
int.TryParse(strDateTime.Substring(12, 2), out iSecond);
return new DateTime(iYear, iMonth, iDay, iHour, iMinute, iSecond).ToLocalTime();
}
else
throw new IOException(ftpConnect.ReplyString.Substring(4));
}
catch (Exception ex)
{
throw (ex);
}
finally
{
if (ftpConnect != null)
ftpConnect.DisConnect();
}
}
#endregion
#region 删除指定的文件
///
/// 删除指定的文件
///
/// 待删除文件名
public void DeleteFile(string fileUrl)
{
FTPUrl ftpUrl = null;
FTPConnect ftpConnect = null;
try
{
ftpUrl = new FTPUrl(fileUrl);
ftpConnect = new FTPConnect(ftpUrl);
ftpConnect.Connect();
string strDirName = ftpUrl.SubUrl;
if (strDirName.IndexOf("/") >= 0)
strDirName = strDirName.Substring(0, strDirName.LastIndexOf("/"));
ftpConnect.ChangeDir(strDirName);
ftpConnect.SendCommand("DELE " + Path.GetFileName(ftpUrl.SubUrl));
if (ftpConnect.ReplyCode != 250)
throw (new Exception(ftpConnect.ReplyString.Substring(4)));
}
catch (Exception ex)
{
throw (ex);
}
finally
{
if (ftpConnect != null)
ftpConnect.DisConnect();
}
}
#endregion
#region 重命名
///
/// 重命名(如果新文件名与已有文件重名,将覆盖已有文件)
///
/// 旧文件名
/// 新文件名
public void Rename(string originalUrl, string newName)
{
FTPUrl ftpUrl = null;
FTPConnect ftpConnect = null;
try
{
ftpUrl = new FTPUrl(originalUrl);
ftpConnect = new FTPConnect(ftpUrl);
ftpConnect.Connect();
string strDirName = ftpUrl.SubUrl;
if (strDirName.IndexOf("/") >= 0)
strDirName = strDirName.Substring(0, strDirName.LastIndexOf("/"));
ftpConnect.ChangeDir(strDirName);
ftpConnect.SendCommand("RNFR " + Path.GetFileName(ftpUrl.SubUrl));
if (ftpConnect.ReplyCode != 350)
throw (new Exception(ftpConnect.ReplyString.Substring(4)));
ftpConnect.SendCommand("RNTO " + newName);
if (ftpConnect.ReplyCode != 250)
throw (new Exception(ftpConnect.ReplyString.Substring(4)));
}
catch (Exception ex)
{
throw (ex);
}
finally
{
if (ftpConnect != null)
ftpConnect.DisConnect();
}
}
#endregion
#region 创建文件夹
public void MakeDirectory(string dirUrl)
{
FTPUrl ftpUrl = null;
FTPConnect ftpConnect = null;
int iCharIndex = 0;
string strDirUrl, strDirUrlTemp;
try
{
ftpUrl = new FTPUrl(dirUrl);
ftpConnect = new FTPConnect(ftpUrl);
ftpConnect.Connect();
strDirUrl = ftpUrl.SubUrl;
while (true && strDirUrl.Trim() != "")
{
iCharIndex = strDirUrl.IndexOf("/", iCharIndex) + 1;
if (iCharIndex == 0)
strDirUrlTemp = strDirUrl;
else
strDirUrlTemp = strDirUrl.Substring(0, iCharIndex);
if (strDirUrlTemp == "")
continue;
ftpConnect.SendCommand("MKD " + strDirUrlTemp);
if (ftpConnect.ReplyCode != 257 && ftpConnect.ReplyCode != 550)
throw new IOException(ftpConnect.ReplyString.Substring(4));
if (strDirUrlTemp == strDirUrl)
break;
}
}
catch (Exception ex)
{
throw (ex);
}
finally
{
if (ftpConnect != null)
ftpConnect.DisConnect();
}
}
#endregion
#region 删除目录
///
/// 删除目录
///
/// 目录名
public void RemoveDirectory(string dirUrl)
{
FTPUrl ftpUrl = null;
FTPConnect ftpConnect = null;
try
{
ftpUrl = new FTPUrl(dirUrl);
ftpConnect = new FTPConnect(ftpUrl);
ftpConnect.Connect();
string strDirPath = ftpUrl.SubUrl;
string strDirName = ftpUrl.SubUrl;
if (strDirPath.IndexOf("/") >= 0)
{
strDirPath = strDirPath.Substring(0, strDirPath.LastIndexOf("/"));
strDirName = strDirPath.Substring(strDirPath.LastIndexOf("/") + 1);
}
ftpConnect.ChangeDir(strDirPath);
ftpConnect.SendCommand("RMD " + strDirName);
if (ftpConnect.ReplyCode != 250)
throw (new Exception(ftpConnect.ReplyString.Substring(4)));
}
catch (Exception ex)
{
throw (ex);
}
finally
{
if (ftpConnect != null)
ftpConnect.DisConnect();
}
}
#endregion
#region 得到简单的文件列表
public string[] ListDirectoryFile(string listUrl)
{
FTPUrl ftpUrl = null;
FTPConnect ftpConnect = null;
Socket socketData = null;
try
{
ftpUrl = new FTPUrl(listUrl);
ftpConnect = new FTPConnect(ftpUrl);
ftpConnect.Connect();
string strDirPath = ftpUrl.SubUrl;
if (strDirPath.IndexOf("/") >= 0)
strDirPath = strDirPath.Substring(0, strDirPath.LastIndexOf("/"));
ftpConnect.ChangeDir(strDirPath);
socketData = ftpConnect.CreateDataSocket();
ftpConnect.SendCommand("NLST");
if (ftpConnect.ReplyCode != 150 && ftpConnect.ReplyCode != 125)
throw new IOException(ftpConnect.ReplyString.Substring(4));
//获得结果
ftpConnect.Message = "";
while (true)
{
int iBytes = socketData.Receive(ftpConnect.Buffer, ftpConnect.Buffer.Length, 0);
ftpConnect.Message += ftpConnect.EncodeType.GetString(ftpConnect.Buffer, 0, iBytes);
if (iBytes < ftpConnect.Buffer.Length)
break;
}
ftpConnect.Message = ftpConnect.Message.Replace('\r', ' ');
char[] seperator = { '\n' };
string[] strsFileList = ftpConnect.Message.Split(seperator);
socketData.Close();//数据socket关闭时也会有返回码
socketData = null;
if (ftpConnect.ReplyCode != 226)
{
ftpConnect.ReadReply();
if (ftpConnect.ReplyCode != 226)
throw new IOException(ftpConnect.ReplyString.Substring(4));
}
return strsFileList;
}
catch (Exception ex)
{
throw (ex);
}
finally
{
if (socketData != null && socketData.Connected)
socketData.Close();
socketData = null;
if (ftpConnect != null)
ftpConnect.DisConnect();
}
}
//获取当前目录下的目录
public List ListDirectory(string listUrl)
{
List strsFileList = new List();
List files = ListDirectoryDetails(listUrl);
foreach (FileStruct fs in files)
{
if (fs.IsDirectory)
{
strsFileList.Add(fs.Name);
}
}
return strsFileList;
}
#endregion
#region 得到详细的文件列表
public List ListDirectoryDetails(string listUrl)
{
FTPUrl ftpUrl = null;
FTPConnect ftpConnect = null;
Socket socketData = null;
try
{
ftpUrl = new FTPUrl(listUrl);
ftpConnect = new FTPConnect(ftpUrl);
ftpConnect.Connect();
string strDirPath = ftpUrl.SubUrl;
if (strDirPath.IndexOf("/") >= 0)
strDirPath = strDirPath.Substring(0, strDirPath.LastIndexOf("/"));
ftpConnect.ChangeDir(strDirPath);
socketData = ftpConnect.CreateDataSocket();
ftpConnect.SendCommand("LIST");
if (ftpConnect.ReplyCode != 150 && ftpConnect.ReplyCode != 125)
throw new IOException(ftpConnect.ReplyString.Substring(4));
//获得结果
ftpConnect.Message = "";
while (true)
{
int iBytes = socketData.Receive(ftpConnect.Buffer, ftpConnect.Buffer.Length, 0);
ftpConnect.Message += ftpConnect.EncodeType.GetString(ftpConnect.Buffer, 0, iBytes);
if (iBytes < ftpConnect.Buffer.Length)
break;
}
if (ftpConnect.Message.StartsWith("t"))
ftpConnect.Message = ftpConnect.Message.Substring(ftpConnect.Message.IndexOf("\r\n") + 2);
return this.GetList(ftpConnect.Message);
}
catch (Exception ex)
{
throw (ex);
}
finally
{
if (socketData != null && socketData.Connected)
socketData.Close();
socketData = null;
if (ftpConnect != null)
ftpConnect.DisConnect();
}
}
#region 用于得到文件列表的方法
///
/// 文件列表类型枚举
///
private enum FileListStyle
{
///
/// Unix系统类型
///
UnixStyle,
///
/// Windows系统类型
///
WindowsStyle,
///
/// 未知类型
///
Unknown
}
///
/// 列出FTP服务器上面当前目录的所有文件
///
/// 查看目标目录
/// 返回文件信息列表
public List ListFiles(string listUrl)
{
List listFile = null;
try
{
List listAll = this.ListDirectoryDetails(listUrl);
listFile = new List();
foreach (FileStruct file in listAll)
{
if (!file.IsDirectory)
{
listFile.Add(file);
}
}
}
catch (Exception ex)
{
throw ex;
}
return listFile;
}
///
/// 列出FTP服务器上面当前目录的所有的目录
///
/// 查看目标目录
/// 返回目录信息列表
public List ListDirectories(string listUrl)
{
List listAll = this.ListDirectoryDetails(listUrl);
List listDirectory = new List();
foreach (FileStruct file in listAll)
{
if (file.IsDirectory)
{
listDirectory.Add(file);
}
}
return listDirectory;
}
///
/// 获得文件和目录列表
///
/// FTP返回的列表字符信息
private List GetList(string datastring)
{
List myListArray = new List();
string[] dataRecords = datastring.Split('\n');
FileListStyle _directoryListStyle = GuessFileListStyle(dataRecords);
foreach (string s in dataRecords)
{
if (_directoryListStyle != FileListStyle.Unknown && s != "")
{
FileStruct f = new FileStruct();
f.Name = "..";
switch (_directoryListStyle)
{
case FileListStyle.UnixStyle:
f = ParseFileStructFromUnixStyleRecord(s);
break;
case FileListStyle.WindowsStyle:
f = ParseFileStructFromWindowsStyleRecord(s);
break;
}
if (!(f.Name == "." || f.Name == ".."))
{
myListArray.Add(f);
}
}
}
return myListArray;
}
///
/// 从Windows格式中返回文件信息
///
/// 文件信息
private FileStruct ParseFileStructFromWindowsStyleRecord(string Record)
{
FileStruct f = new FileStruct();
string processstr = Record.Trim();
string dateStr = processstr.Substring(0, 8);
processstr = (processstr.Substring(8, processstr.Length - 8)).Trim();
string timeStr = processstr.Substring(0, 7);
processstr = (processstr.Substring(7, processstr.Length - 7)).Trim();
DateTimeFormatInfo myDTFI = new CultureInfo("en-US", false).DateTimeFormat;
myDTFI.ShortTimePattern = "t";
f.CreateTime = DateTime.Parse(dateStr + " " + timeStr, myDTFI);
if (processstr.Substring(0, 5) == "")
{
f.IsDirectory = true;
processstr = (processstr.Substring(5, processstr.Length - 5)).Trim();
}
else
{
//string[] strs = processstr.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);   // true);
//processstr = strs[1];
processstr = processstr.Substring(processstr.IndexOf(' ') + 1);
f.IsDirectory = false;
}
f.Name = processstr;
return f;
}
///
/// 根据文件列表记录猜想文件列表类型
///
///
///
private FileListStyle GuessFileListStyle(string[] recordList)
{
foreach (string s in recordList)
{
if (s.Length > 10 && Regex.IsMatch(s.Substring(0, 10), "(-|d)(-|r)(-|w)(-|x)(-|r)(-|w)(-|x)(-|r)(-|w)(-|x)"))
{
return FileListStyle.UnixStyle;
}
else if (s.Length > 8 && Regex.IsMatch(s.Substring(0, 8), "[0-9][0-9]-[0-9][0-9]-[0-9][0-9]"))
{
return FileListStyle.WindowsStyle;
}
}
return FileListStyle.Unknown;
}
///
/// 从Unix格式中返回文件信息
///
/// 文件信息
private FileStruct ParseFileStructFromUnixStyleRecord(string Record)
{
FileStruct f = new FileStruct();
string processstr = Record.Trim();
f.Flags = processstr.Substring(0, 10);
f.IsDirectory = (f.Flags[0] == 'd');
processstr = (processstr.Substring(11)).Trim();
_cutSubstringFromStringWithTrim(ref processstr, ' ', 0);   //跳过一部分
f.Owner = _cutSubstringFromStringWithTrim(ref processstr, ' ', 0);
f.Group = _cutSubstringFromStringWithTrim(ref processstr, ' ', 0);
f.FileSize = Convert.ToInt32(_cutSubstringFromStringWithTrim(ref processstr, ' ', 0));
//_cutSubstringFromStringWithTrim(ref processstr, ' ', 0);   //跳过一部分
string yearOrTime = processstr.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)[2];
if (yearOrTime.IndexOf(":") >= 0)  //time
{
processstr = processstr.Replace(yearOrTime, DateTime.Now.Year.ToString());
}
f.CreateTime = DateTime.Parse(_cutSubstringFromStringWithTrim(ref processstr, ' ', 8));
f.Name = processstr;   //最后就是名称
return f;
}
///
/// 按照一定的规则进行字符串截取
///
/// 截取的字符串
/// 查找的字符
/// 查找的位置
private string _cutSubstringFromStringWithTrim(ref string s, char c, int startIndex)
{
int pos1 = s.IndexOf(c, startIndex);
string retString = s.Substring(0, pos1);
s = (s.Substring(pos1)).Trim();
return retString;
}
#endregion
#endregion
#region 上传文件
///
/// 直接上传文件
///
/// 上传的目标全路径与文件名
/// 是否断点续传
/// 上传是否成功
public bool UploadFileNow(byte[] fileBytes, string uploadUrl, bool isContinueUpload)
{
bool result = true;
FTPUrl ftpUrl = null;
FTPConnect ftpConnect = null;
Socket socketData = null;
int iCharIndex = 0;
int bytesRead;
long lOffset = 0, lTotalReaded = 0;
string strDirUrl, strDirUrlTemp;
try
{
ftpUrl = new FTPUrl(uploadUrl);
ftpConnect = new FTPConnect(ftpUrl);
ftpConnect.Connect();
this.m_FTPConnectList.Add(ftpConnect);//添加到控制器中
#region 判断并创建文件夹
strDirUrl = ftpUrl.SubUrl;
if (strDirUrl.IndexOf("/") >= 0)
strDirUrl = strDirUrl.Substring(0, strDirUrl.LastIndexOf("/"));
while (true && strDirUrl.Trim() != "")
{
iCharIndex = strDirUrl.IndexOf("/", iCharIndex) + 1;
if (iCharIndex == 0)
strDirUrlTemp = strDirUrl;
else
strDirUrlTemp = strDirUrl.Substring(0, iCharIndex);
if (strDirUrlTemp == "")
continue;
ftpConnect.SendCommand("MKD " + strDirUrlTemp);
if (ftpConnect.ReplyCode != 257 && ftpConnect.ReplyCode != 550)
throw new IOException(ftpConnect.ReplyString.Substring(4));
if (strDirUrlTemp == strDirUrl)
break;
}
#endregion
ftpConnect.ChangeDir(strDirUrl);
#region 得到服务器上的文件大小
if (isContinueUpload)
{
string strDirName = ftpUrl.SubUrl;
if (strDirName.IndexOf("/") >= 0)
strDirName = strDirName.Substring(0, strDirName.LastIndexOf("/"));
ftpConnect.ChangeDir(strDirName);
ftpConnect.SendCommand("SIZE " + Path.GetFileName(ftpUrl.SubUrl));
if (ftpConnect.ReplyCode == 213)
lOffset = Int64.Parse(ftpConnect.ReplyString.Substring(4));
}
#endregion
#region 开始上传
lTotalReaded = lOffset;
socketData = ftpConnect.CreateDataSocket();
if (lOffset > 0)
ftpConnect.SendCommand("APPE " + Path.GetFileName(uploadUrl));
else
ftpConnect.SendCommand("STOR " + Path.GetFileName(uploadUrl));
if (!(ftpConnect.ReplyCode == 125 || ftpConnect.ReplyCode == 150))
throw new IOException(ftpConnect.ReplyString.Substring(4));
ftpConnect.DataTransmitting = true;
while (true)
{
if (!ftpConnect.DataTransmitting)
{
this.OnFileUploadCanceled(ftpConnect);
break;
}
this.OnFileUploading(ftpConnect, fileBytes.Length, lTotalReaded);
//开始上传资料
bytesRead = (int)((fileBytes.Length > lTotalReaded + ftpConnect.Buffer.Length) ? ftpConnect.Buffer.Length : (fileBytes.Length - lTotalReaded));
if (bytesRead == 0)
break;
Array.Copy(fileBytes, lTotalReaded, ftpConnect.Buffer, 0, bytesRead);
socketData.Send(ftpConnect.Buffer, bytesRead, 0);
lTotalReaded += bytesRead;
}
if (socketData.Connected)
socketData.Close();
if (ftpConnect.DataTransmitting)
{
if (!(ftpConnect.ReplyCode == 226 || ftpConnect.ReplyCode == 250))
{
ftpConnect.ReadReply();
if (!(ftpConnect.ReplyCode == 226 || ftpConnect.ReplyCode == 250))
throw new IOException(ftpConnect.ReplyString.Substring(4));
}
this.OnFileUploadCompleted(ftpConnect);
}
#endregion
}
catch (Exception ex)
{
result = false;
throw (ex);
}
finally
{
if (socketData != null && socketData.Connected)
socketData.Close();
if (ftpConnect != null)
{
ftpConnect.DisConnect();
this.m_FTPConnectList.Remove(ftpConnect);
}
}
return result;
}
///
/// 直接上传文件
///
/// 上传文件的全路径
/// 上传的目标全路径与文件名
/// 是否断点续传
/// 上传是否成功
public bool UploadFileNow(string filePath, string uploadUrl, bool isContinueUpload)
{
bool result = true;
FTPUrl ftpUrl = null;
FTPConnect ftpConnect = null;
Socket socketData = null;
FileStream fileStream = null;
int iCharIndex = 0;
int bytesRead;
long lOffset = 0, lTotalReaded = 0;
string strDirUrl, strDirUrlTemp;
try
{
ftpUrl = new FTPUrl(uploadUrl);
ftpConnect = new FTPConnect(ftpUrl);
ftpConnect.Connect();
this.m_FTPConnectList.Add(ftpConnect);//添加到控制器中
#region 判断并创建文件夹
strDirUrl = ftpUrl.SubUrl;
if (strDirUrl.IndexOf("/") >= 0)
strDirUrl = strDirUrl.Substring(0, strDirUrl.LastIndexOf("/"));
while (true && strDirUrl.Trim() != "")
{
iCharIndex = strDirUrl.IndexOf("/", iCharIndex) + 1;
if (iCharIndex == 0)
strDirUrlTemp = strDirUrl;
else
strDirUrlTemp = strDirUrl.Substring(0, iCharIndex);
if (strDirUrlTemp == "")
continue;
ftpConnect.SendCommand("MKD " + strDirUrlTemp);
if (ftpConnect.ReplyCode != 257 && ftpConnect.ReplyCode != 550)
throw new IOException(ftpConnect.ReplyString.Substring(4));
if (strDirUrlTemp == strDirUrl)
break;
}
#endregion
ftpConnect.ChangeDir(strDirUrl);
#region 得到服务器上的文件大小
if (isContinueUpload)
{
string strDirName = ftpUrl.SubUrl;
if (strDirName.IndexOf("/") >= 0)
strDirName = strDirName.Substring(0, strDirName.LastIndexOf("/"));
ftpConnect.ChangeDir(strDirName);
ftpConnect.SendCommand("SIZE " + Path.GetFileName(ftpUrl.SubUrl));
if (ftpConnect.ReplyCode == 213)
lOffset = Int64.Parse(ftpConnect.ReplyString.Substring(4));
}
#endregion
#region 开始上传
fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
lTotalReaded = lOffset;
fileStream.Seek(lOffset, SeekOrigin.Begin);
socketData = ftpConnect.CreateDataSocket();
if (lOffset > 0)
ftpConnect.SendCommand("APPE " + Path.GetFileName(filePath));
else
ftpConnect.SendCommand("STOR " + Path.GetFileName(filePath));
if (!(ftpConnect.ReplyCode == 125 || ftpConnect.ReplyCode == 150))
throw new IOException(ftpConnect.ReplyString.Substring(4));
ftpConnect.DataTransmitting = true;
while (true)
{
if (!ftpConnect.DataTransmitting)
{
this.OnFileUploadCanceled(ftpConnect);
break;
}
this.OnFileUploading(ftpConnect, fileStream.Length, lTotalReaded);
//开始上传资料
bytesRead = fileStream.Read(ftpConnect.Buffer, 0, ftpConnect.Buffer.Length);
if (bytesRead == 0)
break;
socketData.Send(ftpConnect.Buffer, bytesRead, 0);
lTotalReaded += bytesRead;
}
fileStream.Close();
if (socketData.Connected)
socketData.Close();
if (ftpConnect.DataTransmitting)
{
if (!(ftpConnect.ReplyCode == 226 || ftpConnect.ReplyCode == 250))
{
ftpConnect.ReadReply();
if (!(ftpConnect.ReplyCode == 226 || ftpConnect.ReplyCode == 250))
throw new IOException(ftpConnect.ReplyString.Substring(4));
}
this.OnFileUploadCompleted(ftpConnect);
}
#endregion
}
catch (Exception ex)
{
result = false;
throw (ex);
}
finally
{
if (fileStream != null)
fileStream.Close();
if (socketData != null && socketData.Connected)
socketData.Close();
if (ftpConnect != null)
{
ftpConnect.DisConnect();
this.m_FTPConnectList.Remove(ftpConnect);
}     
}
return result;
}
///
/// 上传文件
///
///
///
public string UploadFile(string filePath, string uploadUrl)
{
return this.UploadFile(filePath, uploadUrl, false);
}
///
/// 上传文件
///
/// 上传文件的全路径
/// 上传的目标全路径 包含了用户名用户密码与文件名
/// 是否断点续传
/// 返回控制上传下载的ID
public string UploadFile(string filePath, string uploadUrl, bool isContinueUpload)
{
String strFTPId = System.Guid.NewGuid().ToString();
IList objList = new List { filePath, uploadUrl, isContinueUpload, strFTPId };
System.Threading.Thread threadUpload = new System.Threading.Thread(new System.Threading.ParameterizedThreadStart(ThreadUploadFile));
threadUpload.Start(objList);  //开始采用线程方式下载
return strFTPId;
}
///
/// 线程接收上传
///
///
private void ThreadUploadFile(object obj)
{
string filePath;
string uploadUrl;
bool isContinueUpload;
string strFTPId;
IList objList = obj as IList;
if (objList != null && objList.Count == 4)
{
filePath = objList[0] as string;
uploadUrl = objList[1] as string;
isContinueUpload = (bool)objList[2];
strFTPId = objList[3] as string;
this.ThreadUploadFile(filePath, uploadUrl, isContinueUpload, strFTPId);
}
}
///
/// 线程上传文件
///
/// 上传文件的全路径
/// 上传的目标全路径与文件名
/// 是否断点续传
/// 上传是否成功
private bool ThreadUploadFile(string filePath, string uploadUrl, bool isContinueUpload, string strFTPId)
{
bool result = true;
FTPUrl ftpUrl = null;
FTPConnect ftpConnect = null;
Socket socketData = null;
FileStream fileStream = null;
int iCharIndex = 0;
int bytesRead;
long lOffset = 0, lTotalReaded = 0;
string strDirUrl, strDirUrlTemp;
try
{
ftpUrl = new FTPUrl(uploadUrl);
ftpConnect = new FTPConnect(ftpUrl, strFTPId);
ftpConnect.Connect();
this.m_FTPConnectList.Add(ftpConnect);//添加到控制器中
#region 判断并创建文件夹
strDirUrl = ftpUrl.SubUrl;
if (strDirUrl.IndexOf("/") >= 0)
strDirUrl = strDirUrl.Substring(0, strDirUrl.LastIndexOf("/"));
while (true && strDirUrl.Trim() != "")
{
iCharIndex = strDirUrl.IndexOf("/", iCharIndex) + 1;
if (iCharIndex == 0)
strDirUrlTemp = strDirUrl;
else
strDirUrlTemp = strDirUrl.Substring(0, iCharIndex);
if (strDirUrlTemp == "")
continue;
ftpConnect.SendCommand("MKD " + strDirUrlTemp);
if (ftpConnect.ReplyCode != 257 && ftpConnect.ReplyCode != 550)
throw new IOException(ftpConnect.ReplyString.Substring(4));
if (strDirUrlTemp == strDirUrl)
break;
}
#endregion
ftpConnect.ChangeDir(strDirUrl);
#region 得到服务器上的文件大小
if (isContinueUpload)
{
string strDirName = ftpUrl.SubUrl;
if (strDirName.IndexOf("/") >= 0)
strDirName = strDirName.Substring(0, strDirName.LastIndexOf("/"));
ftpConnect.ChangeDir(strDirName);
ftpConnect.SendCommand("SIZE " + Path.GetFileName(ftpUrl.SubUrl));
if (ftpConnect.ReplyCode == 213)
lOffset = Int64.Parse(ftpConnect.ReplyString.Substring(4));
}
#endregion
#region 开始上传
fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
lTotalReaded = lOffset;
fileStream.Seek(lOffset, SeekOrigin.Begin);
socketData = ftpConnect.CreateDataSocket();
if (lOffset > 0)
ftpConnect.SendCommand("APPE " + Path.GetFileName(uploadUrl));
else
ftpConnect.SendCommand("STOR " + Path.GetFileName(uploadUrl));
if (!(ftpConnect.ReplyCode == 125 || ftpConnect.ReplyCode == 150))
throw new IOException(ftpConnect.ReplyString.Substring(4));
ftpConnect.DataTransmitting = true;
while (true)
{
if (!ftpConnect.DataTransmitting)
{
this.OnFileUploadCanceled(ftpConnect);
break;
}
this.OnFileUploading(ftpConnect, fileStream.Length, lTotalReaded);
//开始上传资料
bytesRead = fileStream.Read(ftpConnect.Buffer, 0, ftpConnect.Buffer.Length);
if (bytesRead == 0)
break;
socketData.Send(ftpConnect.Buffer, bytesRead, 0);
lTotalReaded += bytesRead;
}
fileStream.Close();
if (socketData.Connected)
socketData.Close();
if (ftpConnect.DataTransmitting)
{
if (!(ftpConnect.ReplyCode == 226 || ftpConnect.ReplyCode == 250))
{
ftpConnect.ReadReply();
if (!(ftpConnect.ReplyCode == 226 || ftpConnect.ReplyCode == 250))
throw new IOException(ftpConnect.ReplyString.Substring(4));
}
this.OnFileUploadCompleted(ftpConnect);
}
#endregion
}
catch (Exception ex)
{
result = false;
this.OnFtpError(ftpConnect, ex);
}
finally
{
if (fileStream != null)
fileStream.Close();
if (socketData != null && socketData.Connected)
socketData.Close();
if (ftpConnect != null)
{
ftpConnect.DisConnect();
this.m_FTPConnectList.Remove(ftpConnect);
}
}
return result;
}
///
/// 取消正在上传的文件
///
///
public void CancelUploadFile(FTPConnect ftpConnect)
{
if (ftpConnect != null)
ftpConnect.DataTransmitting = false;
}
///
/// 取消正在上传的文件
///
///
public void CancelUploadFile(string strID)
{
foreach (FTPConnect ftp in this.m_FTPConnectList)
{
if (ftp != null && ftp.ID == strID)
{
ftp.DataTransmitting = false;
break;
}
}
}
#endregion
#region 下载文件
///
/// 直接下载文件
///
/// 要下载文件的路径
/// 存贮的内容
/// 下载是否成功
public bool DownloadFileNow(string downloadUrl, out byte[] fileBytes)
{
bool result = true;
FTPUrl ftpUrl = null;
FTPConnect ftpConnect = null;
Socket socketData = null;
fileBytes = new byte[] { };
int bytesRead;
long lTotalReaded = 0, lFileSize;
try
{
ftpUrl = new FTPUrl(downloadUrl);
ftpConnect = new FTPConnect(ftpUrl);
ftpConnect.Connect();
this.m_FTPConnectList.Add(ftpConnect);//添加到控制器中
string strDirUrl = ftpUrl.SubUrl;
if (strDirUrl.IndexOf("/") >= 0)
strDirUrl = strDirUrl.Substring(0, strDirUrl.LastIndexOf("/"));
ftpConnect.ChangeDir(strDirUrl);
#region 得到服务器上的文件大小
string strDirName = ftpUrl.SubUrl;
if (strDirName.IndexOf("/") >= 0)
strDirName = strDirName.Substring(0, strDirName.LastIndexOf("/"));
ftpConnect.ChangeDir(strDirName);
ftpConnect.SendCommand("SIZE " + Path.GetFileName(ftpUrl.SubUrl));
if (ftpConnect.ReplyCode == 213)
lFileSize = Int64.Parse(ftpConnect.ReplyString.Substring(4));
else
throw new IOException(ftpConnect.ReplyString.Substring(4));
#endregion
socketData = ftpConnect.CreateDataSocket();
fileBytes = new byte[lFileSize];
ftpConnect.SendCommand("RETR " + Path.GetFileName(ftpUrl.SubUrl));
if (!(ftpConnect.ReplyCode == 150 || ftpConnect.ReplyCode == 125 || ftpConnect.ReplyCode == 226 || ftpConnect.ReplyCode == 250))
throw new IOException(ftpConnect.ReplyString.Substring(4));
#region 开始下载
ftpConnect.DataTransmitting = true;
while (true)
{
if (!ftpConnect.DataTransmitting)    //判断取消是否取消了下载
{
this.OnFileDownloadCanceled(ftpConnect);
break;
}
this.OnFileDownloading(ftpConnect, lFileSize, lTotalReaded);
//开始将文件流写入本地
bytesRead = socketData.Receive(ftpConnect.Buffer, ftpConnect.Buffer.Length, 0);
if (bytesRead = 0)
strDirUrl = strDirUrl.Substring(0, strDirUrl.LastIndexOf("/"));
ftpConnect.ChangeDir(strDirUrl);
#region 得到服务器上的文件大小
string strDirName = ftpUrl.SubUrl;
if (strDirName.IndexOf("/") >= 0)
strDirName = strDirName.Substring(0, strDirName.LastIndexOf("/"));
ftpConnect.ChangeDir(strDirName);
ftpConnect.SendCommand("SIZE " + Path.GetFileName(ftpUrl.SubUrl));
if (ftpConnect.ReplyCode == 213)
lFileSize = Int64.Parse(ftpConnect.ReplyString.Substring(4));
else
throw new IOException(ftpConnect.ReplyString.Substring(4));
#endregion
socketData = ftpConnect.CreateDataSocket();
//断点续传长度的偏移量
if (System.IO.File.Exists(targetFile) && isContinueDownload)
{
System.IO.FileInfo fiInfo = new FileInfo(targetFile);
lTotalReaded = fiInfo.Length;
ftpConnect.SendCommand("REST " + fiInfo.Length.ToString());
if (ftpConnect.ReplyCode != 350)
throw new IOException(ftpConnect.ReplyString.Substring(4));
}
ftpConnect.SendCommand("RETR " + Path.GetFileName(ftpUrl.SubUrl));
if (!(ftpConnect.ReplyCode == 150 || ftpConnect.ReplyCode == 125 || ftpConnect.ReplyCode == 226 || ftpConnect.ReplyCode == 250))
throw new IOException(ftpConnect.ReplyString.Substring(4));
#region 开始下载
string strTargetPath = targetFile;
strTargetPath = strTargetPath.Substring(0, strTargetPath.LastIndexOf("\\"));//这里本来是//
if (!System.IO.Directory.Exists(strTargetPath)) //判断目标路径是否存在，如果不存在就创建
System.IO.Directory.CreateDirectory(strTargetPath);
if (System.IO.File.Exists(targetFile) && isContinueDownload)  //目标文件已经是全路径了 断点续传
fileStream = new System.IO.FileStream(targetFile, System.IO.FileMode.Append, System.IO.FileAccess.Write);
else
fileStream = new System.IO.FileStream(targetFile, System.IO.FileMode.Create, System.IO.FileAccess.Write);
ftpConnect.DataTransmitting = true;
while (true)
{
if (!ftpConnect.DataTransmitting)    //判断取消是否取消了下载
{
this.OnFileDownloadCanceled(ftpConnect);
break;
}
this.OnFileDownloading(ftpConnect, lFileSize, lTotalReaded);
//开始将文件流写入本地
bytesRead = socketData.Receive(ftpConnect.Buffer, ftpConnect.Buffer.Length, 0);
if (bytesRead = 0)
strDirUrl = strDirUrl.Substring(0, strDirUrl.LastIndexOf("/"));
ftpConnect.ChangeDir(strDirUrl);
#region 得到服务器上的文件大小
string strDirName = ftpUrl.SubUrl;
if (strDirName.IndexOf("/") >= 0)
strDirName = strDirName.Substring(0, strDirName.LastIndexOf("/"));
ftpConnect.ChangeDir(strDirName);
ftpConnect.SendCommand("SIZE " + Path.GetFileName(ftpUrl.SubUrl));
if (ftpConnect.ReplyCode == 213)
lFileSize = Int64.Parse(ftpConnect.ReplyString.Substring(4));
else
throw new IOException(ftpConnect.ReplyString.Substring(4));
#endregion
socketData = ftpConnect.CreateDataSocket();
//断点续传长度的偏移量
if (System.IO.File.Exists(targetFile) && isContinueDownload)
{
System.IO.FileInfo fiInfo = new FileInfo(targetFile);
lTotalReaded = fiInfo.Length;
ftpConnect.SendCommand("REST " + fiInfo.Length.ToString());
if (ftpConnect.ReplyCode != 350)
throw new IOException(ftpConnect.ReplyString.Substring(4));
}
ftpConnect.SendCommand("RETR " + Path.GetFileName(ftpUrl.SubUrl));
if (!(ftpConnect.ReplyCode == 150 || ftpConnect.ReplyCode == 125 || ftpConnect.ReplyCode == 226 || ftpConnect.ReplyCode == 250))
throw new IOException(ftpConnect.ReplyString.Substring(4));
#region 开始下载
string strTargetPath = targetFile;
strTargetPath = strTargetPath.Substring(0, strTargetPath.LastIndexOf("//"));
if (!System.IO.Directory.Exists(strTargetPath)) //判断目标路径是否存在，如果不存在就创建
System.IO.Directory.CreateDirectory(strTargetPath);
if (System.IO.File.Exists(targetFile) && isContinueDownload)  //目标文件已经是全路径了 断点续传
fileStream = new System.IO.FileStream(targetFile, System.IO.FileMode.Append, System.IO.FileAccess.Write);
else
fileStream = new System.IO.FileStream(targetFile, System.IO.FileMode.Create, System.IO.FileAccess.Write);
ftpConnect.DataTransmitting = true;
while (true)
{
if (!ftpConnect.DataTransmitting)    //判断取消是否取消了下载
{
this.OnFileDownloadCanceled(ftpConnect);
break;
}
this.OnFileDownloading(ftpConnect, lFileSize, lTotalReaded);
//开始将文件流写入本地
bytesRead = socketData.Receive(ftpConnect.Buffer, ftpConnect.Buffer.Length, 0);
if (bytesRead = 0)
{
return mem.ToArray();
}
else
{
return null;
}
}
catch (Exception ep)
{
ErrorMsg = ep.ToString();
throw ep;
}
}
#endregion

#region 异步下载文件
///
/// 从FTP服务器异步下载文件，指定本地路径和本地文件名
///
/// 远程文件名        
/// 保存文件的本地路径,后面带有"\"
/// 保存本地的文件名
public void DownloadFileAsync(string RemoteFileName, string LocalPath, string LocalFileName)
{
//byte[] bt = null;
try
{
if (!IsValidFileChars(RemoteFileName) || !IsValidFileChars(LocalFileName) || !IsValidPathChars(LocalPath))
{
throw new Exception("非法文件名或目录名!");
}
if (!Directory.Exists(LocalPath))
{
throw new Exception("本地文件路径不存在!");
}
string LocalFullPath = Path.Combine(LocalPath, LocalFileName);
if (File.Exists(LocalFullPath))
{
throw new Exception("当前路径下已经存在同名文件！");
}
DownloadFileAsync(RemoteFileName, LocalFullPath);
}
catch (Exception ep)
{
ErrorMsg = ep.ToString();
throw ep;
}
}
///
/// 从FTP服务器异步下载文件，指定本地完整路径文件名
///
/// 远程文件名
/// 本地完整路径文件名
public void DownloadFileAsync(string RemoteFileName, string LocalFullPath)
{
try
{
if (!IsValidFileChars(RemoteFileName))
{
throw new Exception("非法文件名或目录名!");
}
if (File.Exists(LocalFullPath))
{
throw new Exception("当前路径下已经存在同名文件！");
}
MyWebClient client = new MyWebClient();
client.DownloadProgressChanged += new DownloadProgressChangedEventHandler(client_DownloadProgressChanged);
client.DownloadFileCompleted += new System.ComponentModel.AsyncCompletedEventHandler(client_DownloadFileCompleted);
client.Credentials = new NetworkCredential(this.UserName, this.Password);
if (this.Proxy != null)
{
client.Proxy = this.Proxy;
}
client.DownloadFileAsync(new Uri(this.Uri.ToString() + RemoteFileName), LocalFullPath);
}
catch (Exception ep)
{
ErrorMsg = ep.ToString();
throw ep;
}
}
///
/// 异步下载文件完成之后触发的事件
///
/// 下载对象
/// 数据信息对象
void client_DownloadFileCompleted(object sender, System.ComponentModel.AsyncCompletedEventArgs e)
{
if (DownloadDataCompleted != null)
{
DownloadDataCompleted(sender, e);
}
}
///
/// 异步下载进度发生改变触发的事件
///
/// 下载对象
/// 进度信息对象
void client_DownloadProgressChanged(object sender, DownloadProgressChangedEventArgs e)
{
if (DownloadProgressChanged != null)
{
DownloadProgressChanged(sender, e);
}
}
#endregion

#region 上传文件
///
/// 上传文件到FTP服务器
///
/// 本地带有完整路径的文件名
public bool UploadFile(string LocalFullPath)
{
return UploadFile(LocalFullPath, Path.GetFileName(LocalFullPath), false);
}
///
/// 上传文件到FTP服务器
///
/// 本地带有完整路径的文件
/// 是否覆盖远程服务器上面同名的文件
public bool UploadFile(string LocalFullPath, bool OverWriteRemoteFile)
{
return UploadFile(LocalFullPath, Path.GetFileName(LocalFullPath), OverWriteRemoteFile);
}
///
/// 上传文件到FTP服务器
///
/// 本地带有完整路径的文件
/// 要在FTP服务器上面保存文件名
public bool UploadFile(string LocalFullPath, string RemoteFileName)
{
return UploadFile(LocalFullPath, RemoteFileName, false);
}
///
/// 上传文件到FTP服务器
///
/// 本地带有完整路径的文件名
/// 要在FTP服务器上面保存文件名
/// 是否覆盖远程服务器上面同名的文件
public bool UploadFile(string LocalFullPath, string RemoteFileName, bool OverWriteRemoteFile)
{
try
{
if (!IsValidFileChars(RemoteFileName) || !IsValidFileChars(Path.GetFileName(LocalFullPath)) || !IsValidPathChars(Path.GetDirectoryName(LocalFullPath)))
{
throw new Exception("非法文件名或目录名!");
}
if (File.Exists(LocalFullPath))
{
FileStream Stream = new FileStream(LocalFullPath, FileMode.Open, FileAccess.Read);
byte[] bt = new byte[Stream.Length];
Stream.Read(bt, 0, (Int32)Stream.Length);   //注意，因为Int32的最大限制，最大上传文件只能是大约2G多一点
Stream.Close();
return UploadFile(bt, RemoteFileName, OverWriteRemoteFile);
}
else
{
throw new Exception("本地文件不存在!");
}
}
catch (Exception ep)
{
ErrorMsg = ep.ToString();
throw ep;
}
}
///
/// 上传文件到FTP服务器
///
/// 上传的二进制数据
/// 要在FTP服务器上面保存文件名
public bool UploadFile(byte[] FileBytes, string RemoteFileName)
{
if (!IsValidFileChars(RemoteFileName))
{
throw new Exception("非法文件名或目录名!");
}
return UploadFile(FileBytes, RemoteFileName, false);
}
///
/// 上传文件到FTP服务器
///
/// 文件二进制内容
/// 要在FTP服务器上面保存文件名
/// 是否覆盖远程服务器上面同名的文件
public bool UploadFile(byte[] FileBytes, string RemoteFileName, bool OverWriteRemoteFile)
{
try
{
if (!IsValidFileChars(RemoteFileName))
{
throw new Exception("非法文件名！");
}
if (!OverWriteRemoteFile && FileExist(RemoteFileName))
{
throw new Exception("FTP服务上面已经存在同名文件！");
}
OpenRequest(new Uri(this.Uri.ToString() + RemoteFileName), WebRequestMethods.Ftp.UploadFile);
Stream requestStream = Request.GetRequestStream();
MemoryStream mem = new MemoryStream(FileBytes);
byte[] buffer = new byte[1024];
int bytesRead = 0;
int TotalRead = 0;
while (true)
{
bytesRead = mem.Read(buffer, 0, buffer.Length);
if (bytesRead == 0)
break;
TotalRead += bytesRead;
requestStream.Write(buffer, 0, bytesRead);
}
requestStream.Close();
Response = (FtpWebResponse)Request.GetResponse();
mem.Close();
mem.Dispose();
FileBytes = null;
return true;
}
catch (Exception ep)
{
ErrorMsg = ep.ToString();
throw ep;
}
}
#endregion

#region 异步上传文件
///
/// 异步上传文件到FTP服务器
///
/// 本地带有完整路径的文件名
public void UploadFileAsync(string LocalFullPath)
{
UploadFileAsync(LocalFullPath, Path.GetFileName(LocalFullPath), false);
}
///
/// 异步上传文件到FTP服务器
///
/// 本地带有完整路径的文件
/// 是否覆盖远程服务器上面同名的文件
public void UploadFileAsync(string LocalFullPath, bool OverWriteRemoteFile)
{
UploadFileAsync(LocalFullPath, Path.GetFileName(LocalFullPath), OverWriteRemoteFile);
}
///
/// 异步上传文件到FTP服务器
///
/// 本地带有完整路径的文件
/// 要在FTP服务器上面保存文件名
public void UploadFileAsync(string LocalFullPath, string RemoteFileName)
{
UploadFileAsync(LocalFullPath, RemoteFileName, false);
}
///
/// 异步上传文件到FTP服务器
///
/// 本地带有完整路径的文件名
/// 要在FTP服务器上面保存文件名
/// 是否覆盖远程服务器上面同名的文件
public void UploadFileAsync(string LocalFullPath, string RemoteFileName, bool OverWriteRemoteFile)
{
try
{
if (!IsValidFileChars(RemoteFileName) || !IsValidFileChars(Path.GetFileName(LocalFullPath)) || !IsValidPathChars(Path.GetDirectoryName(LocalFullPath)))
{
throw new Exception("非法文件名或目录名!");
}
if (!OverWriteRemoteFile && FileExist(RemoteFileName))
{
throw new Exception("FTP服务上面已经存在同名文件！");
}
if (File.Exists(LocalFullPath))
{
MyWebClient client = new MyWebClient();
client.UploadProgressChanged += new UploadProgressChangedEventHandler(client_UploadProgressChanged);
client.UploadFileCompleted += new UploadFileCompletedEventHandler(client_UploadFileCompleted);
client.Credentials = new NetworkCredential(this.UserName, this.Password);
if (this.Proxy != null)
{
client.Proxy = this.Proxy;
}
client.UploadFileAsync(new Uri(this.Uri.ToString() + RemoteFileName), LocalFullPath);
}
else
{
throw new Exception("本地文件不存在!");
}
}
catch (Exception ep)
{
ErrorMsg = ep.ToString();
throw ep;
}
}
///
/// 异步上传文件到FTP服务器
///
/// 上传的二进制数据
/// 要在FTP服务器上面保存文件名
public void UploadFileAsync(byte[] FileBytes, string RemoteFileName)
{
if (!IsValidFileChars(RemoteFileName))
{
throw new Exception("非法文件名或目录名!");
}
UploadFileAsync(FileBytes, RemoteFileName, false);
}
///
/// 异步上传文件到FTP服务器
///
/// 文件二进制内容
/// 要在FTP服务器上面保存文件名
/// 是否覆盖远程服务器上面同名的文件
public void UploadFileAsync(byte[] FileBytes, string RemoteFileName, bool OverWriteRemoteFile)
{
try
{
if (!IsValidFileChars(RemoteFileName))
{
throw new Exception("非法文件名！");
}
if (!OverWriteRemoteFile && FileExist(RemoteFileName))
{
throw new Exception("FTP服务上面已经存在同名文件！");
}
string TempPath = System.Environment.GetFolderPath(Environment.SpecialFolder.Templates);
if (!TempPath.EndsWith("\\"))
{
TempPath += "\\";
}
string TempFile = TempPath + Path.GetRandomFileName();
TempFile = Path.ChangeExtension(TempFile, Path.GetExtension(RemoteFileName));
FileStream Stream = new FileStream(TempFile, FileMode.CreateNew, FileAccess.Write);
Stream.Write(FileBytes, 0, FileBytes.Length);   //注意，因为Int32的最大限制，最大上传文件只能是大约2G多一点
Stream.Flush();
Stream.Close();
Stream.Dispose();
_isDeleteTempFile = true;
_UploadTempFile = TempFile;
FileBytes = null;
UploadFileAsync(TempFile, RemoteFileName, OverWriteRemoteFile);

}
catch (Exception ep)
{
ErrorMsg = ep.ToString();
throw ep;
}
}
///
/// 异步上传文件完成之后触发的事件
///
/// 下载对象
/// 数据信息对象
void client_UploadFileCompleted(object sender, UploadFileCompletedEventArgs e)
{
if (_isDeleteTempFile)
{
if (File.Exists(_UploadTempFile))
{
File.SetAttributes(_UploadTempFile, FileAttributes.Normal);
File.Delete(_UploadTempFile);
}
_isDeleteTempFile = false;
}
if (UploadFileCompleted != null)
{
UploadFileCompleted(sender, e);
}
}
///
/// 异步上传进度发生改变触发的事件
///
/// 下载对象
/// 进度信息对象
void client_UploadProgressChanged(object sender, UploadProgressChangedEventArgs e)
{
if (UploadProgressChanged != null)
{
UploadProgressChanged(sender, e);
}
}
#endregion

#region 列出目录文件信息
///
/// 列出FTP服务器上面当前目录的所有文件和目录
///
public FileStruct[] ListFilesAndDirectories()
{
Response = Open(this.Uri, WebRequestMethods.Ftp.ListDirectoryDetails);
StreamReader stream = new StreamReader(Response.GetResponseStream(), Encoding.Default);
string Datastring = stream.ReadToEnd();
FileStruct[] list = GetList(Datastring);
return list;
}
///
/// 列出FTP服务器上面当前目录的所有文件
///
public FileStruct[] ListFiles()
{
FileStruct[] listAll = ListFilesAndDirectories();
List listFile = new List();
foreach (FileStruct file in listAll)
{
if (!file.IsDirectory)
{
listFile.Add(file);
}
}
return listFile.ToArray();
}
///
/// 列出FTP服务器上面当前目录的所有的目录
///
public FileStruct[] ListDirectories()
{
FileStruct[] listAll = ListFilesAndDirectories();
List listDirectory = new List();
foreach (FileStruct file in listAll)
{
if (file.IsDirectory)
{
listDirectory.Add(file);
}
}
return listDirectory.ToArray();
}
///
/// 获得文件和目录列表
///
/// FTP返回的列表字符信息
private FileStruct[] GetList(string datastring)
{
List myListArray = new List();
string[] dataRecords = datastring.Split('\n');
FileListStyle _directoryListStyle = GuessFileListStyle(dataRecords);
foreach (string s in dataRecords)
{
if (_directoryListStyle != FileListStyle.Unknown && s != "")
{
FileStruct f = new FileStruct();
f.Name = "..";
switch (_directoryListStyle)
{
case FileListStyle.UnixStyle:
f = ParseFileStructFromUnixStyleRecord(s);
break;
case FileListStyle.WindowsStyle:
f = ParseFileStructFromWindowsStyleRecord(s);
break;
}
if (!(f.Name == "." || f.Name == ".."))
{
myListArray.Add(f);
}
}
}
return myListArray.ToArray();
}
///
/// 从Windows格式中返回文件信息
///
/// 文件信息
private FileStruct ParseFileStructFromWindowsStyleRecord(string Record)
{
FileStruct f = new FileStruct();
string processstr = Record.Trim();
string dateStr = processstr.Substring(0, 8);
processstr = (processstr.Substring(8, processstr.Length - 8)).Trim();
string timeStr = processstr.Substring(0, 7);
processstr = (processstr.Substring(7, processstr.Length - 7)).Trim();
DateTimeFormatInfo myDTFI = new CultureInfo("en-US", false).DateTimeFormat;
myDTFI.ShortTimePattern = "t";
f.CreateTime = DateTime.Parse(dateStr + " " + timeStr, myDTFI);
if (processstr.Substring(0, 5) == "")
{
f.IsDirectory = true;
processstr = (processstr.Substring(5, processstr.Length - 5)).Trim();
}
else
{
string[] strs = processstr.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);   // true);
processstr = strs[1];
f.IsDirectory = false;
}
f.Name = processstr;
return f;
}

///
/// 判断文件列表的方式Window方式还是Unix方式
///
/// 文件信息列表
private FileListStyle GuessFileListStyle(string[] recordList)
{
foreach (string s in recordList)
{
if (s.Length > 10
&& Regex.IsMatch(s.Substring(0, 10), "(-|d)(-|r)(-|w)(-|x)(-|r)(-|w)(-|x)(-|r)(-|w)(-|x)"))
{
return FileListStyle.UnixStyle;
}
else if (s.Length > 8
&& Regex.IsMatch(s.Substring(0, 8), "[0-9][0-9]-[0-9][0-9]-[0-9][0-9]"))
{
return FileListStyle.WindowsStyle;
}
}
return FileListStyle.Unknown;
}
///
/// 从Unix格式中返回文件信息
///
/// 文件信息
private FileStruct ParseFileStructFromUnixStyleRecord(string Record)
{
FileStruct f = new FileStruct();
string processstr = Record.Trim();
f.Flags = processstr.Substring(0, 10);
f.IsDirectory = (f.Flags[0] == 'd');
processstr = (processstr.Substring(11)).Trim();
_cutSubstringFromStringWithTrim(ref processstr, ' ', 0);   //跳过一部分
f.Owner = _cutSubstringFromStringWithTrim(ref processstr, ' ', 0);
f.Group = _cutSubstringFromStringWithTrim(ref processstr, ' ', 0);
_cutSubstringFromStringWithTrim(ref processstr, ' ', 0);   //跳过一部分
string yearOrTime = processstr.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)[2];
if (yearOrTime.IndexOf(":") >= 0)  //time
{
processstr = processstr.Replace(yearOrTime, DateTime.Now.Year.ToString());
}
f.CreateTime = DateTime.Parse(_cutSubstringFromStringWithTrim(ref processstr, ' ', 8));
f.Name = processstr;   //最后就是名称
return f;
}
///
/// 按照一定的规则进行字符串截取
///
/// 截取的字符串
/// 查找的字符
/// 查找的位置
private string _cutSubstringFromStringWithTrim(ref string s, char c, int startIndex)
{
int pos1 = s.IndexOf(c, startIndex);
string retString = s.Substring(0, pos1);
s = (s.Substring(pos1)).Trim();
return retString;
}
#endregion

#region 目录或文件存在的判断
///
/// 判断当前目录下指定的子目录是否存在
///
/// 指定的目录名
public bool DirectoryExist(string RemoteDirectoryName)
{
try
{
if (!IsValidPathChars(RemoteDirectoryName))
{
throw new Exception("目录名非法！");
}
FileStruct[] listDir = ListDirectories();
foreach (FileStruct dir in listDir)
{
if (dir.Name == RemoteDirectoryName)
{
return true;
}
}
return false;
}
catch (Exception ep)
{
ErrorMsg = ep.ToString();
throw ep;
}
}
///
/// 判断一个远程文件是否存在服务器当前目录下面
///
/// 远程文件名
public bool FileExist(string RemoteFileName)
{
try
{
if (!IsValidFileChars(RemoteFileName))
{
throw new Exception("文件名非法！");
}
FileStruct[] listFile = ListFiles();
foreach (FileStruct file in listFile)
{
if (file.Name == RemoteFileName)
{
return true;
}
}
return false;
}
catch (Exception ep)
{
ErrorMsg = ep.ToString();
throw ep;
}
}
#endregion

#region 删除文件
///
/// 从FTP服务器上面删除一个文件
///
/// 远程文件名
public void DeleteFile(string RemoteFileName)
{
try
{
if (!IsValidFileChars(RemoteFileName))
{
throw new Exception("文件名非法！");
}
Response = Open(new Uri(this.Uri.ToString() + RemoteFileName), WebRequestMethods.Ftp.DeleteFile);
}
catch (Exception ep)
{
ErrorMsg = ep.ToString();
throw ep;
}
}
#endregion

#region 重命名文件
///
/// 更改一个文件的名称或一个目录的名称
///
/// 原始文件或目录名称
/// 新的文件或目录的名称
public bool ReName(string RemoteFileName, string NewFileName)
{
try
{
if (!IsValidFileChars(RemoteFileName) || !IsValidFileChars(NewFileName))
{
throw new Exception("文件名非法！");
}
if (RemoteFileName == NewFileName)
{
return true;
}
if (FileExist(RemoteFileName))
{
Request = OpenRequest(new Uri(this.Uri.ToString() + RemoteFileName), WebRequestMethods.Ftp.Rename);
Request.RenameTo = NewFileName;
Response = (FtpWebResponse)Request.GetResponse();
}
else
{
throw new Exception("文件在服务器上不存在！");
}
return true;
}
catch (Exception ep)
{
ErrorMsg = ep.ToString();
throw ep;
}
}
#endregion

#region 拷贝、移动文件
///
/// 把当前目录下面的一个文件拷贝到服务器上面另外的目录中，注意，拷贝文件之后，当前工作目录还是文件原来所在的目录
///
/// 当前目录下的文件名
/// 新目录名称。
/// 说明：如果新目录是当前目录的子目录，则直接指定子目录。如: SubDirectory1/SubDirectory2 ；
/// 如果新目录不是当前目录的子目录，则必须从根目录一级一级的指定。如： ./NewDirectory/SubDirectory1/SubDirectory2
///
///
public bool CopyFileToAnotherDirectory(string RemoteFile, string DirectoryName)
{
string CurrentWorkDir = this.DirectoryPath;
try
{
byte[] bt = DownloadFile(RemoteFile);
GotoDirectory(DirectoryName);
bool Success = UploadFile(bt, RemoteFile, false);
this.DirectoryPath = CurrentWorkDir;
return Success;
}
catch (Exception ep)
{
this.DirectoryPath = CurrentWorkDir;
ErrorMsg = ep.ToString();
throw ep;
}
}
///
/// 把当前目录下面的一个文件移动到服务器上面另外的目录中，注意，移动文件之后，当前工作目录还是文件原来所在的目录
///
/// 当前目录下的文件名
/// 新目录名称。
/// 说明：如果新目录是当前目录的子目录，则直接指定子目录。如: SubDirectory1/SubDirectory2 ；
/// 如果新目录不是当前目录的子目录，则必须从根目录一级一级的指定。如： ./NewDirectory/SubDirectory1/SubDirectory2
///
///
public bool MoveFileToAnotherDirectory(string RemoteFile, string DirectoryName)
{
string CurrentWorkDir = this.DirectoryPath;
try
{
if (DirectoryName == "")
return false;
if (!DirectoryName.StartsWith("/"))
DirectoryName = "/" + DirectoryName;
if (!DirectoryName.EndsWith("/"))
DirectoryName += "/";
bool Success = ReName(RemoteFile, DirectoryName + RemoteFile);
this.DirectoryPath = CurrentWorkDir;
return Success;
}
catch (Exception ep)
{
this.DirectoryPath = CurrentWorkDir;
ErrorMsg = ep.ToString();
throw ep;
}
}
#endregion

#region 建立、删除子目录
///
/// 在FTP服务器上当前工作目录建立一个子目录
///
/// 子目录名称
public bool MakeDirectory(string DirectoryName)
{
try
{
if (!IsValidPathChars(DirectoryName))
{
throw new Exception("目录名非法！");
}
if (DirectoryExist(DirectoryName))
{
throw new Exception("服务器上面已经存在同名的文件名或目录名！");
}
Response = Open(new Uri(this.Uri.ToString() + DirectoryName), WebRequestMethods.Ftp.MakeDirectory);
return true;
}
catch (Exception ep)
{
ErrorMsg = ep.ToString();
throw ep;
}
}
///
/// 从当前工作目录中删除一个子目录
///
/// 子目录名称
public bool RemoveDirectory(string DirectoryName)
{
try
{
if (!IsValidPathChars(DirectoryName))
{
throw new Exception("目录名非法！");
}
if (!DirectoryExist(DirectoryName))
{
throw new Exception("服务器上面不存在指定的文件名或目录名！");
}
Response = Open(new Uri(this.Uri.ToString() + DirectoryName), WebRequestMethods.Ftp.RemoveDirectory);
return true;
}
catch (Exception ep)
{
ErrorMsg = ep.ToString();
throw ep;
}
}
#endregion

#region 文件、目录名称有效性判断
///
/// 判断目录名中字符是否合法
///
/// 目录名称
public bool IsValidPathChars(string DirectoryName)
{
char[] invalidPathChars = Path.GetInvalidPathChars();
char[] DirChar = DirectoryName.ToCharArray();
foreach (char C in DirChar)
{
if (Array.BinarySearch(invalidPathChars, C) >= 0)
{
return false;
}
}
return true;
}
///
/// 判断文件名中字符是否合法
///
/// 文件名称
public bool IsValidFileChars(string FileName)
{
char[] invalidFileChars = Path.GetInvalidFileNameChars();
char[] NameChar = FileName.ToCharArray();
foreach (char C in NameChar)
{
if (Array.BinarySearch(invalidFileChars, C) >= 0)
{
return false;
}
}
return true;
}
#endregion

#region 目录切换操作
///
/// 进入一个目录
///
///
/// 新目录的名字。
/// 说明：如果新目录是当前目录的子目录，则直接指定子目录。如: SubDirectory1/SubDirectory2 ；
/// 如果新目录不是当前目录的子目录，则必须从根目录一级一级的指定。如： ./NewDirectory/SubDirectory1/SubDirectory2
///
public bool GotoDirectory(string DirectoryName)
{
string CurrentWorkPath = this.DirectoryPath;
try
{
DirectoryName = DirectoryName.Replace("\\", "/");
string[] DirectoryNames = DirectoryName.Split(new char[] { '/' });
if (DirectoryNames[0] == ".")
{
this.DirectoryPath = "/";
if (DirectoryNames.Length == 1)
{
return true;
}
Array.Clear(DirectoryNames, 0, 1);
}
bool Success = false;
foreach (string dir in DirectoryNames)
{
if (dir != null)
{
Success = EnterOneSubDirectory(dir);
if (!Success)
{
this.DirectoryPath = CurrentWorkPath;
return false;
}
}
}
return Success;
}
catch (Exception ep)
{
this.DirectoryPath = CurrentWorkPath;
ErrorMsg = ep.ToString();
throw ep;
}
}
///
/// 从当前工作目录进入一个子目录
///
/// 子目录名称
private bool EnterOneSubDirectory(string DirectoryName)
{
try
{
if (DirectoryName.IndexOf("/") >= 0 || !IsValidPathChars(DirectoryName))
{
throw new Exception("目录名非法!");
}
if (DirectoryName.Length > 0 && DirectoryExist(DirectoryName))
{
if (!DirectoryName.EndsWith("/"))
{
DirectoryName += "/";
}
_DirectoryPath += DirectoryName;
return true;
}
else
{
return false;
}
}
catch (Exception ep)
{
ErrorMsg = ep.ToString();
throw ep;
}
}
///
/// 从当前工作目录往上一级目录
///
public bool ComeoutDirectory()
{
if (_DirectoryPath == "/")
{
ErrorMsg = "当前目录已经是根目录！";
throw new Exception("当前目录已经是根目录！");
}
char[] sp = new char[1] { '/' };
string[] strDir = _DirectoryPath.Split(sp, StringSplitOptions.RemoveEmptyEntries);
if (strDir.Length == 1)
{
_DirectoryPath = "/";
}
else
{
_DirectoryPath = String.Join("/", strDir, 0, strDir.Length - 1);
}
return true;
}
#endregion

#region 重载WebClient，支持FTP进度
internal class MyWebClient : WebClient
{
protected override WebRequest GetWebRequest(Uri address)
{
FtpWebRequest req = (FtpWebRequest)base.GetWebRequest(address);
req.UsePassive = false;
return req;
}
}
#endregion
}
}

　　使用示例：



Uri ftpUrl = new Uri("ftp://192.168.1.100/");
FTPHelper ftp = new FTPHelper(ftpUrl, "用户名", "密码");
FileStruct[] files = ftp.ListFiles();
foreach (FileStruct fs in files)
{
if (fs.Name == filename)
{
MessageUtil.ShowTips("服务器中已经含有" + filename + "文件");
break;
}
}
bool result = ftp.UploadFile(filePosition);