Parallel Programming

If you are writing multi threaded application with .Net , there are various options to choose from. There is Thread,Background worker, delegate etc. 

.Net framework 4.5 has introduced another approach towards parallel programming "async and await". With async n await, code follows a logical structure which looks similar to synchronous code and provides benefits of asynchronous programming.

	async Task<Stream> Act_Async()
	{
	HttpClient client = new HttpClient();
	Task<Stream> stream = client.GetStreamAsync(
	"http://ichart.finance.yahoo.com/table.csv?"+
	"s=GOOG&d=8&e=8&f=2013&g=d&a=7&b=19&c=2004&ignore=.csv");
	Console.WriteLine("This is async task");
	await stream;
	return stream.Result;
	}

view raw AsyncTask hosted with ❤ by GitHub

	static void Main(string[] args)
	{
	Program pro = new Program();
	var stream = pro.Act_Async();
	Console.WriteLine("Back to main method");
	using (stream)
	{
	stream.Result.CopyTo(new FileStream(@"C:\Temp\goog.csv",
	FileMode.Create,
	FileAccess.Write));
	}
	Console.ReadLine();
	}

view raw Program hosted with ❤ by GitHub

Above is an example of a program which downloads the historical prices from Yahoo finance and saves it as a csv file. 

Here Act_Async is an asynchronous method which makes a call to GetStreamAsync and after that performs some operations (which are some print operation for ex.). Once those operation are complete and it requires the output of GetStreamAsync , it await on the return object (which is stream in this case). Once await is called, control is returned to the calling code (which is main method).

In Main method, once the control comes back  it performs some operation (which are again some print operation for ex.) and the thread is never blocked. when it needs the output from Act_Async method, and if Act_Async method has not come back yet, it waits for it to come back. Once the results are back, it proceed with the result for further processing .

Below is similar method written using Thread class.

	void Act_Async2()
	{
	Thread worker = new Thread(new ParameterizedThreadStart(Download));
	worker.Start("http://ichart.finance.yahoo.com/table.csv?"+
	"s=GOOG&d=8&e=8&f=2013&g=d&a=7&b=19&c=2004&ignore=.csv");
	Console.WriteLine("Do some other work");
	worker.Join();
	}
	private void Download(object urlObj)
	{
	string url = urlObj.ToString();
	HttpWebRequest req = (HttpWebRequest)HttpWebRequest.Create(url);
	var response = req.GetResponse();
	var response_stream = response.GetResponseStream();
	stream = response_stream;
	}

view raw gistfile1.cs hosted with ❤ by GitHub

	static void Main(string[] args)
	{
	Program pro = new Program();
	pro.Act_Async2();
	Console.WriteLine("Back to main method");
	using (pro.stream)
	{
	pro.stream.CopyTo(new FileStream(@"C:\Temp\goog.csv",
	FileMode.Create,
	FileAccess.Write));
	}
	Console.ReadLine();
	}

view raw gistfile2.cs hosted with ❤ by GitHub

Some of the key differences- 

1.  You need to make use of a shared variable which thread updates since ThreadStart delegate can not point to a method which returns a value (difficult to use with functional programming) while async method can return an object.  
2. The flow of the code is not as smooth as with async n await. code may look similar but code with async n await is much more easy to understand and follows a sequential structure. 
3. The flexibility with using Thread is that You can manage it ( Do you really want to !!!) like setting up background/foreground , priority etc . 

There may be some cases where you need certain notification on progress of parallel tasks (some of these are provided in background worker class) those are not available here but you can use async n await in almost any case where you are using any other threading approach for parallel processing.

For more details , visit MSDN.