FTP操作类的使用

FTP（文件传输协议）

FTP 是File Transfer Protocol（文件传输协议）的英文简称，而中文简称为“文传协议”。用于Internet上的控制文件的双向传输。同时，它也是一个应用程序（Application）。基于不同的操作系统有不同的FTP应用程序，而所有这些应用程序都遵守同一种协议以传输文件。在FTP的使用当中，用户经常遇到两个概念："下载"（Download）和"上传"（Upload）。"下载"文件就是从远程主机拷贝文件至自己的计算机上；"上传"文件就是将文件从自己的计算机中拷贝至远程主机上。用Internet语言来说，用户可通过客户机程序向（从）远程主机上传（下载）文件。

运行机制

FTP服务器

简单地说，支持FTP协议的服务器就是FTP服务器。

与大多数Internet服务一样，FTP也是一个客户机/服务器系统。用户通过一个支持FTP协议的客户机程序，连接到在远程主机上的FTP服务器程序。用户通过客户机程序向服务器程序发出命令，服务器程序执行用户所发出的命令，并将执行的结果返回到客户机。比如说，用户发出一条命令，要求服务器向用户传送某一个文件的一份拷贝，服务器会响应这条命令，将指定文件送至用户的机器上。客户机程序代表用户接收到这个文件，将其存放在用户目录中。

 

匿名FTP

使用FTP时必须首先登录，在远程主机上获得相应的权限以后，方可下载或上传文件。也就是说，要想同哪一台计算机传送文件，就必须具有哪一台计算机的适当授权。换言之，除非有用户ID和口令，否则便无法传送文件。这种情况违背了Internet的开放性，Internet上的FTP主机何止千万，不可能要求每个用户在每一台主机上都拥有帐号。匿名FTP就是为解决这个问题而产生的。

匿名FTP是这样一种机制，用户可通过它连接到远程主机上，并从其下载文件，而无需成为其注册用户。系统管理员建立了一个特殊的用户ID，名为anonymous, Internet上的任何人在任何地方都可使用该用户ID。

通过FTP程序连接匿名FTP主机的方式同连接普通FTP主机的方式差不多，只是在要求提供用户标识ID时必须输入anonymous，该用户ID的口令可以是任意的字符串。习惯上，用自己的E-mail地址作为口令，使系统维护程序能够记录下来谁在存取这些文件。

值得注意的是，匿名FTP不适用于所有Internet主机，它只适用于那些提供了这项服务的主机。

当远程主机提供匿名FTP服务时，会指定某些目录向公众开放，允许匿名存取。系统中的其余目录则处于隐匿状态。作为一种安全措施，大多数匿名FTP主机都允许用户从其下载文件，而不允许用户向其上传文件，也就是说，用户可将匿名FTP主机上的所有文件全部拷贝到自己的机器上，但不能将自己机器上的任何一个文件拷贝至匿名FTP主机上。即使有些匿名FTP主机确实允许用户上传文件，用户也只能将文件上传至某一指定上传目录中。随后，系统管理员会去检查这些文件，他会将这些文件移至另一个公共下载目录中，供其他用户下载，利用这种方式，远程主机的用户得到了保护，避免了有人上传有问题的文件，如带病毒的文件。

传输方式

FTP的传输有两种方式：ASCII、二进制。

ASCII传输方式

假定用户正在拷贝的文件包含的简单ASCII码文本，如果在远程机器上运行的不是UNIX，当文件传输时ftp通常会自动地调整文件的内容以便于把文件解释成另外那台计算机存储文本文件的格式。

但是常常有这样的情况，用户正在传输的文件包含的不是文本文件，它们可能是程序，数据库，字处理文件或者压缩文件。在拷贝任何非文本文件之前，用binary 命令告诉ftp逐字拷贝。

二进制传输模式

在二进制传输中，保存文件的位序，以便原始和拷贝的是逐位一一对应的。即使目的地机器上包含位序列的文件是没意义的。例如，macintosh以二进制方式传送可执行文件到Windows系统，在对方系统上，此文件不能执行。

如在ASCII方式下传输二进制文件，即使不需要也仍会转译。这会损坏数据。（ASCII方式一般假设每一字符的第一有效位无意义，因为ASCII字符组合不使用它。如果传输二进制文件，所有的位都是重要的。）

 

FTPHelper操作类方便使用

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

namespace DotNet.Dal
{
public class FTPHelper
{
#region 字段
string ftpURI;
string ftpUserID;
string ftpServerIP;
string ftpPassword;
string ftpRemotePath;
#endregion

/// <summary>
/// 连接FTP服务器
/// </summary>
/// <param name="FtpServerIP">FTP连接地址</param>
/// <param name="FtpRemotePath">指定FTP连接成功后的当前目录, 如果不指定即默认为根目录</param>
/// <param name="FtpUserID">用户名</param>
/// <param name="FtpPassword">密码</param>
public FTPHelper(string FtpServerIP, string FtpRemotePath, string FtpUserID, string FtpPassword)
{
ftpServerIP = FtpServerIP;
ftpRemotePath = FtpRemotePath;
ftpUserID = FtpUserID;
ftpPassword = FtpPassword;
ftpURI = "ftp://" + ftpServerIP + "/" + ftpRemotePath + "/";
}

/// <summary>
/// 上传
/// </summary>
public void Upload(string filename)
{
FileInfo fileInf = new FileInfo(filename);
FtpWebRequest reqFTP;
reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri(ftpURI + fileInf.Name));
reqFTP.Credentials = new NetworkCredential(ftpUserID, ftpPassword);
reqFTP.Method = WebRequestMethods.Ftp.UploadFile;
reqFTP.KeepAlive = false;
reqFTP.UseBinary = true;
reqFTP.ContentLength = fileInf.Length;
int buffLength = ;
byte[] buff = new byte[buffLength];
int contentLen;
FileStream fs = fileInf.OpenRead();
try
{
Stream strm = reqFTP.GetRequestStream();
contentLen = fs.Read(buff, , buffLength);
while (contentLen != )
{
strm.Write(buff, , contentLen);
contentLen = fs.Read(buff, , buffLength);
}
strm.Close();
fs.Close();
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}

/// <summary>
/// 下载
/// </summary>
public void Download(string filePath, string fileName)
{
try
{
FileStream outputStream = new FileStream(filePath + "\\" + fileName, FileMode.Create);
FtpWebRequest reqFTP;
reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri(ftpURI + fileName));
reqFTP.Credentials = new NetworkCredential(ftpUserID, ftpPassword);
reqFTP.Method = WebRequestMethods.Ftp.DownloadFile;
reqFTP.UseBinary = true;
FtpWebResponse response = (FtpWebResponse)reqFTP.GetResponse();
Stream ftpStream = response.GetResponseStream();
long cl = response.ContentLength;
int bufferSize = ;
int readCount;
byte[] buffer = new byte[bufferSize];
readCount = ftpStream.Read(buffer, , bufferSize);
while (readCount > )
{
outputStream.Write(buffer, , readCount);
readCount = ftpStream.Read(buffer, , bufferSize);
}
ftpStream.Close();
outputStream.Close();
response.Close();
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}

/// <summary>
/// 删除文件
/// </summary>
public void Delete(string fileName)
{
try
{
FtpWebRequest reqFTP;
reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri(ftpURI + fileName));
reqFTP.Credentials = new NetworkCredential(ftpUserID, ftpPassword);
reqFTP.Method = WebRequestMethods.Ftp.DeleteFile;
reqFTP.KeepAlive = false;
string result = String.Empty;
FtpWebResponse response = (FtpWebResponse)reqFTP.GetResponse();
long size = response.ContentLength;
Stream datastream = response.GetResponseStream();
StreamReader sr = new StreamReader(datastream);
result = sr.ReadToEnd();
sr.Close();
datastream.Close();
response.Close();
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}

/// <summary>
/// 获取当前目录下明细(包含文件和文件夹)
/// </summary>
public string[] GetFilesDetailList()
{
try
{
StringBuilder result = new StringBuilder();
FtpWebRequest ftp;
ftp = (FtpWebRequest)FtpWebRequest.Create(new Uri(ftpURI));
ftp.Credentials = new NetworkCredential(ftpUserID, ftpPassword);
ftp.Method = WebRequestMethods.Ftp.ListDirectoryDetails;
WebResponse response = ftp.GetResponse();
StreamReader reader = new StreamReader(response.GetResponseStream());
string line = reader.ReadLine();
line = reader.ReadLine();
line = reader.ReadLine();
while (line != null)
{
result.Append(line);
result.Append("\n");
line = reader.ReadLine();
}
result.Remove(result.ToString().LastIndexOf("\n"), );
reader.Close();
response.Close();
return result.ToString().Split('\n');
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}

/// <summary>
/// 获取FTP文件列表(包括文件夹)
/// </summary>
private string[] GetAllList(string url)
{
List<string> list = new List<string>();
FtpWebRequest req = (FtpWebRequest)WebRequest.Create(new Uri(url));
req.Credentials = new NetworkCredential(ftpPassword, ftpPassword);
req.Method = WebRequestMethods.Ftp.ListDirectory;
req.UseBinary = true;
req.UsePassive = true;
try
{
using (FtpWebResponse res = (FtpWebResponse)req.GetResponse())
{
using (StreamReader sr = new StreamReader(res.GetResponseStream()))
{
string s;
while ((s = sr.ReadLine()) != null)
{
list.Add(s);
}
}
}
}
catch (Exception ex)
{
throw (ex);
}
return list.ToArray();
}

/// <summary>
/// 获取当前目录下文件列表(不包括文件夹)
/// </summary>
public string[] GetFileList(string url)
{
StringBuilder result = new StringBuilder();
FtpWebRequest reqFTP;
try
{
reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri(url));
reqFTP.UseBinary = true;
reqFTP.Credentials = new NetworkCredential(ftpPassword, ftpPassword);
reqFTP.Method = WebRequestMethods.Ftp.ListDirectoryDetails;
WebResponse response = reqFTP.GetResponse();
StreamReader reader = new StreamReader(response.GetResponseStream());
string line = reader.ReadLine();
while (line != null)
{

if (line.IndexOf("<DIR>") == -)
{
result.Append(Regex.Match(line, @"[\S]+ [\S]+", RegexOptions.IgnoreCase).Value.Split(' ')[]);
result.Append("\n");
}
line = reader.ReadLine();
}
result.Remove(result.ToString().LastIndexOf('\n'), );
reader.Close();
response.Close();
}
catch (Exception ex)
{
throw (ex);
}
return result.ToString().Split('\n');
}

/// <summary>
/// 判断当前目录下指定的文件是否存在
/// </summary>
/// <param name="RemoteFileName">远程文件名</param>
public bool FileExist(string RemoteFileName)
{
string[] fileList = GetFileList("*.*");
foreach (string str in fileList)
{
if (str.Trim() == RemoteFileName.Trim())
{
return true;
}
}
return false;
}

/// <summary>
/// 创建文件夹
/// </summary>
public void MakeDir(string dirName)
{
FtpWebRequest reqFTP;
try
{
reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri(ftpURI + dirName));
reqFTP.Method = WebRequestMethods.Ftp.MakeDirectory;
reqFTP.UseBinary = true;
reqFTP.Credentials = new NetworkCredential(ftpUserID, ftpPassword);
FtpWebResponse response = (FtpWebResponse)reqFTP.GetResponse();
Stream ftpStream = response.GetResponseStream();
ftpStream.Close();
response.Close();
}
catch (Exception ex)
{ }
}

/// <summary>
/// 获取指定文件大小
/// </summary>
public long GetFileSize(string filename)
{
FtpWebRequest reqFTP;
long fileSize = ;
try
{
reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri(ftpURI + filename));
reqFTP.Method = WebRequestMethods.Ftp.GetFileSize;
reqFTP.UseBinary = true;
reqFTP.Credentials = new NetworkCredential(ftpUserID, ftpPassword);
FtpWebResponse response = (FtpWebResponse)reqFTP.GetResponse();
Stream ftpStream = response.GetResponseStream();
fileSize = response.ContentLength;
ftpStream.Close();
response.Close();
}
catch (Exception ex)
{ }
return fileSize;
}

/// <summary>
/// 更改文件名
/// </summary>
public void ReName(string currentFilename, string newFilename)
{
FtpWebRequest reqFTP;
try
{
reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri(ftpURI + currentFilename));
reqFTP.Method = WebRequestMethods.Ftp.Rename;
reqFTP.RenameTo = newFilename;
reqFTP.UseBinary = true;
reqFTP.Credentials = new NetworkCredential(ftpUserID, ftpPassword);
FtpWebResponse response = (FtpWebResponse)reqFTP.GetResponse();
Stream ftpStream = response.GetResponseStream();
ftpStream.Close();
response.Close();
}
catch (Exception ex)
{ }
}

/// <summary>
/// 移动文件
/// </summary>
public void MovieFile(string currentFilename, string newDirectory)
{
ReName(currentFilename, newDirectory);
}

/// <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 + "/" + ftpRemotePath + "/";
}
}
}

using System;
using System.Text;
using System.IO;

namespace DotNet.Dal
{
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 ftpFileName, string localFolder, string localFileName, string BscInfo)
{
string sLine = "";
string sResult = "";
string path = "获得应用程序所在的完整的路径";
path = path.Substring(, 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(, SeekOrigin.Begin);
while (sr.Peek() > -)
{
sLine = sr.ReadToEnd();
}
string[] arStr = sLine.Split(new string[] { "\n" }, StringSplitOptions.RemoveEmptyEntries);

for (int i = ; i < arStr.Length - ; 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 ftpFileName, string localFolder, string localFileName)
{
try
{
if (ftp == null) ftp = this.getFtpClient();
if (!ftp.Connected)
{
ftp.Connect();
ftp.ChDir(ftpFolder);
}
ftp.GetNoBinary(ftpFileName, localFolder, 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;
}
}
}

  using System;
   using System.Net;
   using System.IO;
   using System.Text;
   using System.Net.Sockets;
   using System.Threading;

   namespace DotNet.Dal
   {
  public class FTPClient
  {
  public static object obj = new object();

  #region 构造函数
  /// <summary>
  /// 缺省构造函数
  /// </summary>
  public FTPClient()
  {
  strRemoteHost = "";
  strRemotePath = "";
  strRemoteUser = "";
  strRemotePass = "";
  strRemotePort = ;
  bConnected = false;
  }

  /// <summary>
  /// 构造函数
  /// </summary>
  public FTPClient(string remoteHost, string remotePath, string remoteUser, string remotePass, int remotePort)
  {
  strRemoteHost = remoteHost;
  strRemotePath = remotePath;
  strRemoteUser = remoteUser;
  strRemotePass = remotePass;
  strRemotePort = remotePort;
  Connect();
  }
  #endregion

  #region 字段
  private int strRemotePort;
  private Boolean bConnected;
  private string strRemoteHost;
  private string strRemotePass;
  private string strRemoteUser;
  private string strRemotePath;

  /// <summary>
  /// 服务器返回的应答信息(包含应答码)
  /// </summary>
  private string strMsg;
  /// <summary>
  /// 服务器返回的应答信息(包含应答码)
  /// </summary>
  private string strReply;
  /// <summary>
  /// 服务器返回的应答码
  /// </summary>
  private int iReplyCode;
  /// <summary>
  /// 进行控制连接的socket
  /// </summary>
  private Socket socketControl;
  /// <summary>
  /// 传输模式
  /// </summary>
  private TransferType trType;
  /// <summary>
  /// 接收和发送数据的缓冲区
  /// </summary>
  private static int BLOCK_SIZE = ;
  /// <summary>
  /// 编码方式
  /// </summary>
  Encoding ASCII = Encoding.ASCII;
  /// <summary>
  /// 字节数组
  /// </summary>
  Byte[] buffer = new Byte[BLOCK_SIZE];
  #endregion

  #region 属性
  /// <summary>
  /// FTP服务器IP地址
  /// </summary>
  public string RemoteHost
  {
  get
  {
  return strRemoteHost;
  }
  set
  {
  strRemoteHost = value;
  }
  }

 /// <summary>
 /// FTP服务器端口
 /// </summary>
 public int RemotePort
 {
 get
 {
 return strRemotePort;
 }
 set
 {
 strRemotePort = value;
 }
 }

 /// <summary>
 /// 当前服务器目录
 /// </summary>
 public string RemotePath
 {
 get
 {
 return strRemotePath;
 }
 set
 {
 strRemotePath = value;
 }
 }

 /// <summary>
 /// 登录用户账号
 /// </summary>
 public string RemoteUser
 {
 set
 {
 strRemoteUser = value;
 }
 }

 /// <summary>
 /// 用户登录密码
 /// </summary>
 public string RemotePass
 {
 set
 {
 strRemotePass = value;
 }
 }

 /// <summary>
 /// 是否登录
 /// </summary>
 public bool Connected
 {
 get
 {
 return bConnected;
 }
 }
 #endregion

 #region 链接
 /// <summary>
 /// 建立连接
 /// </summary>
 public void Connect()
 {
 lock (obj)
 {
 socketControl = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
 IPEndPoint ep = new IPEndPoint(IPAddress.Parse(RemoteHost), strRemotePort);
 try
 {
 socketControl.Connect(ep);
 }
 catch (Exception)
 {
 throw new IOException("不能连接ftp服务器");
 }
 }
 ReadReply();
 if (iReplyCode != )
 {
 DisConnect();
 throw new IOException(strReply.Substring());
 }
 SendCommand("USER " + strRemoteUser);
 if (!(iReplyCode ==  || iReplyCode == ))
 {
 CloseSocketConnect();
 throw new IOException(strReply.Substring());
 }
 if (iReplyCode != )
 {
 SendCommand("PASS " + strRemotePass);
 if (!(iReplyCode ==  || iReplyCode == ))
 {
 CloseSocketConnect();
 throw new IOException(strReply.Substring());
 }
 }
 bConnected = true;
 ChDir(strRemotePath);
 }

 /// <summary>
 /// 关闭连接
 /// </summary>
 public void DisConnect()
 {
 if (socketControl != null)
 {
 SendCommand("QUIT");
 }
 CloseSocketConnect();
 }
 #endregion

 #region 传输模式
 /// <summary>
 /// 传输模式:二进制类型、ASCII类型
 /// </summary>
 public enum TransferType { Binary, ASCII };

 /// <summary>
 /// 设置传输模式
 /// </summary>
 /// <param name="ttType">传输模式</param>
 public void SetTransferType(TransferType ttType)
 {
 if (ttType == TransferType.Binary)
 {
 SendCommand("TYPE I");//binary类型传输
 }
 else
 {
 SendCommand("TYPE A");//ASCII类型传输
 }
 if (iReplyCode != )
 {
 throw new IOException(strReply.Substring());
 }
 else
 {
 trType = ttType;
 }
 }

 /// <summary>
 /// 获得传输模式
 /// </summary>
 /// <returns>传输模式</returns>
 public TransferType GetTransferType()
 {
 return trType;
 }
 #endregion

 #region 文件操作
 /// <summary>
 /// 获得文件列表
 /// </summary>
 /// <param name="strMask">文件名的匹配字符串</param>
 public string[] Dir(string strMask)
 {
 if (!bConnected)
 {
 Connect();
 }
 Socket socketData = CreateDataSocket();
 SendCommand("NLST " + strMask);
 if (!(iReplyCode ==  || iReplyCode ==  || iReplyCode == ))
 {
 throw new IOException(strReply.Substring());
 }
 strMsg = "";
 Thread.Sleep();
 while (true)
 {
 int iBytes = socketData.Receive(buffer, buffer.Length, );
 strMsg += ASCII.GetString(buffer, , iBytes);
 if (iBytes < buffer.Length)
 {
 break;
 }
 }
 char[] seperator = { '\n' };
 string[] strsFileList = strMsg.Split(seperator);
 socketData.Close(); //数据socket关闭时也会有返回码
 if (iReplyCode != )
 {
 ReadReply();
 if (iReplyCode != )
 {

 throw new IOException(strReply.Substring());
 }
 }
 return strsFileList;
 }

 public void newPutByGuid(string strFileName, string strGuid)
 {
 if (!bConnected)
 {
 Connect();
 }
 string str = strFileName.Substring(, strFileName.LastIndexOf("\\"));
 string strTypeName = strFileName.Substring(strFileName.LastIndexOf("."));
 strGuid = str + "\\" + strGuid;
 Socket socketData = CreateDataSocket();
 SendCommand("STOR " + Path.GetFileName(strGuid));
 if (!(iReplyCode ==  || iReplyCode == ))
 {
 throw new IOException(strReply.Substring());
 }
 FileStream input = new FileStream(strGuid, FileMode.Open);
 input.Flush();
 int iBytes = ;
 while ((iBytes = input.Read(buffer, , buffer.Length)) > )
 {
 socketData.Send(buffer, iBytes, );
 }
 input.Close();
 if (socketData.Connected)
 {
 socketData.Close();
 }
 if (!(iReplyCode ==  || iReplyCode == ))
 {
 ReadReply();
 if (!(iReplyCode ==  || iReplyCode == ))
 {
 throw new IOException(strReply.Substring());
 }
 }
 }

 /// <summary>
 /// 获取文件大小
 /// </summary>
 /// <param name="strFileName">文件名</param>
 /// <returns>文件大小</returns>
 public long GetFileSize(string strFileName)
 {
 if (!bConnected)
 {
 Connect();
 }
 SendCommand("SIZE " + Path.GetFileName(strFileName));
 long lSize = ;
 if (iReplyCode == )
 {
 lSize = Int64.Parse(strReply.Substring());
 }
 else
 {
 throw new IOException(strReply.Substring());
 }
 return lSize;
 }

 /// <summary>
 /// 获取文件信息
 /// </summary>
 /// <param name="strFileName">文件名</param>
 /// <returns>文件大小</returns>
 public string GetFileInfo(string strFileName)
 {
 if (!bConnected)
 {
 Connect();
 }
 Socket socketData = CreateDataSocket();
 SendCommand("LIST " + strFileName);
 string strResult = "";
 if (!(iReplyCode ==  || iReplyCode ==
 || iReplyCode ==  || iReplyCode == ))
 {
 throw new IOException(strReply.Substring());
 }
 byte[] b = new byte[];
 MemoryStream ms = new MemoryStream();

 while (true)
 {
 int iBytes = socketData.Receive(b, b.Length, );
 ms.Write(b, , iBytes);
 if (iBytes <= )
 {

 break;
 }
 }
 byte[] bt = ms.GetBuffer();
 strResult = System.Text.Encoding.ASCII.GetString(bt);
 ms.Close();
 return strResult;
 }

 /// <summary>
 /// 删除
 /// </summary>
 /// <param name="strFileName">待删除文件名</param>
 public void Delete(string strFileName)
 {
 if (!bConnected)
 {
 Connect();
 }
 SendCommand("DELE " + strFileName);
 if (iReplyCode != )
 {
 throw new IOException(strReply.Substring());
 }
 }

 /// <summary>
 /// 重命名(如果新文件名与已有文件重名,将覆盖已有文件)
 /// </summary>
 /// <param name="strOldFileName">旧文件名</param>
 /// <param name="strNewFileName">新文件名</param>
 public void Rename(string strOldFileName, string strNewFileName)
 {
 if (!bConnected)
 {
 Connect();
 }
 SendCommand("RNFR " + strOldFileName);
 if (iReplyCode != )
 {
 throw new IOException(strReply.Substring());
 }
 // 如果新文件名与原有文件重名,将覆盖原有文件
 SendCommand("RNTO " + strNewFileName);
 if (iReplyCode != )
 {
 throw new IOException(strReply.Substring());
 }
 }
 #endregion

 #region 上传和下载
 /// <summary>
 /// 下载一批文件
 /// </summary>
 /// <param name="strFileNameMask">文件名的匹配字符串</param>
 /// <param name="strFolder">本地目录(不得以\结束)</param>
 public void Get(string strFileNameMask, string strFolder)
 {
 if (!bConnected)
 {
 Connect();
 }
 string[] strFiles = Dir(strFileNameMask);
 foreach (string strFile in strFiles)
 {
 if (!strFile.Equals(""))//一般来说strFiles的最后一个元素可能是空字符串
 {
 Get(strFile, strFolder, strFile);
 }
 }
 }

 /// <summary>
 /// 下载一个文件
 /// </summary>
 /// <param name="strRemoteFileName">要下载的文件名</param>
 /// <param name="strFolder">本地目录(不得以\结束)</param>
 /// <param name="strLocalFileName">保存在本地时的文件名</param>
 public void Get(string strRemoteFileName, string strFolder, string strLocalFileName)
 {
 Socket socketData = CreateDataSocket();
 try
 {
 if (!bConnected)
 {
 Connect();
 }
 SetTransferType(TransferType.Binary);
 if (strLocalFileName.Equals(""))
 {
 strLocalFileName = strRemoteFileName;
 }
 SendCommand("RETR " + strRemoteFileName);
 if (!(iReplyCode ==  || iReplyCode ==  || iReplyCode ==  || iReplyCode == ))
 {
 throw new IOException(strReply.Substring());
 }
 FileStream output = new FileStream(strFolder + "\\" + strLocalFileName, FileMode.Create);
 while (true)
 {
 int iBytes = socketData.Receive(buffer, buffer.Length, );
 output.Write(buffer, , iBytes);
 if (iBytes <= )
 {
 break;
 }
 }
 output.Close();
 if (socketData.Connected)
 {
 socketData.Close();
 }
 if (!(iReplyCode ==  || iReplyCode == ))
 {
 ReadReply();
 if (!(iReplyCode ==  || iReplyCode == ))
 {
 throw new IOException(strReply.Substring());
 }
 }
 }
 catch
 {
 socketData.Close();
 socketData = null;
 socketControl.Close();
 bConnected = false;
 socketControl = null;
 }
 }

 /// <summary>
 /// 下载一个文件
 /// </summary>
 /// <param name="strRemoteFileName">要下载的文件名</param>
 /// <param name="strFolder">本地目录(不得以\结束)</param>
 /// <param name="strLocalFileName">保存在本地时的文件名</param>
 public void GetNoBinary(string strRemoteFileName, string strFolder, string strLocalFileName)
 {
 if (!bConnected)
 {
 Connect();
 }

 if (strLocalFileName.Equals(""))
 {
 strLocalFileName = strRemoteFileName;
 }
 Socket socketData = CreateDataSocket();
 SendCommand("RETR " + strRemoteFileName);
 if (!(iReplyCode ==  || iReplyCode ==  || iReplyCode ==  || iReplyCode == ))
 {
 throw new IOException(strReply.Substring());
 }
 FileStream output = new FileStream(strFolder + "\\" + strLocalFileName, FileMode.Create);
 while (true)
 {
 int iBytes = socketData.Receive(buffer, buffer.Length, );
 output.Write(buffer, , iBytes);
 if (iBytes <= )
 {
 break;
 }
 }
 output.Close();
 if (socketData.Connected)
 {
 socketData.Close();
 }
 if (!(iReplyCode ==  || iReplyCode == ))
 {
 ReadReply();
 if (!(iReplyCode ==  || iReplyCode == ))
 {
 throw new IOException(strReply.Substring());
 }
 }
 }

 /// <summary>
 /// 上传一批文件
 /// </summary>
 /// <param name="strFolder">本地目录(不得以\结束)</param>
 /// <param name="strFileNameMask">文件名匹配字符(可以包含*和?)</param>
 public void Put(string strFolder, string strFileNameMask)
 {
 string[] strFiles = Directory.GetFiles(strFolder, strFileNameMask);
 foreach (string strFile in strFiles)
 {
 Put(strFile);
 }
 }

 /// <summary>
 /// 上传一个文件
 /// </summary>
 /// <param name="strFileName">本地文件名</param>
 public void Put(string strFileName)
 {
 if (!bConnected)
 {
 Connect();
 }
 Socket socketData = CreateDataSocket();
 if (Path.GetExtension(strFileName) == "")
 SendCommand("STOR " + Path.GetFileNameWithoutExtension(strFileName));
 else
 SendCommand("STOR " + Path.GetFileName(strFileName));

 if (!(iReplyCode ==  || iReplyCode == ))
 {
 throw new IOException(strReply.Substring());
 }

 FileStream input = new FileStream(strFileName, FileMode.Open);
 int iBytes = ;
 while ((iBytes = input.Read(buffer, , buffer.Length)) > )
 {
 socketData.Send(buffer, iBytes, );
 }
 input.Close();
 if (socketData.Connected)
 {
 socketData.Close();
 }
 if (!(iReplyCode ==  || iReplyCode == ))
 {
 ReadReply();
 if (!(iReplyCode ==  || iReplyCode == ))
 {
 throw new IOException(strReply.Substring());
 }
 }
 }

 /// <summary>
 /// 上传一个文件
 /// </summary>
 /// <param name="strFileName">本地文件名</param>
 public void PutByGuid(string strFileName, string strGuid)
 {
 if (!bConnected)
 {
 Connect();
 }
 string str = strFileName.Substring(, strFileName.LastIndexOf("\\"));
 string strTypeName = strFileName.Substring(strFileName.LastIndexOf("."));
 strGuid = str + "\\" + strGuid;
 System.IO.File.Copy(strFileName, strGuid);
 System.IO.File.SetAttributes(strGuid, System.IO.FileAttributes.Normal);
 Socket socketData = CreateDataSocket();
 SendCommand("STOR " + Path.GetFileName(strGuid));
 if (!(iReplyCode ==  || iReplyCode == ))
 {
 throw new IOException(strReply.Substring());
 }
 FileStream input = new FileStream(strGuid, FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.Read);
 int iBytes = ;
 while ((iBytes = input.Read(buffer, , buffer.Length)) > )
 {
 socketData.Send(buffer, iBytes, );
 }
 input.Close();
 File.Delete(strGuid);
 if (socketData.Connected)
 {
 socketData.Close();
 }
 if (!(iReplyCode ==  || iReplyCode == ))
 {
 ReadReply();
 if (!(iReplyCode ==  || iReplyCode == ))
 {
 throw new IOException(strReply.Substring());
 }
 }
 }
 #endregion

 #region 目录操作
 /// <summary>
 /// 创建目录
 /// </summary>
 /// <param name="strDirName">目录名</param>
 public void MkDir(string strDirName)
 {
 if (!bConnected)
 {
 Connect();
 }
 SendCommand("MKD " + strDirName);
 if (iReplyCode != )
 {
 throw new IOException(strReply.Substring());
 }
 }

 /// <summary>
 /// 删除目录
 /// </summary>
 /// <param name="strDirName">目录名</param>
 public void RmDir(string strDirName)
 {
 if (!bConnected)
 {
 Connect();
 }
 SendCommand("RMD " + strDirName);
 if (iReplyCode != )
 {
 throw new IOException(strReply.Substring());
 }
 }

 /// <summary>
 /// 改变目录
 /// </summary>
 /// <param name="strDirName">新的工作目录名</param>
 public void ChDir(string strDirName)
 {
 if (strDirName.Equals(".") || strDirName.Equals(""))
 {
 return;
 }
 if (!bConnected)
 {
 Connect();
 }
 SendCommand("CWD " + strDirName);
 if (iReplyCode != )
 {
 throw new IOException(strReply.Substring());
 }
 this.strRemotePath = strDirName;
 }
 #endregion

 #region 内部函数
 /// <summary>
 /// 将一行应答字符串记录在strReply和strMsg,应答码记录在iReplyCode
 /// </summary>
 private void ReadReply()
 {
 strMsg = "";
 strReply = ReadLine();
 iReplyCode = Int32.Parse(strReply.Substring(, ));
 }

 /// <summary>
 /// 建立进行数据连接的socket
 /// </summary>
 /// <returns>数据连接socket</returns>
 private Socket CreateDataSocket()
 {
 SendCommand("PASV");
 if (iReplyCode != )
 {
 throw new IOException(strReply.Substring());
 }
 int index1 = strReply.IndexOf('(');
 int index2 = strReply.IndexOf(')');
 string ipData = strReply.Substring(index1 + , index2 - index1 - );
 int[] parts = new int[];
 int len = ipData.Length;
 int partCount = ;
 string buf = "";
 for (int i = ; i < len && partCount <= ; i++)
 {
 char ch = Char.Parse(ipData.Substring(i, ));
 if (Char.IsDigit(ch))
 buf += ch;
 else if (ch != ',')
 {
 throw new IOException("Malformed PASV strReply: " + strReply);
 }
 if (ch == ',' || i +  == len)
 {
 try
 {
 parts[partCount++] = Int32.Parse(buf);
 buf = "";
 }
 catch (Exception)
 {
 throw new IOException("Malformed PASV strReply: " + strReply);
 }
 }
 }
 string ipAddress = parts[] + "." + parts[] + "." + parts[] + "." + parts[];
 int port = (parts[] << ) + parts[];
 Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
 IPEndPoint ep = new IPEndPoint(IPAddress.Parse(ipAddress), port);
 try
 {
 s.Connect(ep);
 }
 catch (Exception)
 {
 throw new IOException("无法连接ftp服务器");
 }
 return s;
 }

 /// <summary>
 /// 关闭socket连接(用于登录以前)
 /// </summary>
 private void CloseSocketConnect()
 {
 lock (obj)
 {
 if (socketControl != null)
 {
 socketControl.Close();
 socketControl = null;
 }
 bConnected = false;
 }
 }

 /// <summary>
 /// 读取Socket返回的所有字符串
 /// </summary>
 /// <returns>包含应答码的字符串行</returns>
 private string ReadLine()
 {
 lock (obj)
 {
 while (true)
 {
 int iBytes = socketControl.Receive(buffer, buffer.Length, );
 strMsg += ASCII.GetString(buffer, , iBytes);
 if (iBytes < buffer.Length)
 {
 break;
 }
 }
 }
 char[] seperator = { '\n' };
 string[] mess = strMsg.Split(seperator);
 if (strMsg.Length > )
 {
 strMsg = mess[mess.Length - ];
 }
 else
 {
 strMsg = mess[];
 }
 if (!strMsg.Substring(, ).Equals(" ")) //返回字符串正确的是以应答码(如220开头,后面接一空格,再接问候字符串)
 {
 return ReadLine();
 }
 return strMsg;
 }

 /// <summary>
 /// 发送命令并获取应答码和最后一行应答字符串
 /// </summary>
 /// <param name="strCommand">命令</param>
 public void SendCommand(String strCommand)
 {
 lock (obj)
 {
 Byte[] cmdBytes = Encoding.ASCII.GetBytes((strCommand + "\r\n").ToCharArray());
 socketControl.Send(cmdBytes, cmdBytes.Length, );
 Thread.Sleep();
 ReadReply();
 }
 }
 #endregion
 }
 }

http://www.cnblogs.com/sufei/archive/2012/12/09/2810197.html

QQ群：108845298，期待你的加入