Upload file to ftp server using c# asp.net with API

Introduction

An addition to the Microsoft .NET framework 2.0 to 1.x is the support for FTP. All these days we need to rely on third-party libraries that pretty well satisfies most of our needs, but for sure, there is an extra pleasure with the use of the .Net framework library classes. The code included is not designed to be a full-fledged reusable library, but rather an easy to use and reusable piece of code that is easily comprehensible and can be reused and tweaked to fit your specific needs. Therefore the code for each functionality (upload, download, delete and so on) can be easy picked up separately and reused. The main motive behind this article was the unavailability of .Net 2.0 FTP sample codes and their usage in C#, maybe because it's a new entrant to the .Net scenario, or the third-party implementations available were working pretty well, that this area of the .Net 2.0 library hasn't gotten enough focus.

Background

I started working on this FTP module as part of my official work, but the requirement soon changed and I need to do it for .Net 1.1. So, I haven't travelled deeper into the Rabbit hole. But I believe this gives a good, instant start for using the FTP support in .Net 2.0.

Using the code

Don't forget to add the following directive:

using System.Net;

using System.IO;

The following steps can be considered as a generic procedure of getting an FTP request executed using a "FtpWebRequest" object:

1. Create an "FtpWebRequest" object over an FTP server URI
2. Set the FTP method to execute (upload, download, and so on)
3. Set options (SSL support, transfer as binary or not and so on) for the FTP webrequest
4. Set the login credentials (username and password)
5. Execute the request
6. Recieve the response stream (if required)
7. Close the FTP Request, in addition to any open streams

One point to watch out while coding for any FTP application is to have the settings for the FTP request proper to suit the FTP server and its specific configurations. A "FtpWebRequest" object exposes many poperties to have these settings in place.

The sample for the upload functionality is as follows.

First a URI is created that represents the FTP address along with the filename (directory structure included). This URI is used to create the "FtpWebRequest" instance.

Then the properties of the "FtpWebRequest" object are set, that determines the settings for the FTP request.

Some of its important properties are:

• Credentials: specifies the username and password to login to the FTP server.
  
• KeepAlive: specifies if the control connection should be closed or not after the request is completed. By default it is set to true.
  
• UseBinary: denotes the datatype for file transfers. The 2 modes of file transfer in this case are Binary and ASCII. At the bit level both vary in the 8th bit of a byte. ASCII uses the 8th bit as an insignificant bit for error control, whereas for binary all the 8 bits are significant. So take care when you go for the ASCII transmission. To be simple, all those files that open and read well in Notepad are safe as ASCII. Executables, formatted documents and so on should be sent using binary mode. BTW sending ASCII files as binary works fine most of the time.
  
• UsePassive: specifies whether to use active or passive mode. Earlier an active FTP worked fine with all clients, but nowm since most of the random ports will blocked by firewalls, the active mode may fail. The passive FTP is helpful in this case. But still it causes issues at the server. The higher ports requested by the client on the server may also be blocked by a firewall. But since FTP servers will need to make their servers accessible to the greatest number of clients, they will almost certainly need to support passive FTP. The reason why passive mode is considered safe is that it ensures all data flow initiation comes from inside (the client) the network rather than from the outside (the server).
  
• Contentlength: setting this property is useful for the server we make requests to but is not of much use for us (the client) because FtpWebRequest usually ignores this property value, so it will not be available for our use in most of the cases. But if we set this property then the FTP server will get an idea in advance about the size of the file it should expect (in the case of an upload).
  
• Method: Denotes what action (command) to take in the current request (upload, download, filelist and so on). It is set a value defined in the WebRequestMethods.FTP structure.
   
   
   

  private void Upload(string filename)

  {

      FileInfo fileInf = new FileInfo(filename);

      string uri = "ftp://" + ftpServerIP + "/" + fileInf.Name;

      FtpWebRequest reqFTP; 

      // Create FtpWebRequest object from the Uri provided

      reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri("ftp://" + ftpServerIP + "/" + fileInf.Name)); 

      // Provide the WebPermission Credintials

      reqFTP.Credentials = new NetworkCredential(ftpUserID, ftpPassword); 

      // By default KeepAlive is true, where the control connection is not closed

      // after a command is executed.

      reqFTP.KeepAlive = false; 

      // Specify the command to be executed.

      reqFTP.Method = WebRequestMethods.Ftp.UploadFile; 

      // Specify the data transfer type.

      reqFTP.UseBinary = true; 

      // Notify the server about the size of the uploaded file

      reqFTP.ContentLength = fileInf.Length; 

      // The buffer size is set to 2kb

      int buffLength = 2048;

      byte[] buff = new byte[buffLength];

      int contentLen; 

      // Opens a file stream (System.IO.FileStream) to read the file to be uploaded

      FileStream fs = fileInf.OpenRead(); 

      try

      {

          // Stream to which the file to be upload is written

          Stream strm = reqFTP.GetRequestStream(); 

          // Read from the file stream 2kb at a time

          contentLen = fs.Read(buff, 0, buffLength); 

          // Until Stream content ends

          while (contentLen != 0)

          {

              // Write Content from the file stream to the FTP Upload Stream

              strm.Write(buff, 0, contentLen);

              contentLen = fs.Read(buff, 0, buffLength);

          } 

          // Close the file stream and the Request Stream

          strm.Close();

          fs.Close();

      }

      catch (Exception ex)

      {

          MessageBox.Show(ex.Message, "Upload Error");

      }

  }