Welcome to Ultra Developers.

Sometimes your application wants to upload files or reports to an FTP directory on a web server to be viewed by your customers. You can open Explorer and type your FTP directory location, type FTP user name and password and copy files from your machine to that FTP directory. But if you want to automate the process of generating reports from your application and upload it to the FTP directory on the web server. This article will help you solve this problem.

Using the Code:

To automate the process of generating reports from your application and upload it to the FTP directory follow the following steps:

1. Create a new windows application using Visual Studio 2005/2008/2010.
2. Rename Form1 to FtpForm.
3. Add a Label to the FtpForm and rename it to FtpDirectoryLabel and set its Text property toFTP Directory.
4. Add another Label to the FtpForm and rename it to UserNameLabel and set its Text property to User Name.
5. Add another Label to the FtpForm and rename it to PasswordLabel and set its Text property to Password.
6. Add a TextBox to the FtpForm and rename it to FtpDirectoryTextBox.
7. Add another TextBox to the FtpForm and rename it to UserNameTextBox.
8. Add another TextBox to the FtpForm and rename it to PasswordTextBox and set its PasswordCharproperty to *.
9. Add a RichTextBox to the FtpForm and rename it to ResultTextBox.
10. Add an ErrorProvider component to the FtpForm and name it errorProvider. The Error Provider provides a user interface for indication that a control on the form has an error associated with it.
11. Add a button to the FtpForm and rename it to UploadFtpButton and set its Text Property to Upload FTP.
12. Import the System.Net and System.IO namespaces using the following statement:

using System.Net;
using System.IO;

13. The System.Net namespace provides a simple programming interface for many of the protocols used on networks today.
14. The System.IO namespace contains types that allow reading and writing to files and data streams and types that provide basic file and directory support.
15. Double click the UploadFtpButton to create the Click Event Handler.
16. Add the following code to the UploadFtpButton Click Event Handler:

private void UploadFtpToolStripButton_Click(object sender, EventArgs e)
{
    try
    {
        errorProvider.Clear();

        if (string.IsNullOrEmpty(FtpDirectoryTextBox.Text))
        {
            errorProvider.SetError(FtpDirectoryTextBox, "Required");
            return;
        } 

        if (string.IsNullOrEmpty(UserNameTextBox.Text))
        {
            errorProvider.SetError(UserNameTextBox, "Required");
            return;
        } 

        if (string.IsNullOrEmpty(PasswordTextBox.Text))
        {
            errorProvider.SetError(PasswordTextBox, "Required");
            return;
        }

        OpenFileDialog openFileDialog = new OpenFileDialog();
        DialogResult openResult = openFileDialog.ShowDialog();

        if (openResult == DialogResult.OK)
        {
            FileInfo uploadFile = new FileInfo(openFileDialog.FileName);
            string ftpLink = FtpDirectoryTextBox.Text + "/" + uploadFile.Name;

            FtpWebRequest ftpWebRequest = (FtpWebRequest)WebRequest.Create(ftpLink);
            ftpWebRequest.Method = WebRequestMethods.Ftp.UploadFile;
            ftpWebRequest.Credentials = new NetworkCredential(UserNameTextBox.Text, PasswordTextBox.Text);
            ftpWebRequest.KeepAlive = true;

            FileStream fileStream = new FileStream(openFileDialog.FileName, FileMode.Open);

            byte[] fileData = new byte[fileStream.Length];
            fileStream.Read(fileData, 0, (int)fileStream.Length);
            fileStream.Close(); 

            ftpWebRequest.ContentLength = fileData.Length;
            Stream requestStream = ftpWebRequest.GetRequestStream();
            requestStream.Write(fileData, 0, fileData.Length);
            requestStream.Close(); 

            FtpWebResponse ftpWebResponse = (FtpWebResponse)ftpWebRequest.GetResponse(); 

            ResultTextBox.Text += string.Format("\n{0} {1} {2}", uploadFile.Name
, ftpWebResponse.StatusDescription, ftpWebResponse.StatusCode.ToString());
            ftpWebResponse.Close();
        }
    }
    catch (IOException ex)
    {
        MessageBox.Show(ex.Message, ex.GetType().ToString(),
               MessageBoxButtons.OK, MessageBoxIcon.Error);
    }
    catch (WebException ex)
    {
        MessageBox.Show(ex.Message, ex.GetType().ToString(),
            MessageBoxButtons.OK, MessageBoxIcon.Error);
    }
}

17. In the above code:
    • First of all we clear any error in the errorProvider component by calling the Clear method of the errorProvider.
    • We check that the user enters a value in the FtpDirectoryTextBox and we notify him if no value is entered. You will see a blinking red image beside the text box if no value is entered and if you stop the mouse over it a tooltip is displayed with a required text.
    • We then check that the user enters a value in the UserNameTextBox and we notify him if no value is entered. You will see a blinking red image beside the text box if no value is entered and if you stop the mouse over it a tooltip is displayed with a required text.
    • We then check that the user enters a value in the PasswordTextBox and we notify him if no value is entered. You will see a blinking red image beside the text box if no value is entered and if you stop the mouse over it a tooltip is displayed with a required text.
    • We create an object of the OpenFileDialog class that will prompt the user to open a file.
    • We create an object of the Dialogresult class that will hold the result of opening the OpenFileDialog to determine if the user clicks open or cancel.
    • If the user selects to upload the files we create a FileInfo object that will have all the details about the selected file to upload.
    • Create a string object and set it to the FTP upload directory concatenated by the file to upload.
    • We create an FtpWebRequestobject named ftpWebRequest that implements a File Transfer Protocol (FTP) client.
    • We use the WebRequest class (that makes a request to a Uniform Resource Identifier (URI)) to create the request and cast it to FtpWebRequest.
    • We then set the ftpWebRequest Method property to WebRequestMethods.Ftp.UploadFile to make the request uploads the file.
    • Then we set the ftpWebRequest Credentials using the NetworkCredential class and passing to it the user name and password that we will use to authenticate the FTP request.
    • Creat a FileStream object and name it fileStream to open the file to be uploaded.
    • Create a byte array and name it fileData that will be used to store the file data and set its initial capacity to the file stream length.
    • Read the data of the file from the fileStream object and place it in the fileData byte array.
    • Close the fileStream to free memory resourse we don’t need this stream again.
    • We set the ftpWebRequest content length to the length of the fileData byte array.
    • We create a Stream object and name it requestStream this will get its data from the ftpWebRequest.GetRequestStream() method. We will use this stream to write the fileData to the FTP Directory.
    • Close the requestStream object to free memory resources.
    • Create an object of type FtpWebResponse class that encapsulates a File Transfer Protocol (FTP) server's response to a request.
    • Use the ftpWebRequest to get the response to the upload operation using the GetResponse method.
    • Now we have the response to the upload operation we will display the response status code and Status Description in the ResultTextBox.
    • Close the ftpWebResponse object to free memory and resources.
    • We then catch any IO Exceptions and Web Exceptions.

Now you have an application that can be used to upload files to an FTP directory.

Further Improvements:

1. You can collect data from the application user and save it in a file and upload it directly.
2. You can select more than one file from the OpenFileDialog and upload them.