If you like to submit a POST form to your server the following will explain how to do create the program.

To help with debugging I created a tiny test script on my server to see if my code was working as advertised: http://www.dijksterhuis.org/test/post.php Please feel free to use this script to see if your program is working correctly.

My wrapper code is easy to use and allows for you to add any number of parameters to the POST request:

			WebPostRequest myPost = new WebPostRequest("http://www.dijksterhuis.org/test/post.php");
			myPost.Add("keyword","void");
			myPost.Add("data","hello&+-[]");

I use the HttpUtility.UrlEncode method to ensure that all parameters containing weird symbols survive their trip over the Internet intact.

string Response = myPost.GetResponse();

The above function call executes the query and returns any response from the server. The test script simply echoes the parameters and their values.

using System;
using System.Net;
using System.Web;
using System.Collections;
using System.IO;

namespace WebRequestExample
{

	class WebPostRequest
	{
		WebRequest theRequest;
		HttpWebResponse theResponse;
		ArrayList  theQueryData;

		public WebPostRequest(string url)
		{
			theRequest = WebRequest.Create(url);
			theRequest.Method = "POST";
			theQueryData = new ArrayList();
		}

		public void Add(string key, string value)
		{
			theQueryData.Add(String.Format("{0}={1}",key,HttpUtility.UrlEncode(value)));
		}

		public string GetResponse()
		{
			// Set the encoding type
			theRequest.ContentType="application/x-www-form-urlencoded";

			// Build a string containing all the parameters
			string Parameters = String.Join("&",(String[]) theQueryData.ToArray(typeof(string)));
			theRequest.ContentLength = Parameters.Length;

			// We write the parameters into the request
			StreamWriter sw = new StreamWriter(theRequest.GetRequestStream());
  			sw.Write(Parameters);
  			sw.Close();

			// Execute the query
			theResponse =  (HttpWebResponse)theRequest.GetResponse();
  			StreamReader sr = new StreamReader(theResponse.GetResponseStream());
   			return sr.ReadToEnd();
		}

	}

	class MainClass
	{
		public static void Main(string[] args)
		{
			WebPostRequest myPost = new WebPostRequest("http://www.dijksterhuis.org/test/post.php");
			myPost.Add("keyword","void");
			myPost.Add("data","hello&+-[]");
			Console.WriteLine(myPost.GetResponse());
		}
	}
}

This is a post from Martijn's C# Coding Blog.

At the end of this post you will find my BasicFTPClient class that implements the uploading and downloading code.

1. Download an FTP file to disk

If you have a file called “fileonftpserver.txt” and would like to download it to “/tmp/mydownload.txt” use the “DownloadFile” method:

BasicFTPClient MyClient = new BasicFTPClient();

MyClient.Host="myserver.com";
MyClient.Username="yourusername";
MyClient.Password="yourpassword";

try
{
     MyClient.DownloadFile("fileonftpserver.txt","/tmp/mydownload.txt"); // c:\temp\mydownload.txt for Windows
}
catch (WebException e)
{
     Console.WriteLine(e.ToString());
}

2. Download an FTP file to memory

If you would like to directly process the file you have downloaded (and don’t need to save it to disk first) the “DownloadData” method is your friend. If you would like to print the contents of the file to the console you could try this:

BasicFTPClient MyClient = new BasicFTPClient();

MyClient.Host="myserver.com";
MyClient.Username="yourusername";
MyClient.Password="yourpassword";

try
{
    byte[] Data = MyClient.DownloadData("download.test");

    // Convert the data to a string
    String s = System.Text.Encoding.UTF8.GetString(Data);
    Console.WriteLine(s);
}
catch (WebException e)
{
    Console.WriteLine(e.ToString());
}

3. Upload a file to the FTP server

If you have a file on disk and would like to upload it to an FTP server then use the “UploadFile” method.

BasicFTPClient MyClient = new BasicFTPClient();

MyClient.Host="myserver.com";
MyClient.Username="yourusername";
MyClient.Password="yourpassword";

try
{
    MyClient.UploadFile("upload.test","/tmp/output.txt");
}
catch (WebException e)
{
    Console.WriteLine(e.ToString());
}

4. Upload a byte[] to the FTP server

The “UploadData” method takes a byte array as the source of its data, allowing you to create something in memory and then save it to an FTP server. Usefull for those reports you have just generated.

BasicFTPClient MyClient = new BasicFTPClient();

MyClient.Host="myserver.com";
MyClient.Username="yourusername";
MyClient.Password="yourpassword";

try
{
    string MyReport = "Sales figures for October 2010";
    byte[] Data = System.Text.Encoding.UTF8.GetBytes(MyReport);
    MyClient.UploadData("upload.test",Data);
}
catch (WebException e)
{
    Console.WriteLine(e.ToString());
}

The Mono angle

All of the above examples work on Mono just as well as on Microsoft’s .NET. With a catch: I found two bugs in the Mono class libraries that made things quite impossible. Both were fixed by the mono team within hours of reporting them (thanks!). So if you are using the Mono CVS code for Mono 2.4 you are in luck, otherwise the following code is not going to work until the next Mono release.

If you come across a problem with Mono reporting a bug is trivial, you can report them at bugzilla.novell.com

The BasicFTPClient class

using System;
using System.Net;
using System.IO;

namespace BasicFTPClientNamespace
{
    class BasicFTPClient
    {
        public string Username;
        public string Password;
        public string Host;
        public int Port;

        public BasicFTPClient()
        {
            Username = "anonymous";
            Password = "anonymous@internet.com";
            Port = 21;
            Host = "";
        }

        public BasicFTPClient(string theUser, string thePassword, string theHost)
        {
            Username = theUser;
            Password = thePassword;
            Host = theHost;
            Port = 21;
        }

        private Uri BuildServerUri(string Path)
        {
            return new Uri(String.Format("ftp://{0}:{1}/{2}", Host, Port, Path));
        }

        /// <summary>
        /// This method downloads the given file name from the FTP server
        /// and returns a byte array containing its contents.
        /// Throws a WebException on encountering a network error.
        /// </summary>

        public byte[] DownloadData(string path)
        {
            // Get the object used to communicate with the server.
            WebClient request = new WebClient();

            // Logon to the server using username + password
            request.Credentials = new NetworkCredential(Username, Password);
            return request.DownloadData(BuildServerUri(path));
        }

        /// <summary>
        /// This method downloads the FTP file specified by "ftppath" and saves
        /// it to "destfile".
        /// Throws a WebException on encountering a network error.
        /// </summary>
        public void DownloadFile(string ftppath, string destfile)
        {
            // Download the data
            byte[] Data = DownloadData(ftppath);

            // Save the data to disk
            FileStream fs = new FileStream(destfile, FileMode.Create);
            fs.Write(Data, 0, Data.Length);
            fs.Close();
        }

        /// <summary>
        /// Upload a byte[] to the FTP server
        /// </summary>
        /// <param name="path">Path on the FTP server (upload/myfile.txt)</param>
        /// <param name="Data">A byte[] containing the data to upload</param>
        /// <returns>The server response in a byte[]</returns>

        public byte[] UploadData(string path, byte[] Data)
        {
            // Get the object used to communicate with the server.
            WebClient request = new WebClient();

            // Logon to the server using username + password
            request.Credentials = new NetworkCredential(Username, Password);
            return request.UploadData(BuildServerUri(path), Data);
        }

        /// <summary>
        /// Load a file from disk and upload it to the FTP server
        /// </summary>
        /// <param name="ftppath">Path on the FTP server (/upload/myfile.txt)</param>
        /// <param name="srcfile">File on the local harddisk to upload</param>
        /// <returns>The server response in a byte[]</returns>

        public byte[] UploadFile(string ftppath, string srcfile)
        {
            // Read the data from disk
            FileStream fs = new FileStream(srcfile, FileMode.Open);
            byte[] FileData = new byte[fs.Length];

            int numBytesToRead = (int)fs.Length;
            int numBytesRead = 0;
            while (numBytesToRead > 0)
            {
                // Read may return anything from 0 to numBytesToRead.
                int n = fs.Read(FileData, numBytesRead, numBytesToRead);

                // Break when the end of the file is reached.
                if (n == 0) break;

                numBytesRead += n;
                numBytesToRead -= n;
            }
            numBytesToRead = FileData.Length;
            fs.Close();

            // Upload the data from the buffer
            return UploadData(ftppath, FileData);
        }

    }
}

This is a post from Martijn's C# Coding Blog.