Welcome to my tutorial on FTP Class Library in C#. In this tutorial I will walk you through creating an FTP Class, which can be implemented into your own FTP interface, using Raw FTP Commands and the following Namespaces in the .Net Framework:

• System.Net
• System.Net.Sockets
• System.Runtime.Remoting
• System.Runtime.Remoting.Messaging

The latter of the 4, System.Runtime.Remoting.Messaging, gives us the remoting infrastructure needed to communicate with the remote FTP Server. Support for FTP in .Net 2.0 is not only a new feature, but it doesn't get nearly enough attention as it should. Before 2.0 we were delegated to relying on 3rd party libraries if we wanted to access FTP functionality. I have been asked many times how to go about creating an FTP Class Library in C#, both professionally and from friends I know in the industry, so I thought it was time to dive into the world of Sockets and remoting.

At the time of this tutorial my FTP Class Library doesn't yet have support for FTPS or recursive downloading, but I plan on implementing that in the future. The features you will have available when you complete this tutorial are:

• Uploading
• Recursive Uploading
• Download
• Resume (Download & Upload)
• Delete (Files & Directories)
• Rename Files
• Create Directory

Keep in mind that this is a large class library, responsible for a lot of functionality, so this tutorial is rather lengthy. Now into the making of your class library. As with any .Net code you write you need to add your using Directives. The using Directive allows us access to the types and methods in Namespace's without having to fully qualify the Namespace as well:



Next we need our Global variables. Some of these are for populating our Public Properties. Variables are required for properties as properties don't allocate any storage space on their own, and to prevent the variables from being directly modified, always declare them as private:



Now we need to look at the Properties for our library. All our properties are Public, making them accessible from outside the class, but we have Read/Write variables, where the value is set outside our library, and we have ReadOnly properties, where the value is set from within the library itself, and retrieve from elsewhere. In this version of out library we have properties for the following:

• Server name
• Working directory path
• Username
• Password
• Port number
• Is the user logged in
• Use binary mode or Ascii
• Timeout value

In future versions I will be adding these as storable values, to keep a list of FTP Servers I connect to, and hashed values for the username/password combination of each server. Here are our properties:



Notice the property StatusCode, this is a readonly property that will hold the FTP code returned from the remote server. This value is crucial when creating an FTP client. Now we move on to the methods of our class library. Before a user can do anything on an FTP Server, they first need to login to that server with the correct username and password. For our login method we create a Socket to communicate with the server through, once we have successfully connection to the host, we can execute 2 FTP commands:

• USER: Used to send the username to the server
• PASS: Used to send the password to the server

Then based on the returned status code we act accordingly, we either let the user know they logged on successfully, or we throw our custom exception FtpException (We'll get to that later):



Next we will look at the CloseConnection method. This method is called mainly when we close our application. Here we check to see if the socket is still active, if so we execute the FTP command of QUIT which immediately terminates the connection tot he FTP server:



You will notice that in the first 2 methods we looked at, both called a method named Execute. The Execute method is what we will be using to send our FTP commands to the remote server. Here we convert the command string into a byte array, then use the Send Method of the Socket to send the converted command to the remote server. Once we send the command we wait for and read the host's response:



You'll notice the method call to readResponse as the last line in the Execute method. It is in here we set the values of our _statusCode variable, along with the result and statusMessage variables. These values come from a method called ParseHostResponse. First the readResponse method:



Now for ParseHostResponse:



Now, when doing FTP you need to open a new socket for any transfers. To do this we use the passive approach, by letting the remote server send us the IP and port we need to connect through. We do this by sending the PASV command to the server, it then returns the IP and post in this format 227 Entering Passive Mode (192,168,8,36,8,75), so we need to parse this so we have the information for transferring the data. We do this by looping through the return message, building the IP and port number, then we attempt a connect with that information:



Now we have all the information for connecting to the remote server, for logging into the server, and for opening a data socket for the data transfer, now lets look at how we would go about uploading a file to an FTP Server. With uploading a file, we will attempt to enable resuming the download in case the connection is interrupted, but remember, all servers don't support resuming.

To do this we initially get the size of the file, then when we start the upload we look for a file with the same name, if it exists then we check its size against the file on the clients computer. If they don't match we send the REST command, which will initialize a resume, it is here when we will be informed if the FTP server supports the resume feature. If it doesn't support resume, we overwrite the file there with the one being uploaded:



You will notice we reference a method named GetFileSize when we upload the file. This is a method we use to retrieve the size of the file they're uploading (we also use it for the downloading as well). Here we sent the SIZE command to the server, and if successful it returns the file size, in decimal format, otherwise we throw an exception:



For downloading a file, we also attempt to implement a resume, checking in the same fashion to see if the server supports this command. Here we require the name of the file on the server to download, the name you want the file on the clients computer, and a boolean resume value. Once we send the REST command, we then send the RETR command to retrieve the remote file. We then set a timeout value, and check that value in a loop, while calling the Receive Method of the Socket Class until we either reach the timeout value, of the number of bytes remaining is zero:



How will someone know what file(s) they want to download? Thats good question, which I have a good answer for. When you plug your library into a UI for the user, you have a method to list all the files that are currently on the FTP server. We do this by executing the NLST command. This will retrieve the name and size of all files on the server, then we simply populate a string array with that information, and use it to populate the UI for the client to view:



I had mentioned earlier in this tutorial that our library will offer recursive uploading to the FTP server, so lets take a look at how we offer that functionality. FOr this we require the user to provide the directory path, a boolean value for recursive, and a mask value , such as '*.*', '*.jpg*', etc. We take that directory name and check to see if the directory already exists on the server, if it doesnt we create that directory.

From there we change the working directory to the new directory, we want to be in the new directory when we start the upload, we'll look at that method next.Then we start our loop, we first upload all the files that are in that directory, then, if the user opted for recursive, we loop through all the directories in the specified directory and upload them, and their files as well, then we change the working directory back to the root directory:



For changing the working directory for the user all we need is the name of the directory they wish to make the working directory. We then execute the [i[CWD[/i] command, which stands for, Change Working Directory. We then check for a stus code of 250, if we dont receive that code we throw an exception, if we do we then execute the PWD command (Print Working Directory) and check for a status of 257. If we dont receive that status from the server we throw an exception, otherwise we write out the message of the new directory:



There are 2 more small methods I'd like to go over with you, one is for renaming a file, the other is for deleting a file. There is, of course, more in this library, but this tutorial is getting quite long as it is, so I'll be including the file with this tutorial, so you can look through the rest of the code.

For deleting a file, we send the DELE command to the remote server, then wait for a response. If we receive a status code of 250 all is good and the file was deleted, if not we throw an exception with the error message returned from the server:



Now, to rename a file we send two commands to the server. First we send the RNFR command, which is rename from, then we send the RNTO, which is rename to. When wwe send the first command we check for a status code of 350, if successful we send the 2nd command, then look for a status of 250. If all goes well then the file is renamed, otherwise we throw an exception with the message from the FTP server:



One finaly method, this method is for creating a new directory on the server. To do this we send the MKD command to the server (Make Directory), then check the status code thats returned. If its not either 250 or 257 we throw an exception containing the message from the server, otherwise the operation was successful:



There are a couple more methods in the library, but Ill let you look through them on your own, because I now want to show the short class file that makes our cutom FtpException we throw whever a command fails. In this class we inherit from the Exception Class, and it contains nothing but the 2 base contructors Microsoft suggests all custom exception classes have:



That's it, thats our Custom Exception class, and our FTP Class Library. Like I metioned earlier, I will be including this library with the tutorial, but it is under the GNU General Public License so the licensing information must remain in tact with the library and code at all times. So now you have a good understanding of creating your own custom FTP Class Library utilizing just the objects available in the .Net Framework 2.0.

I know this tutorial was long and indepth, but I hope you found it useful and informative, as I did when creating this library. Thank you so much for reading.

 PCFtp.zip ( 46.54k ) Number of downloads: 851


Happy Coding!

I needed something like that.
Awesome Tutorial!!!

Wow, that is some tutorial... I remember I had to write something like that to do file sending via FTP in ASP.NET. Since there wasn't any need to write a full class, I just did the STOR command (and USER, PASS, QUIT).

Given that .NET 2.0 has built-in classes for FTP too, what are the pros and cons using the class library here and the built-in classes? For example, I used this (in another program) for sending files


I've never been strong in networking stuff...

that was a great tutorial but i m not able to use it.
please tell me how to use it in a different program say on a button click.