Multilevel asynchronous method call pattern in c#

Question

Hi,

I have design problem regarding async calls to method.

I'd like to know best/good pattern to call async method, which calls another async method, which calls another async method :)

In other words, I have WCF service reference created with async methods and I want to call them from another async method which is called by other async method. All this for non blocking GUI.

Thanks!

Answer 1

Switch to F#, where calling/composing async methods is nearly as easy as the sync ones.

(See also

LINQ for sequential async code in C#: http://lorgonblog.spaces.live.com/blog/cns!701679AD17B6D310!208.entry

F# on the server side (async comparison with C#): http://lorgonblog.spaces.live.com/blog/cns!701679AD17B6D310!1847.entry

F# on the client side (easy): http://lorgonblog.spaces.live.com/blog/cns!701679AD17B6D310!1842.entry

)

Answer 2

If your only goal is to have a non blocking GUI then the multiple levels are unnecessary. Once your toplevel method runs in the background, your GUI is freed. Using multiple levels does bring extra complexity.

There can be other reasons (performance) to call the lower level methods async, but it depends. Do you need to wait for results later on?

So I don't think there is a 'pattern' here.

Answer 3

One example of when it would be good to have multiple levels would be when creating asynchronous controllers in a MVC framework like MonoRail or MS MVC. The end thing that calls into something IO-blocking, such as SqlCommand from System.Data.SqlClient or some socket, would put the IO operand on an IO completion port: http://msdn.microsoft.com/library/aa365198, which would save the managed/unmanaged thread's quanta for something more useful.

If you write classes that return IAsyncResult, then you are not far away from implementing co-routines. Here's a good article about how asynchronous programming can be used with coroutines: http://blogs.msdn.com/b/pfxteam/archive/2009/06/30/9809774.aspx.

Caliburn, a WPF framework supports co-routines natively. The task parallel library, released with .Net 4, has given its task the IAsyncResult interface. [If you are at 3.5 then you might need to create your own implementation (they are pretty simple to make, just implement the interface).] Co-routines are a way of using the compiler re-writes of IEnumerable to push IAsyncResults to a stack of things to do (as seen from the "async manager").

F# async (like seen in the down-voted answer) uses a monad (as monadic as they get on the CLR) to move the state of the asynchronous request from the Begin* to End* methods. The compilers both this into nested lambda expressions/SelectMany.