"Tony" <tr****@cosmi.c om> wrote in message
news:04******** *************** *****@phx.gbl.. .
I'm sorry Jon. I don't see an attachment. Could you send
it again.
Thank You,
see below
--------------------------------------------------------------
using System;
using System.Net;
using System.IO;
using System.Text;
using System.Net.Sock ets;
using System.Diagnost ics;
using System.Runtime. Remoting;
using System.Runtime. Remoting.Messag ing;
/*
* FTP Client library in C#
* Author: Jaimon Mathew
* mailto:ja****** ****@rediffmail .com
*
http://www.csharphelp.com/archives/archive9.html
*
* Adapted for use by Dan Glass 07/03/03
*
* Modified / adapted again by Jon Davis 08/15/2003
* added DirExists(), GetCurrentDir()
*
*/
namespace
Accentra.Applic ations.PowerBlo g.BlogObjects.P ublishing.Conne ctionClients
{
public class FtpClient
{
public class FtpException : Exception
{
public FtpException(st ring message) : base(message) {
_resultcode = -1;
}
public FtpException(st ring message, int resultCode) : base(message) {
_resultcode = resultCode;
}
public FtpException(st ring message, Exception innerException) :
base(message,in nerException) {
_resultcode = -1;
}
public FtpException(st ring message, int resultCode, Exception
innerException) : base(message,in nerException) {
_resultcode = resultCode;
}
private int _resultcode;
public int ResultCode {
get {
return _resultcode;
}
}
}
private static int BUFFER_SIZE = 512;
private static Encoding ASCII = Encoding.ASCII;
private bool verboseDebuggin g = false;
// defaults
private string server = "localhost" ;
private string remotePath = ".";
private string username = "anonymous" ;
private string password = "an*******@anon ymous.net";
private string message = null;
private string result = null;
private int port = 21;
private int bytes = 0;
private int resultCode = 0;
private bool loggedin = false;
private bool binMode = false;
private Byte[] buffer = new Byte[BUFFER_SIZE];
private Socket clientSocket = null;
private int timeoutSeconds = 10;
/// <summary>
/// Default contructor
/// </summary>
public FtpClient()
{
}
/// <summary>
///
/// </summary>
/// <param name="server"></param>
/// <param name="username" ></param>
/// <param name="password" ></param>
public FtpClient(strin g server, string username, string password)
{
this.server = server;
this.username = username;
this.password = password;
}
/// <summary>
///
/// </summary>
/// <param name="server"></param>
/// <param name="username" ></param>
/// <param name="password" ></param>
/// <param name="timeoutSe conds"></param>
/// <param name="port"></param>
public FtpClient(strin g server, string username, string password, int
timeoutSeconds, int port)
{
this.server = server;
this.username = username;
this.password = password;
this.timeoutSec onds = timeoutSeconds;
this.port = port;
}
/// <summary>
/// Display all communications to the debug log
/// </summary>
public bool VerboseDebuggin g
{
get
{
return this.verboseDeb ugging;
}
set
{
this.verboseDeb ugging = value;
}
}
/// <summary>
/// Remote server port. Typically TCP 21
/// </summary>
public int Port
{
get
{
return this.port;
}
set
{
this.port = value;
}
}
/// <summary>
/// Timeout waiting for a response from server, in seconds.
/// </summary>
public int Timeout
{
get
{
return this.timeoutSec onds;
}
set
{
this.timeoutSec onds = value;
}
}
/// <summary>
/// Gets and Sets the name of the FTP server.
/// </summary>
/// <returns></returns>
public string Server
{
get
{
return this.server;
}
set
{
this.server = value;
}
}
/// <summary>
/// Gets and Sets the port number.
/// </summary>
/// <returns></returns>
public int RemotePort
{
get
{
return this.port;
}
set
{
this.port = value;
}
}
/// <summary>
/// GetS and Sets the remote directory.
/// </summary>
public string RemotePath
{
get
{
return this.remotePath ;
}
set
{
this.remotePath = value;
}
}
/// <summary>
/// Gets and Sets the username.
/// </summary>
public string Username
{
get
{
return this.username;
}
set
{
this.username = value;
}
}
/// <summary>
/// Gets and Set the password.
/// </summary>
public string Password
{
get
{
return this.password;
}
set
{
this.password = value;
}
}
/// <summary>
/// If the value of mode is true, set binary mode for downloads, else,
Ascii mode.
/// </summary>
public bool BinaryMode
{
get
{
return this.binMode;
}
set
{
if ( this.binMode == value ) return;
if ( value )
sendCommand("TY PE I");
else
sendCommand("TY PE A");
if ( this.resultCode != 200 ) throw new
FtpException(re sult.Substring( 4), this.resultCode );
}
}
/// <summary>
/// Login to the Remote server.
/// </summary>
public void Login()
{
if ( this.loggedin ) this.Close();
Debug.WriteLine ("Opening connection to " + this.server, "FtpClient" );
IPAddress addr = null;
IPEndPoint ep = null;
try
{
this.clientSock et = new Socket( AddressFamily.I nterNetwork,
SocketType.Stre am, ProtocolType.Tc p );
addr = Dns.Resolve(thi s.server).Addre ssList[0];
ep = new IPEndPoint( addr, this.port );
this.clientSock et.Connect(ep);
}
catch(Exception ex)
{
// doubtfull
if ( this.clientSock et != null && this.clientSock et.Connected )
this.clientSock et.Close();
throw new FtpException("C ouldn't connect to remote server",ex);
}
this.readRespon se();
if(this.resultC ode != 220)
{
this.Close();
throw new FtpException(th is.result.Subst ring(4), this.resultCode );
}
this.sendComman d( "USER " + username );
if( !(this.resultCo de == 331 || this.resultCode == 230) )
{
this.cleanup();
throw new FtpException(th is.result.Subst ring(4), this.resultCode );
}
if( this.resultCode != 230 )
{
this.sendComman d( "PASS " + password );
if( !(this.resultCo de == 230 || this.resultCode == 202) )
{
this.cleanup();
throw new FtpException(th is.result.Subst ring(4), this.resultCode );
}
}
this.loggedin = true;
Debug.WriteLine ( "Connected to " + this.server, "FtpClient" );
this.ChangeDir( this.RemotePath );
}
/// <summary>
/// Close the FTP connection.
/// </summary>
public void Close()
{
Debug.WriteLine ("Closing connection to " + this.server, "FtpClient" );
if( this.clientSock et != null )
{
this.sendComman d("QUIT");
}
this.cleanup();
}
/// <summary>
/// Return a string array containing the remote directory's file list.
/// </summary>
/// <returns></returns>
public string[] GetFileList()
{
return this.GetFileLis t("*.*");
}
/// <summary>
/// Return a string array containing the remote directory's file list.
/// </summary>
/// <param name="mask"></param>
/// <returns></returns>
public string[] GetFileList(str ing mask)
{
if ( !this.loggedin ) this.Login();
Socket cSocket = createDataSocke t();
this.sendComman d("NLST " + mask);
if(!(this.resul tCode == 150 || this.resultCode == 125)) throw new
FtpException(th is.result.Subst ring(4), this.resultCode );
this.message = "";
DateTime timeout = DateTime.Now.Ad dSeconds(this.t imeoutSeconds);
while( timeout > DateTime.Now )
{
int bytes = cSocket.Receive (buffer, buffer.Length, 0);
this.message += ASCII.GetString (buffer, 0, bytes);
if ( bytes < this.buffer.Len gth ) break;
}
string[] msg = this.message.Re place("\r",""). Split('\n');
cSocket.Close() ;
if ( this.message.In dexOf( "No such file or directory" ) != -1 )
msg = new string[]{};
this.readRespon se();
if ( this.resultCode != 226 )
msg = new string[]{};
// throw new FtpException(re sult.Substring( 4));
return msg;
}
/// <summary>
/// Return the size of a file.
/// </summary>
/// <param name="fileName" ></param>
/// <returns></returns>
public long GetFileSize(str ing fileName)
{
if ( !this.loggedin ) this.Login();
this.sendComman d("SIZE " + fileName);
long size=0;
if ( this.resultCode == 213 )
size = long.Parse(this .result.Substri ng(4));
else
throw new FtpException(th is.result.Subst ring(4), this.resultCode );
return size;
}
/// <summary>
/// Download a file to the Assembly's local directory,
/// keeping the same file name.
/// </summary>
/// <param name="remFileNa me"></param>
public void Download(string remFileName)
{
this.Download(r emFileName,"",f alse);
}
/// <summary>
/// Download a remote file to the Assembly's local directory,
/// keeping the same file name, and set the resume flag.
/// </summary>
/// <param name="remFileNa me"></param>
/// <param name="resume"></param>
public void Download(string remFileName,Boo lean resume)
{
this.Download(r emFileName,"",r esume);
}
/// <summary>
/// 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.
/// </summary>
/// <param name="remFileNa me"></param>
/// <param name="locFileNa me"></param>
public void Download(string remFileName,str ing locFileName)
{
this.Download(r emFileName,locF ileName,false);
}
/// <summary>
/// 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.
/// </summary>
/// <param name="remFileNa me"></param>
/// <param name="locFileNa me"></param>
/// <param name="resume"></param>
public void Download(string remFileName,str ing locFileName,Boo lean resume)
{
if ( !this.loggedin ) this.Login();
this.BinaryMode = true;
Debug.WriteLine ("Downloadin g file " + remFileName + " from " + server +
"/" + RemotePath, "FtpClient" );
if (locFileName.Eq uals(""))
{
locFileName = remFileName;
}
FileStream output = null;
if ( !File.Exists(lo cFileName) )
output = File.Create(loc FileName);
else
output = new FileStream(locF ileName,FileMod e.Open);
Socket cSocket = createDataSocke t();
long offset = 0;
if ( resume )
{
offset = output.Length;
if ( offset > 0 )
{
this.sendComman d( "REST " + offset );
if ( this.resultCode != 350 )
{
//Server dosnt support resuming
offset = 0;
Debug.WriteLine ("Resuming not supported:" + result.Substrin g(4),
"FtpClient" );
}
else
{
Debug.WriteLine ("Resuming at offset " + offset, "FtpClient" );
output.Seek( offset, SeekOrigin.Begi n );
}
}
}
this.sendComman d("RETR " + remFileName);
if ( this.resultCode != 150 && this.resultCode != 125 )
{
throw new FtpException(th is.result.Subst ring(4), this.resultCode );
}
DateTime timeout = DateTime.Now.Ad dSeconds(this.t imeoutSeconds);
while ( timeout > DateTime.Now )
{
this.bytes = cSocket.Receive (buffer, buffer.Length, 0);
output.Write(th is.buffer,0,thi s.bytes);
if ( this.bytes <= 0)
{
break;
}
}
output.Close();
if ( cSocket.Connect ed ) cSocket.Close() ;
this.readRespon se();
if( this.resultCode != 226 && this.resultCode != 250 )
throw new FtpException(th is.result.Subst ring(4), this.resultCode );
}
/// <summary>
/// Upload a file.
/// </summary>
/// <param name="fileName" ></param>
public void Upload(string fileName)
{
this.Upload(fil eName, MiscUtil.GetFil eName(fileName) , false);
}
public void Upload(string fileName, string destName) {
this.Upload(fil eName, destName, false);
}
/// <summary>
/// Upload a file and set the resume flag.
/// </summary>
/// <param name="fileName" ></param>
/// <param name="resume"></param>
public void Upload(string fileName, bool resume) {
this.Upload(fil eName, MiscUtil.GetFil eName(fileName) , resume);
}
/// <summary>
/// Upload a file and set the resume flag.
/// </summary>
/// <param name="fileName" ></param>
/// <param name="resume"></param>
public void Upload(string fileName, string destName, bool resume)
{
if ( !this.loggedin ) this.Login();
Socket cSocket = null ;
long offset = 0;
if ( resume )
{
try
{
this.BinaryMode = true;
offset = GetFileSize( Path.GetFileNam e(fileName) );
}
catch(Exception )
{
// file not exist
offset = 0;
}
}
// open stream to read file
FileStream input = new FileStream(file Name,FileMode.O pen);
if ( resume && input.Length < offset )
{
// different file size
Debug.WriteLine ("Overwritin g " + fileName, "FtpClient" );
offset = 0;
}
else if ( resume && input.Length == offset )
{
// file done
input.Close();
Debug.WriteLine ("Skipping completed " + fileName + " - turn resume off
to not detect.", "FtpClient" );
return;
}
// dont create untill we know that we need it
cSocket = this.createData Socket();
if ( offset > 0 )
{
this.sendComman d( "REST " + offset );
if ( this.resultCode != 350 )
{
Debug.WriteLine ("Resuming not supported", "FtpClient" );
offset = 0;
}
}
this.sendComman d( "STOR " + destName);
if ( this.resultCode != 125 && this.resultCode != 150 ) throw new
FtpException(re sult.Substring( 4), this.resultCode );
if ( offset != 0 )
{
Debug.WriteLine ("Resuming at offset " + offset, "FtpClient" );
input.Seek(offs et,SeekOrigin.B egin);
}
Debug.WriteLine ( "Uploading file " + fileName + " to " + RemotePath,
"FtpClient" );
while ((bytes = input.Read(buff er,0,buffer.Len gth)) > 0)
{
cSocket.Send(bu ffer, bytes, 0);
}
input.Close();
if (cSocket.Connec ted)
{
cSocket.Close() ;
}
this.readRespon se();
if( this.resultCode != 226 && this.resultCode != 250 ) throw new
FtpException(th is.result.Subst ring(4), this.resultCode );
}
/// <summary>
/// Upload a directory and its file contents
/// </summary>
/// <param name="path"></param>
/// <param name="recurse"> Whether to recurse sub directories</param>
public void UploadDirectory (string path, bool recurse)
{
this.UploadDire ctory(path,recu rse,"*.*");
}
/// <summary>
/// Upload a directory and its file contents
/// </summary>
/// <param name="path"></param>
/// <param name="recurse"> Whether to recurse sub directories</param>
/// <param name="mask">Onl y upload files of the given mask - everything is
'*.*'</param>
public void UploadDirectory (string path, bool recurse, string mask)
{
string[] dirs = path.Replace("/",@"\").Split(' \\');
string rootDir = dirs[ dirs.Length - 1 ];
// make the root dir if it doed not exist
if ( this.GetFileLis t(rootDir).Leng th < 1 ) this.MakeDir(ro otDir);
this.ChangeDir( rootDir);
foreach ( string file in Directory.GetFi les(path,mask) )
{
this.Upload(fil e,true);
}
if ( recurse )
{
foreach ( string directory in Directory.GetDi rectories(path) )
{
this.UploadDire ctory(directory ,recurse,mask);
}
}
this.ChangeDir( "..");
}
/// <summary>
/// Delete a file from the remote FTP server.
/// </summary>
/// <param name="fileName" ></param>
public void DeleteFile(stri ng fileName)
{
if ( !this.loggedin ) this.Login();
this.sendComman d( "DELE " + fileName );
if ( this.resultCode != 250 ) throw new
FtpException(th is.result.Subst ring(4), this.resultCode );
Debug.WriteLine ( "Deleted file " + fileName, "FtpClient" );
}
/// <summary>
/// Rename a file on the remote FTP server.
/// </summary>
/// <param name="oldFileNa me"></param>
/// <param name="newFileNa me"></param>
/// <param name="overwrite ">setting to false will throw exception if it
exists</param>
public void RenameFile(stri ng oldFileName,str ing newFileName, bool
overwrite)
{
if ( !this.loggedin ) this.Login();
this.sendComman d( "RNFR " + oldFileName );
if ( this.resultCode != 350 ) throw new
FtpException(th is.result.Subst ring(4), this.resultCode );
if ( !overwrite && this.GetFileLis t(newFileName). Length > 0 ) throw new
FtpException("F ile already exists");
this.sendComman d( "RNTO " + newFileName );
if ( this.resultCode != 250 ) throw new
FtpException(th is.result.Subst ring(4), this.resultCode );
Debug.WriteLine ( "Renamed file " + oldFileName + " to " + newFileName,
"FtpClient" );
}
/// <summary>
/// Create a directory on the remote FTP server.
/// </summary>
/// <param name="dirName"> </param>
public void MakeDir(string dirName)
{
if ( !this.loggedin ) this.Login();
this.sendComman d( "MKD " + dirName );
if ( this.resultCode != 250 && this.resultCode != 257 ) throw new
FtpException(th is.result.Subst ring(4), this.resultCode );
Debug.WriteLine ( "Created directory " + dirName, "FtpClient" );
}
/// <summary>
/// Delete a directory on the remote FTP server.
/// </summary>
/// <param name="dirName"> </param>
public void RemoveDir(strin g dirName)
{
if ( !this.loggedin ) this.Login();
this.sendComman d( "RMD " + dirName );
if ( this.resultCode != 250 ) throw new
FtpException(th is.result.Subst ring(4), this.resultCode );
Debug.WriteLine ( "Removed directory " + dirName, "FtpClient" );
}
/// <summary>
/// Change the current working directory on the remote FTP server.
/// </summary>
/// <param name="dirName"> </param>
public void ChangeDir(strin g dirName)
{
if( dirName == null || dirName.Equals( ".") || dirName.Length == 0 )
{
return;
}
if ( !this.loggedin ) this.Login();
this.sendComman d( "CWD " + dirName );
if ( this.resultCode != 250 ) throw new FtpException(re sult.Substring( 4),
this.resultCode );
this.sendComman d( "PWD" );
if ( this.resultCode != 257 ) throw new FtpException(re sult.Substring( 4),
this.resultCode );
// gonna have to do better than this....
this.RemotePath = this.message.Sp lit('"')[1];
Debug.WriteLine ( "Current directory is " + this.RemotePath ,
"FtpClient" );
}
/// <summary>
/// Tests to see if a specified directory exists on the remote FTP server.
/// </summary>
/// <param name="dirName"> </param>
/// <returns></returns>
public bool DirExists(strin g dirName) {
string pwd = this.GetCurrent Dir();
if (pwd == dirName) return true;
bool exists;
try {
this.ChangeDir( dirName);
exists = true;
this.ChangeDir( pwd);
} catch (FtpException ex) {
if (ex.ResultCode == 550) {
exists = false;
} else throw ex;
}
return exists;
}
public string GetCurrentDir() {
if ( !this.loggedin ) this.Login();
this.sendComman d( "PWD" );
if ( this.resultCode != 257 ) throw new FtpException(re sult.Substring( 4),
this.resultCode );
string ret = result.Substrin g(4);
if (ret.IndexOf("\ "") > -1 &&
ret.LastIndexOf ("\"", ret.IndexOf("\" ") + 1) > -1) {
ret = ret.Substring(r et.IndexOf("\"" ) + 1,
ret.IndexOf("\" ", ret.IndexOf("\" ") + 1) - ret.IndexOf("\" ") - 1);
} else if (ret.ToLower(). IndexOf(" is current directory") > -1) {
ret = ret.Substring(0 , ret.ToLower().I ndexOf(" is current
directory")).Tr im();
}
return ret;
}
/// <summary>
///
/// </summary>
private void readResponse()
{
this.message = "";
this.result = this.readLine() ;
if ( this.result.Len gth > 3 ) {
this.resultCode = int.Parse( this.result.Sub string(0,3) );
if (this.result.Su bstring(this.re sult.Length - 1) == "\r") {
this.result = this.result.Sub string(0, this.result.Len gth - 1);
}
} else
this.result = null;
}
/// <summary>
///
/// </summary>
/// <returns></returns>
private string readLine()
{
while(true)
{
this.bytes = clientSocket.Re ceive( this.buffer, this.buffer.Len gth, 0 );
this.message += ASCII.GetString ( this.buffer, 0, this.bytes );
if ( this.bytes < this.buffer.Len gth )
{
break;
}
}
string[] msg = this.message.Sp lit('\n');
if ( this.message.Le ngth > 2 )
this.message = msg[ msg.Length - 2 ];
else
this.message = msg[0];
if ( this.message.Le ngth > 4 && !this.message.S ubstring(3,1).E quals("
") ) return this.readLine() ;
if ( this.verboseDeb ugging )
{
for(int i = 0; i < msg.Length - 1; i++)
{
Debug.Write( msg[i], "FtpClient" );
}
}
return message;
}
/// <summary>
///
/// </summary>
/// <param name="command"> </param>
private void sendCommand(Str ing command)
{
if ( this.verboseDeb ugging ) Debug.WriteLine (command,"FtpCl ient");
Byte[] cmdBytes = Encoding.ASCII. GetBytes( ( command +
"\r\n" ).ToCharArray() );
clientSocket.Se nd( cmdBytes, cmdBytes.Length , 0);
this.readRespon se();
}
/// <summary>
/// when doing data transfers, we need to open another socket for it.
/// </summary>
/// <returns>Connec ted socket</returns>
private Socket createDataSocke t()
{
this.sendComman d("PASV");
if ( this.resultCode != 227 ) throw new
FtpException(th is.result.Subst ring(4), this.resultCode );
int index1 = this.result.Ind exOf('(');
int index2 = this.result.Ind exOf(')');
string ipData = this.result.Sub string(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.Substrin g(i,1) );
if ( char.IsDigit(ch ) )
buf+=ch;
else if (ch != ',')
throw new FtpException("M alformed PASV result: " + result);
if ( ch == ',' || i+1 == len )
{
try
{
parts[partCount++] = int.Parse(buf);
buf = "";
}
catch (Exception ex)
{
throw new FtpException("M alformed PASV result (not supported?): " +
this.result, ex);
}
}
}
string ipAddress = parts[0] + "."+ parts[1]+ "." + parts[2] + "." +
parts[3];
int port = (parts[4] << 8) + parts[5];
Socket socket = null;
IPEndPoint ep = null;
try
{
socket = new
Socket(AddressF amily.InterNetw ork,SocketType. Stream,Protocol Type.Tcp);
ep = new IPEndPoint(Dns. Resolve(ipAddre ss).AddressList[0], port);
socket.Connect( ep);
}
catch(Exception ex)
{
// doubtfull....
if ( socket != null && socket.Connecte d ) socket.Close();
throw new FtpException("C an't connect to remote server", ex);
}
return socket;
}
/// <summary>
/// Always release those sockets.
/// </summary>
private void cleanup()
{
if ( this.clientSock et!=null )
{
this.clientSock et.Close();
this.clientSock et = null;
}
this.loggedin = false;
}
/// <summary>
/// Destuctor
/// </summary>
~FtpClient()
{
this.cleanup();
}
/*************** *************** *************** *************** ***************
*************** *************** *****/
#region Async methods (auto generated)
/*
WinInetApi.FtpC lient ftp = new WinInetApi.FtpC lient();
MethodInfo[] methods =
ftp.GetType().G etMethods(Bindi ngFlags.Declare dOnly|BindingFl ags.Instance|Bi n
dingFlags.Publi c);
foreach ( MethodInfo method in methods )
{
string param = "";
string values = "";
foreach ( ParameterInfo i in method.GetParam eters() )
{
param += i.ParameterType .Name + " " + i.Name + ",";
values += i.Name + ",";
}
Debug.WriteLine ("private delegate " + method.ReturnTy pe.Name + " " +
method.Name + "Callback(" + param.TrimEnd(' ,') + ");");
Debug.WriteLine ("public System.IAsyncRe sult Begin" + method.Name + "( "
+ param + " System.AsyncCal lback callback )");
Debug.WriteLine ("{");
Debug.WriteLine ("" + method.Name + "Callback ftpCallback = new " +
method.Name + "Callback(" + values + " this." + method.Name + ");");
Debug.WriteLine ("return ftpCallback.Beg inInvoke(callba ck, null);");
Debug.WriteLine ("}");
Debug.WriteLine ("public void End" + method.Name + "(System.IAsync Result
asyncResult)");
Debug.WriteLine ("{");
Debug.WriteLine (method.Name + "Callback fc = (" + method.Name +
"Callback) ((AsyncResult)a syncResult).Asy ncDelegate;");
Debug.WriteLine ("fc.EndInvoke( asyncResult);") ;
Debug.WriteLine ("}");
//Debug.WriteLine (method);
}
*/
private delegate void LoginCallback() ;
public System.IAsyncRe sult BeginLogin( System.AsyncCal lback callback )
{
LoginCallback ftpCallback = new LoginCallback( this.Login);
return ftpCallback.Beg inInvoke(callba ck, null);
}
private delegate void CloseCallback() ;
public System.IAsyncRe sult BeginClose( System.AsyncCal lback callback )
{
CloseCallback ftpCallback = new CloseCallback( this.Close);
return ftpCallback.Beg inInvoke(callba ck, null);
}
private delegate String[] GetFileListCall back();
public System.IAsyncRe sult BeginGetFileLis t( System.AsyncCal lback
callback )
{
GetFileListCall back ftpCallback = new GetFileListCall back(
this.GetFileLis t);
return ftpCallback.Beg inInvoke(callba ck, null);
}
private delegate String[] GetFileListMask Callback(String mask);
public System.IAsyncRe sult BeginGetFileLis t( String mask,
System.AsyncCal lback callback )
{
GetFileListMask Callback ftpCallback = new
GetFileListMask Callback(this.G etFileList);
return ftpCallback.Beg inInvoke(mask, callback, null);
}
private delegate Int64 GetFileSizeCall back(String fileName);
public System.IAsyncRe sult BeginGetFileSiz e( String fileName,
System.AsyncCal lback callback )
{
GetFileSizeCall back ftpCallback = new
GetFileSizeCall back(this.GetFi leSize);
return ftpCallback.Beg inInvoke(fileNa me, callback, null);
}
private delegate void DownloadCallbac k(String remFileName);
public System.IAsyncRe sult BeginDownload( String remFileName,
System.AsyncCal lback callback )
{
DownloadCallbac k ftpCallback = new DownloadCallbac k(this.Download );
return ftpCallback.Beg inInvoke(remFil eName, callback, null);
}
private delegate void DownloadFileNam eResumeCallback (String
remFileName,Boo lean resume);
public System.IAsyncRe sult BeginDownload( String remFileName,Boo lean
resume, System.AsyncCal lback callback )
{
DownloadFileNam eResumeCallback ftpCallback = new
DownloadFileNam eResumeCallback (this.Download) ;
return ftpCallback.Beg inInvoke(remFil eName, resume, callback, null);
}
private delegate void DownloadFileNam eFileNameCallba ck(String
remFileName,Str ing locFileName);
public System.IAsyncRe sult BeginDownload( String remFileName,Str ing
locFileName, System.AsyncCal lback callback )
{
DownloadFileNam eFileNameCallba ck ftpCallback = new
DownloadFileNam eFileNameCallba ck(this.Downloa d);
return ftpCallback.Beg inInvoke(remFil eName, locFileName, callback, null);
}
private delegate void DownloadFileNam eFileNameResume Callback(String
remFileName,Str ing locFileName,Boo lean resume);
public System.IAsyncRe sult BeginDownload( String remFileName,Str ing
locFileName,Boo lean resume, System.AsyncCal lback callback )
{
DownloadFileNam eFileNameResume Callback ftpCallback = new
DownloadFileNam eFileNameResume Callback(this.D ownload);
return ftpCallback.Beg inInvoke(remFil eName, locFileName, resume,
callback, null);
}
private delegate void UploadCallback( String fileName);
public System.IAsyncRe sult BeginUpload( String fileName,
System.AsyncCal lback callback )
{
UploadCallback ftpCallback = new UploadCallback( this.Upload);
return ftpCallback.Beg inInvoke(fileNa me, callback, null);
}
private delegate void UploadFileNameR esumeCallback(S tring fileName,Boolea n
resume);
public System.IAsyncRe sult BeginUpload( String fileName,Boolea n resume,
System.AsyncCal lback callback )
{
UploadFileNameR esumeCallback ftpCallback = new
UploadFileNameR esumeCallback(t his.Upload);
return ftpCallback.Beg inInvoke(fileNa me, resume, callback, null);
}
private delegate void UploadDirectory Callback(String path,Boolean
recurse);
public System.IAsyncRe sult BeginUploadDire ctory( String path,Boolean
recurse, System.AsyncCal lback callback )
{
UploadDirectory Callback ftpCallback = new
UploadDirectory Callback(this.U ploadDirectory) ;
return ftpCallback.Beg inInvoke(path, recurse, callback, null);
}
private delegate void UploadDirectory PathRecurseMask Callback(String
path,Boolean recurse,String mask);
public System.IAsyncRe sult BeginUploadDire ctory( String path,Boolean
recurse,String mask, System.AsyncCal lback callback )
{
UploadDirectory PathRecurseMask Callback ftpCallback = new
UploadDirectory PathRecurseMask Callback(this.U ploadDirectory) ;
return ftpCallback.Beg inInvoke(path, recurse, mask, callback, null);
}
private delegate void DeleteFileCallb ack(String fileName);
public System.IAsyncRe sult BeginDeleteFile ( String fileName,
System.AsyncCal lback callback )
{
DeleteFileCallb ack ftpCallback = new DeleteFileCallb ack(this.Delete File);
return ftpCallback.Beg inInvoke(fileNa me, callback, null);
}
private delegate void RenameFileCallb ack(String oldFileName,Str ing
newFileName,Boo lean overwrite);
public System.IAsyncRe sult BeginRenameFile ( String oldFileName,Str ing
newFileName,Boo lean overwrite, System.AsyncCal lback callback )
{
RenameFileCallb ack ftpCallback = new RenameFileCallb ack(this.Rename File);
return ftpCallback.Beg inInvoke(oldFil eName, newFileName, overwrite,
callback, null);
}
private delegate void MakeDirCallback (String dirName);
public System.IAsyncRe sult BeginMakeDir( String dirName,
System.AsyncCal lback callback )
{
MakeDirCallback ftpCallback = new MakeDirCallback (this.MakeDir);
return ftpCallback.Beg inInvoke(dirNam e, callback, null);
}
private delegate void RemoveDirCallba ck(String dirName);
public System.IAsyncRe sult BeginRemoveDir( String dirName,
System.AsyncCal lback callback )
{
RemoveDirCallba ck ftpCallback = new RemoveDirCallba ck(this.RemoveD ir);
return ftpCallback.Beg inInvoke(dirNam e, callback, null);
}
private delegate void ChangeDirCallba ck(String dirName);
public System.IAsyncRe sult BeginChangeDir( String dirName,
System.AsyncCal lback callback )
{
ChangeDirCallba ck ftpCallback = new ChangeDirCallba ck(this.ChangeD ir);
return ftpCallback.Beg inInvoke(dirNam e, callback, null);
}
#endregion
}
}
