Almost any software application today will likely contain a long-running process. “Long-running” may be a relative term but in the Windows Runtime it is specifically anything that could take longer than 50ms to execute. That’s a fairly small window, and it means those operations will need to run concurrently to the main application thread. Concurrency is important in both client applications (to keep from blocking the UI) and server applications (to accommodate multiple simultaneous requests).
The new technology referred to as Visual Studio Asynchronous Programming provides a streamlined language syntax for asynchronous development. It does this by providing two new keywords: async and await. While these keywords may simplify asynchronous development, they can still be confusing to developers. There are a lot of materials out there but I thought it might help to take a very simple example and explore just what these keywords are and how they operate. In this post I’ll focus specifically on the .NET Framework 4.5 support. While they are also supported for Metro-style applications, the implementation is slightly different.
The Main Event
In the movie Mission Impossible II, the short-lived protagonist Dr. Nekhorvich says:
“…every search for a hero must begin with something every hero needs, a villain. So in a search for our hero, Bellerophon, we have created a more effective monster: Chimera.”
In the search for an elegant solution to asynchronous programming we must start with some of the rougher implementations that have plagued developers in the past.
The event-based pattern is probably one of the most well-known asynchronous patterns to .NET developers as it is prevalent throughout the base library. Let’s assume I have a method that multiplies two numbers and for some crazy reason (maybe I’m sending it over a 300 baud modem to my Commodore 64 to process the result on the 6502 chip … you know, using a bunch of ROR operations) it takes a bit longer to process than I’d like, so I want to make sure it executes asynchronously. The first thing I’ll do is create an event argument payload for the result:
public class MultiplyEventArgs : EventArgs
{
public int Result
{
get;
private set;
}
public MultiplyEventArgs(int result)
{
Result = result;
}
}
Next, I’ll define an interface:
public interface IMultiplierEvent
{
event EventHandler<MultiplyEventArgs> MultiplyCompleted;
void MultiplyAsync(int a, int b);
}
Finally, I’ll implement the class that executes the operation asynchronous and fires the completed event when done.
public class MultiplierEvent : IMultiplierEvent
{
public event EventHandler<MultiplyEventArgs> MultiplyCompleted;
private void RaiseCompleted(int result)
{
var handler = MultiplyCompleted;
if (handler != null)
{
handler(this, new MultiplyEventArgs(result));
}
}
public void MultiplyAsync(int a, int b)
{
Task.Run(() => RaiseCompleted(a * b));
}
}
Read more: C#:IMage
QR: 