FTP客户端库文件C＃源码 (有两篇，第三篇支持中文)

第一篇
作者: Jaimon Mathew

This is the C# version of an FTP client library which is originally written in Java. The library will be compiled to a DLL file. A test program is also included to show the usage of this library. You will get more details about FTP from its rfc. Most of the commands are supported here. File upload & download methods are capable enough of doing resuming also.

The given test program is a console based application. I inviting somebody on the net to develop a front end application with this library.

/*
FTPFactory.cs
Better view with tab space=4

Written by Jaimon Mathew ([e-mail])
Rolander,Dan ([e-mail]) has modified the 
download
method to cope with file name with path information. He also 
provided
the XML comments so that the library provides Intellisense 
descriptions.

use the following line to compile
csc /target:library /out:FTPLib.dll /r:System.DLL FTPFactory.cs
*/

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

namespace FtpLib
{

   public class FTPFactory
   {

     private string 
remoteHost,remotePath,remoteUser,remotePass,mes;
     private int remotePort,bytes;
     private Socket clientSocket;

     private int retValue;
     private Boolean debug;
     private Boolean logined;
     private string reply;

     private static int BLOCK_SIZE = 512;

     Byte[] buffer = new Byte[BLOCK_SIZE];
     Encoding ASCII = Encoding.ASCII;

     public FTPFactory()
     {

       remoteHost  = "localhost";
       remotePath  = ".";
       remoteUser  = "anonymous";
       remotePass  = "[e-mail]";
       remotePort  = 21;
       debug     = false;
       logined    = false;

     }

     ///
     /// Set the name of the FTP server to connect to.
     ///
     /// Server name
     public void setRemoteHost(string remoteHost)
     {
       this.remoteHost = remoteHost;
     }

     ///
     /// Return the name of the current FTP server.
     ///
     /// Server name
     public string getRemoteHost()
     {
       return remoteHost;
     }

     ///
     /// Set the port number to use for FTP.
     ///
     /// Port number
     public void setRemotePort(int remotePort)
     {
       this.remotePort = remotePort;
     }

     ///
     /// Return the current port number.
     ///
     /// Current port number
     public int getRemotePort()
     {
       return remotePort;
     }

     ///
     /// Set the remote directory path.
     ///
     /// The remote directory path
     public void setRemotePath(string remotePath)
     {
       this.remotePath = remotePath;
     }

     ///
     /// Return the current remote directory path.
     ///
     /// The current remote directory path.
     public string getRemotePath()
     {
       return remotePath;
     }

     ///
     /// Set the user name to use for logging into the remote 
server.
     ///
     /// Username
     public void setRemoteUser(string remoteUser)
     {
       this.remoteUser = remoteUser;
     }

     ///
     /// Set the password to user for logging into the remote 
server.
     ///
     /// Password
     public void setRemotePass(string remotePass)
     {
       this.remotePass = remotePass;
     }

     ///
     /// Return a string array containing the remote directory's 
file list.
     ///
     ///
     ///
     public string[] getFileList(string mask)
     {

       if(!logined)
       {
         login();
       }

       Socket cSocket = createDataSocket();

       sendCommand("NLST " + mask);

       if(!(retValue == 150 || retValue == 125))
       {
         throw new IOException(reply.Substring(4));
       }

       mes = "";

       while(true)
       {

         int bytes = cSocket.Receive(buffer, buffer.Length, 0);
         mes += ASCII.GetString(buffer, 0, bytes);

         if(bytes < buffer.Length)
         {
           break;
         }
       }

       char[] seperator = {'\n'};
       string[] mess = mes.Split(seperator);

       cSocket.Close();

       readReply();

       if(retValue != 226)
       {
         throw new IOException(reply.Substring(4));
       }
       return mess;

     }

     ///
     /// Return the size of a file.
     ///
     ///
     ///
     public long getFileSize(string fileName)
     {

       if(!logined)
       {
         login();
       }

       sendCommand("SIZE " + fileName);
       long size=0;

       if(retValue == 213)
       {
         size = Int64.Parse(reply.Substring(4));
       }
       else
       {
         throw new IOException(reply.Substring(4));
       }

       return size;

     }

     ///
     /// Login to the remote server.
     ///
     public void login()
     {

       clientSocket = new 
Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
       IPEndPoint ep = new 
IPEndPoint(Dns.Resolve(remoteHost).AddressList[0], remotePort);

       try
       {
         clientSocket.Connect(ep);
       }
       catch(Exception)
       {
         throw new IOException("Couldn't connect to remote 
server");
       }

       readReply();
       if(retValue != 220)
       {
         close();
         throw new IOException(reply.Substring(4));
       }
       if(debug)
         Console.WriteLine("USER "+remoteUser);

       sendCommand("USER "+remoteUser);

       if( !(retValue == 331 || retValue == 230) )
       {
         cleanup();
         throw new IOException(reply.Substring(4));
       }

       if( retValue != 230 )
       {
         if(debug)
           Console.WriteLine("PASS xxx");

         sendCommand("PASS "+remotePass);
         if( !(retValue == 230 || retValue == 202) )
         {
           cleanup();
           throw new IOException(reply.Substring(4));
         }
       }

       logined = true;
       Console.WriteLine("Connected to "+remoteHost);

       chdir(remotePath);

     }

     ///
     /// If the value of mode is true, set binary mode for 
downloads.
     /// Else, set Ascii mode.
     ///
     ///
     public void setBinaryMode(Boolean mode)
     {

       if(mode)
       {
         sendCommand("TYPE I");
       }
       else
       {
         sendCommand("TYPE A");
       }
       if (retValue != 200)
       {
         throw new IOException(reply.Substring(4));
       }
     }

     ///
     /// Download a file to the Assembly's local directory,
     /// keeping the same file name.
     ///
     ///
     public void download(string remFileName)
     {
       download(remFileName,"",false);
     }

     ///
     /// Download a remote file to the Assembly's local 
directory,
     /// keeping the same file name, and set the resume flag.
     ///
     ///
     ///
     public void download(string remFileName,Boolean resume)
     {
       download(remFileName,"",resume);
     }

     ///
     /// Download a remote file to a local file name which can 
include
     /// a path. The local file name will be created or 
overwritten,
     /// but the path must exist.
     ///
     ///
     ///
     public void download(string remFileName,string locFileName)
     {
       download(remFileName,locFileName,false);
     }

     ///
     /// Download a remote file to a local file name which can 
include
     /// a path, and set the resume flag. The local file name will 
be
     /// created or overwritten, but the path must exist.
     ///
     ///
     ///
     ///
     public void download(string remFileName,string 
locFileName,Boolean resume)
     {
       if(!logined)
       {
         login();
       }

       setBinaryMode(true);

       Console.WriteLine("Downloading file "+remFileName+" from 
"+remoteHost + "/"+remotePath);

       if (locFileName.Equals(""))
       {
         locFileName = remFileName;
       }

       if(!File.Exists(locFileName))
       {
         Stream st = File.Create(locFileName);
         st.Close();
       }

       FileStream output = new 
FileStream(locFileName,FileMode.Open);

       Socket cSocket = createDataSocket();

       long offset = 0;

       if(resume)
       {

         offset = output.Length;

         if(offset > 0 )
         {
           sendCommand("REST "+offset);
           if(retValue != 350)
           {
             //throw new IOException(reply.Substring(4));
             //Some servers may not support resuming.
             offset = 0;
           }
         }

         if(offset > 0)
         {
           if(debug)
           {
             Console.WriteLine("seeking to " + offset);
           }
           long npos = output.Seek(offset,SeekOrigin.Begin);
           Console.WriteLine("new pos="+npos);
         }
       }

       sendCommand("RETR " + remFileName);

       if(!(retValue == 150 || retValue == 125))
       {
         throw new IOException(reply.Substring(4));
       }

       while(true)
       {

         bytes = cSocket.Receive(buffer, buffer.Length, 0);
         output.Write(buffer,0,bytes);

         if(bytes <= 0)
         {
           break;
         }
       }

       output.Close();
       if (cSocket.Connected)
       {
           cSocket.Close();
       }

       Console.WriteLine("");

       readReply();

       if( !(retValue == 226 || retValue == 250) )
       {
         throw new IOException(reply.Substring(4));
       }

     }

     ///
     /// Upload a file.
     ///
     ///
     public void upload(string fileName)
     {
       upload(fileName,false);
     }

     ///
     /// Upload a file and set the resume flag.
     ///
     ///
     ///
     public void upload(string fileName,Boolean resume)
     {

       if(!logined)
       {
         login();
       }

       Socket cSocket = createDataSocket();
       long offset=0;

       if(resume)
       {

         try
         {

           setBinaryMode(true);
           offset = getFileSize(fileName);

         }
         catch(Exception)
         {
           offset = 0;
         }
       }

       if(offset > 0 )
       {
         sendCommand("REST " + offset);
         if(retValue != 350)
         {
           //throw new IOException(reply.Substring(4));
           //Remote server may not support resuming.
           offset = 0;
         }
       }

       sendCommand("STOR "+Path.GetFileName(fileName));

       if( !(retValue == 125 || retValue == 150) )
       {
         throw new IOException(reply.Substring(4));
       }

       // open input stream to read source file
       FileStream input = new 
FileStream(fileName,FileMode.Open);

       if(offset != 0)
       {

         if(debug)
         {
           Console.WriteLine("seeking to " + offset);
         }
         input.Seek(offset,SeekOrigin.Begin);
       }

       Console.WriteLine("Uploading file "+fileName+" to 
"+remotePath);

       while ((bytes = input.Read(buffer,0,buffer.Length)) > 0)
       {

         cSocket.Send(buffer, bytes, 0);

       }
       input.Close();

       Console.WriteLine("");

       if (cSocket.Connected)
       {
           cSocket.Close();
       }

       readReply();
       if( !(retValue == 226 || retValue == 250) )
       {
         throw new IOException(reply.Substring(4));
       }
     }

     ///
     /// Delete a file from the remote FTP server.
     ///
     ///
     public void deleteRemoteFile(string fileName)
     {

       if(!logined)
       {
         login();
       }

       sendCommand("DELE "+fileName);

       if(retValue != 250)
       {
         throw new IOException(reply.Substring(4));
       }

     }

     ///
     /// Rename a file on the remote FTP server.
     ///
     ///
     ///
     public void renameRemoteFile(string oldFileName,string 
newFileName)
     {

       if(!logined)
       {
         login();
       }

       sendCommand("RNFR "+oldFileName);

       if(retValue != 350)
       {
         throw new IOException(reply.Substring(4));
       }

       //  known problem
       //  rnto will not take care of existing file.
       //  i.e. It will overwrite if newFileName exist
       sendCommand("RNTO "+newFileName);
       if(retValue != 250)
       {
         throw new IOException(reply.Substring(4));
       }

     }

     ///
     /// Create a directory on the remote FTP server.
     ///
     ///
     public void mkdir(string dirName)
     {

       if(!logined)
       {
         login();
       }

       sendCommand("MKD "+dirName);

       if(retValue != 250)
       {
         throw new IOException(reply.Substring(4));
       }

     }

     ///
     /// Delete a directory on the remote FTP server.
     ///
     ///
     public void rmdir(string dirName)
     {

       if(!logined)
       {
         login();
       }

       sendCommand("RMD "+dirName);

       if(retValue != 250)
       {
         throw new IOException(reply.Substring(4));
       }

     }

     ///
     /// Change the current working directory on the remote FTP 
server.
     ///
     ///
     public void chdir(string dirName)
     {

       if(dirName.Equals("."))
       {
         return;
       }

       if(!logined)
       {
         login();
       }

       sendCommand("CWD "+dirName);

       if(retValue != 250)
       {
         throw new IOException(reply.Substring(4));
       }

       this.remotePath = dirName;

       Console.WriteLine("Current directory is "+remotePath);

     }

     ///
     /// Close the FTP connection.
     ///
     public void close()
     {

       if( clientSocket != null )
       {
         sendCommand("QUIT");
       }

       cleanup();
       Console.WriteLine("Closing...");
     }

     ///
     /// Set debug mode.
     ///
     ///
     public void setDebug(Boolean debug)
     {
       this.debug = debug;
     }

     private void readReply()
     {
       mes = "";
       reply = readLine();
       retValue = Int32.Parse(reply.Substring(0,3));
     }

     private void cleanup()
     {
       if(clientSocket!=null)
       {
         clientSocket.Close();
         clientSocket = null;
       }
       logined = false;
     }

     private string readLine()
     {

       while(true)
       {
         bytes = clientSocket.Receive(buffer, buffer.Length, 0);
         mes += ASCII.GetString(buffer, 0, bytes);
         if(bytes < buffer.Length)
         {
           break;
         }
       }

       char[] seperator = {'\n'};
       string[] mess = mes.Split(seperator);

       if(mes.Length > 2)
       {
         mes = mess[mess.Length-2];
       }
       else
       {
         mes = mess[0];
       }

       if(!mes.Substring(3,1).Equals(" "))
       {
         return readLine();
       }

       if(debug)
       {
         for(int k=0;k < mess.Length-1;k++)
         {
           Console.WriteLine(mess[k]);
         }
       }
       return mes;
     }

     private void sendCommand(String command)
     {

       Byte[] cmdBytes = 
Encoding.ASCII.GetBytes((command+"\r\n").ToCharArray());
       clientSocket.Send(cmdBytes, cmdBytes.Length, 0);
       readReply();
     }

     private Socket createDataSocket()
     {

       sendCommand("PASV");

       if(retValue != 227)
       {
         throw new IOException(reply.Substring(4));
       }

       int index1 = reply.IndexOf('(');
       int index2 = reply.IndexOf(')');
       string ipData = 
reply.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 <= 6; i++)
       {

         char ch = Char.Parse(ipData.Substring(i,1));
         if (Char.IsDigit(ch))
           buf+=ch;
         else if (ch != ',')
         {
           throw new IOException("Malformed PASV reply: " + 
reply);
         }

         if (ch == ',' || i+1 == len)
         {

           try
           {
             parts[partCount++] = Int32.Parse(buf);
             buf="";
           }
           catch (Exception)
           {
             throw new IOException("Malformed PASV reply: " + 
reply);
           }
         }
       }

       string ipAddress = parts[0] + "."+ parts[1]+ "." +
         parts[2] + "." + parts[3];

       int port = (parts[4] << 8) + parts[5];

       Socket s = new 
Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
       IPEndPoint ep = new 
IPEndPoint(Dns.Resolve(ipAddress).AddressList[0], port);

       try
       {
         s.Connect(ep);
       }
       catch(Exception)
       {
         throw new IOException("Can't connect to remote 
server");
       }

       return s;
     }

   }
}


Following is the listing of a test program which uses this 
library

/*

File : Test.cs
Better view with tab space=4
use the following line to compile
csc.exe /t:exe /r:System.DLL /r:FTPLib.dll /out:"Test.exe" 
"Test.cs"

*/
using System;
using FtpLib;

public class Test {

   public static void Main() {

     try {

       Console.WriteLine("Starting...");

       FTPFactory ff = new FTPFactory();
       ff.setDebug(true);
       ff.setRemoteHost("192.168.0.30");
       ff.setRemoteUser("jaimon");
       ff.setRemotePass("mathew");
       ff.login();
       ff.chdir("incoming");

       string[] fileNames = ff.getFileList("*.*");
       for(int i=0;i < fileNames.Length;i++) {
         Console.WriteLine(fileNames[i]);
       }

       ff.setBinaryMode(true);
       ff.upload("c:\jaimon\tmp\Webdunia.ttf");
       ff.close();

     }catch(Exception e) {
       Console.WriteLine("Caught Error :"+e.Message);
     }
   }
}

第二篇

基本原理就是先建立Socket连接，然后发请求命令和取回应答码。编码方式采用EncodingASCII=Encoding.Default;来支持中文文件名。
usingSystem;
usingSystem.Net;
usingSystem.Net.Sockets;
usingSystem.Text;
usingSystem.IO; 
namespaceKostech.Net
{
///<summary>
///FTP的摘要说明。
///</summary>
publicclassFTP
{
privatestringstrRemoteHost;
privateintstrRemotePort;
privatestringstrRemotePath;
privatestringstrRemoteUser;
privatestringstrRemotePass;
privateBooleanbConnected;
#region内部变量
///<summary>
///服务器返回的应答信息(包含应答码)
///</summary>
privatestringstrMsg;
///<summary>
///服务器返回的应答信息(包含应答码)
///</summary>
privatestringstrReply;
///<summary>
///服务器返回的应答码
///</summary>
privateintiReplyCode;
///<summary>
///进行控制连接的socket
///</summary>
privateSocketsocketControl;
///<summary>
///传输模式
///</summary>
privateTransferTypetrType;
///<summary>
///传输模式:二进制类型、ASCII类型
///</summary>
publicenumTransferType
{
///<summary>
///Binary
///</summary>
Binary,
///<summary>
///ASCII
///</summary>
ASCII
};
///<summary>
///接收和发送数据的缓冲区
///</summary>
privatestaticintBLOCK_SIZE=512;
Byte[]buffer=newByte[BLOCK_SIZE];
///<summary>
///编码方式
///</summary>
EncodingASCII=Encoding.Default;
#endregion
#region内部函数

#region构造函数
///<summary>
///缺省构造函数
///</summary>
publicFTP()
{
strRemoteHost="";
strRemotePath="";
strRemoteUser="";
strRemotePass="";
strRemotePort=21;
bConnected=false;
}
///<summary>
///构造函数
///</summary>
///<paramname="remoteHost"></param>
///<paramname="remotePath"></param>
///<paramname="remoteUser"></param>
///<paramname="remotePass"></param>
///<paramname="remotePort"></param>
publicFTP(stringremoteHost,stringremotePath,stringremoteUser,stringremotePass,intremotePort)
{
strRemoteHost=remoteHost;
strRemotePath=remotePath;
strRemoteUser=remoteUser;
strRemotePass=remotePass;
strRemotePort=remotePort;
Connect();
}
#endregion
#region登陆
///<summary>
///FTP服务器IP地址
///</summary>

publicstringRemoteHost
{
get
{
returnstrRemoteHost;
}
set
{
strRemoteHost=value;
}
}
///<summary>
///FTP服务器端口
///</summary>
publicintRemotePort
{
get
{
returnstrRemotePort;
}
set
{
strRemotePort=value;
}
}
///<summary>
///当前服务器目录
///</summary>
publicstringRemotePath
{
get
{
returnstrRemotePath;
}
set
{
strRemotePath=value;
}
}
///<summary>
///登录用户账号
///</summary>
publicstringRemoteUser
{
set
{
strRemoteUser=value;
}
}
///<summary>
///用户登录密码
///</summary>
publicstringRemotePass
{
set
{
strRemotePass=value;
}
}
///<summary>
///是否登录
///</summary>
publicboolConnected
{
get
{
returnbConnected;
}
}
#endregion
#region链接
///<summary>
///建立连接
///</summary>
publicvoidConnect()
{
socketControl=newSocket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
IPEndPointep=newIPEndPoint(IPAddress.Parse(RemoteHost),strRemotePort);
//链接
try
{
socketControl.Connect(ep);
}
catch(Exception)
{
thrownewIOException("Couldn'tconnecttoremoteserver");
}
//获取应答码
ReadReply();
if(iReplyCode!=220)
{
DisConnect();
thrownewIOException(strReply.Substring(4));
}
//登陆
SendCommand("USER"+strRemoteUser);
if(!(iReplyCode==331||iReplyCode==230))
{
CloseSocketConnect();//关闭连接
thrownewIOException(strReply.Substring(4));
}
if(iReplyCode!=230)
{
SendCommand("PASS"+strRemotePass);
if(!(iReplyCode==230||iReplyCode==202))
{
CloseSocketConnect();//关闭连接
thrownewIOException(strReply.Substring(4));
}
}
bConnected=true;
//切换到目录
ChDir(strRemotePath);
}

///<summary>
///关闭连接
///</summary>
publicvoidDisConnect()
{
if(socketControl!=null)
{
SendCommand("QUIT");
}
CloseSocketConnect();
}
#endregion
#region传输模式
///<summary>
///设置传输模式
///</summary>
///<paramname="ttType">传输模式</param>
publicvoidSetTransferType(TransferTypettType)
{
if(ttType==TransferType.Binary)
{
SendCommand("TYPEI");//binary类型传输
}
else
{
SendCommand("TYPEA");//ASCII类型传输
}
if(iReplyCode!=200)
{
thrownewIOException(strReply.Substring(4));
}
else
{
trType=ttType;
}
}

///<summary>
///获得传输模式
///</summary>
///<returns>传输模式</returns>
publicTransferTypeGetTransferType()
{
returntrType;
}
#endregion
#region文件操作
///<summary>
///获得文件列表
///</summary>
///<paramname="strMask">文件名的匹配字符串</param>
///<returns></returns>
publicstring[]Dir(stringstrMask)
{
//建立链接
if(!bConnected)
{
Connect();
}
//建立进行数据连接的socket
SocketsocketData=CreateDataSocket();
//传送命令
SendCommand("NLST"+strMask);
//分析应答代码
if(!(iReplyCode==150||iReplyCode==125||iReplyCode==226))
{
thrownewIOException(strReply.Substring(4));
}
//获得结果
strMsg="";
while(true)
{
intiBytes=socketData.Receive(buffer,buffer.Length,0);
strMsg+=ASCII.GetString(buffer,0,iBytes);
if(iBytes<buffer.Length)
{
break;
}
}
char[]seperator={'\n'};
string[]strsFileList=strMsg.Split(seperator);
socketData.Close();//数据socket关闭时也会有返回码
if(iReplyCode!=226)
{
ReadReply();
if(iReplyCode!=226)
{
thrownewIOException(strReply.Substring(4));
}
}
returnstrsFileList;
}

///<summary>
///获取文件大小
///</summary>
///<paramname="strFileName">文件名</param>
///<returns>文件大小</returns>
privatelongGetFileSize(stringstrFileName)
{
if(!bConnected)
{
Connect();
}
SendCommand("SIZE"+Path.GetFileName(strFileName));
longlSize=0;
if(iReplyCode==213)
{
lSize=Int64.Parse(strReply.Substring(4));
}
else
{
thrownewIOException(strReply.Substring(4));
}
returnlSize;
}

///<summary>
///删除
///</summary>
///<paramname="strFileName">待删除文件名</param>
publicvoidDelete(stringstrFileName)
{
if(!bConnected)
{
Connect();
}
SendCommand("DELE"+strFileName);
if(iReplyCode!=250)
{
thrownewIOException(strReply.Substring(4));
}
}

///<summary>
///重命名(如果新文件名与已有文件重名,将覆盖已有文件)
///</summary>
///<paramname="strOldFileName">旧文件名</param>
///<paramname="strNewFileName">新文件名</param>
publicvoidRename(stringstrOldFileName,stringstrNewFileName)
{
if(!bConnected)
{
Connect();
}
SendCommand("RNFR"+strOldFileName);
if(iReplyCode!=350)
{
thrownewIOException(strReply.Substring(4));
}
//如果新文件名与原有文件重名,将覆盖原有文件
SendCommand("RNTO"+strNewFileName);
if(iReplyCode!=250)
{
thrownewIOException(strReply.Substring(4));
}
}
#endregion
#region上传和下载
///<summary>
///下载一批文件
///</summary>
///<paramname="strFileNameMask">文件名的匹配字符串</param>
///<paramname="strFolder">本地目录(不得以\结束)</param>
publicvoidGet(stringstrFileNameMask,stringstrFolder)
{
if(!bConnected)
{
Connect();
}
string[]strFiles=Dir(strFileNameMask);
foreach(stringstrFileinstrFiles)
{
if(!strFile.Equals(""))//一般来说strFiles的最后一个元素可能是空字符串
{
Get(strFile,strFolder,strFile);
}
}
}

///<summary>
///下载一个文件
///</summary>
///<paramname="strRemoteFileName">要下载的文件名</param>
///<paramname="strFolder">本地目录(不得以\结束)</param>
///<paramname="strLocalFileName">保存在本地时的文件名</param>
publicvoidGet(stringstrRemoteFileName,stringstrFolder,stringstrLocalFileName)
{
if(!bConnected)
{
Connect();
}
SetTransferType(TransferType.Binary);
if(strLocalFileName.Equals(""))
{
strLocalFileName=strRemoteFileName;
}
if(!File.Exists(strLocalFileName))
{
Streamst=File.Create(strLocalFileName);
st.Close();
}
FileStreamoutput=new
FileStream(strFolder+"\\"+strLocalFileName,FileMode.Create);
SocketsocketData=CreateDataSocket();
SendCommand("RETR"+strRemoteFileName);
if(!(iReplyCode==150||iReplyCode==125
||iReplyCode==226||iReplyCode==250))
{
thrownewIOException(strReply.Substring(4));
}
while(true)
{
intiBytes=socketData.Receive(buffer,buffer.Length,0);
output.Write(buffer,0,iBytes);
if(iBytes<=0)
{
break;
}
}
output.Close();
if(socketData.Connected)
{
socketData.Close();
}
if(!(iReplyCode==226||iReplyCode==250))
{
ReadReply();
if(!(iReplyCode==226||iReplyCode==250))
{
thrownewIOException(strReply.Substring(4));
}
}
}

///<summary>
///上传一批文件
///</summary>
///<paramname="strFolder">本地目录(不得以\结束)</param>
///<paramname="strFileNameMask">文件名匹配字符(可以包含*和?)</param>
publicvoidPut(stringstrFolder,stringstrFileNameMask)
{
string[]strFiles=Directory.GetFiles(strFolder,strFileNameMask);
foreach(stringstrFileinstrFiles)
{
//strFile是完整的文件名(包含路径)
Put(strFile);
}
}

///<summary>
///上传一个文件
///</summary>
///<paramname="strFileName">本地文件名</param>
publicvoidPut(stringstrFileName)
{
if(!bConnected)
{
Connect();
}
SocketsocketData=CreateDataSocket();
SendCommand("STOR"+Path.GetFileName(strFileName));
if(!(iReplyCode==125||iReplyCode==150))
{
thrownewIOException(strReply.Substring(4));
}
FileStreaminput=new
FileStream(strFileName,FileMode.Open);
intiBytes=0;
while((iBytes=input.Read(buffer,0,buffer.Length))>0)
{
socketData.Send(buffer,iBytes,0);
}
input.Close();
if(socketData.Connected)
{
socketData.Close();
}
if(!(iReplyCode==226||iReplyCode==250))
{
ReadReply();
if(!(iReplyCode==226||iReplyCode==250))
{
thrownewIOException(strReply.Substring(4));
}
}
}
#endregion
#region目录操作
///<summary>
///创建目录
///</summary>
///<paramname="strDirName">目录名</param>
publicvoidMkDir(stringstrDirName)
{
if(!bConnected)
{
Connect();
}
SendCommand("MKD"+strDirName);
if(iReplyCode!=257)
{
thrownewIOException(strReply.Substring(4));
}
}

///<summary>
///删除目录
///</summary>
///<paramname="strDirName">目录名</param>
publicvoidRmDir(stringstrDirName)
{
if(!bConnected)
{
Connect();
}
SendCommand("RMD"+strDirName);
if(iReplyCode!=250)
{
thrownewIOException(strReply.Substring(4));
}
}

///<summary>
///改变目录
///</summary>
///<paramname="strDirName">新的工作目录名</param>
publicvoidChDir(stringstrDirName)
{
if(strDirName.Equals(".")||strDirName.Equals(""))
{
return;
}
if(!bConnected)
{
Connect();
}
SendCommand("CWD"+strDirName);
if(iReplyCode!=250)
{
thrownewIOException(strReply.Substring(4));
}
this.strRemotePath=strDirName;
}
#endregion

///<summary>
///将一行应答字符串记录在strReply和strMsg
///应答码记录在iReplyCode
///</summary>
privatevoidReadReply()
{
strMsg="";
strReply=ReadLine();
iReplyCode=Int32.Parse(strReply.Substring(0,3));
}
///<summary>
///建立进行数据连接的socket
///</summary>
///<returns>数据连接socket</returns>
privateSocketCreateDataSocket()
{
SendCommand("PASV");
if(iReplyCode!=227)
{
thrownewIOException(strReply.Substring(4));
}
intindex1=strReply.IndexOf('(');
intindex2=strReply.IndexOf(')');
stringipData=
strReply.Substring(index1+1,index2-index1-1);
int[]parts=newint[6];
intlen=ipData.Length;
intpartCount=0;
stringbuf="";
for(inti=0;i<len&&partCount<=6;i++)
{
charch=Char.Parse(ipData.Substring(i,1));
if(Char.IsDigit(ch))
buf+=ch;
elseif(ch!=',')
{
thrownewIOException("MalformedPASVstrReply:"+
strReply);
}
if(ch==','||i+1==len)
{
try
{
parts[partCount++]=Int32.Parse(buf);
buf="";
}
catch(Exception)
{
thrownewIOException("MalformedPASVstrReply:"+
strReply);
}
}
}
stringipAddress=parts[0]+"."+parts[1]+"."+
parts[2]+"."+parts[3];
intport=(parts[4]<<8)+parts[5];
Sockets=new
Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
IPEndPointep=new
IPEndPoint(IPAddress.Parse(ipAddress),port);
try
{
s.Connect(ep);
}
catch(Exception)
{
thrownewIOException("Can'tconnecttoremoteserver");
}
returns;
}

///<summary>
///关闭socket连接(用于登录以前)
///</summary>
privatevoidCloseSocketConnect()
{
if(socketControl!=null)
{
socketControl.Close();
socketControl=null;
}
bConnected=false;
}
///<summary>
///读取Socket返回的所有字符串
///</summary>
///<returns>包含应答码的字符串行</returns>
privatestringReadLine()
{
while(true)
{
intiBytes=socketControl.Receive(buffer,buffer.Length,0);
strMsg+=ASCII.GetString(buffer,0,iBytes);
if(iBytes<buffer.Length)
{
break;
}
}
char[]seperator={'\n'};
string[]mess=strMsg.Split(seperator);
if(strMsg.Length>2)
{
strMsg=mess[mess.Length-2];
//seperator[0]是10,换行符是由13和0组成的,分隔后10后面虽没有字符串,
//但也会分配为空字符串给后面(也是最后一个)字符串数组,
//所以最后一个mess是没用的空字符串
//但为什么不直接取mess[0],因为只有最后一行字符串应答码与信息之间有空格
}
else
{
strMsg=mess[0];
}
if(!strMsg.Substring(3,1).Equals(""))//返回字符串正确的是以应答码(如220开头,后面接一空格,再接问候字符串)
{
returnReadLine();
}
returnstrMsg;
}

///<summary>
///发送命令并获取应答码和最后一行应答字符串
///</summary>
///<paramname="strCommand">命令</param>
privatevoidSendCommand(stringstrCommand)
{
Byte[]cmdBytes=ASCII.GetBytes((strCommand+"\r\n").ToCharArray());
socketControl.Send(cmdBytes,cmdBytes.Length,0);
ReadReply();
}
#endregion
}
}