Asynchronous Programming - Call Chains

When a pair of BeginXxx()/EndXxx() calls appear in the code, this is acceptable. But what if the algorithm requires several such calls in a row, then the number of methods (or anonymous delegates) will multiply and the code will become less readable. Fortunately, this problem is solved in both F # and C #.

Task

So, imagine that you want to download a web page in a fully asynchronous mode and save it on your hard disk. For this you need

Start downloading site page
When it downloads, start writing the file to disk.
When the recording is complete, close the file stream and notify the user.

A simple solution

A naive solution to a problem looks like this:

static void Main( string [] args) { Program p = new Program(); // p.DownloadPage( "http://habrahabr.ru" ); // 10. p.waitHandle.WaitOne(10000); } // private WebRequest wr; private FileStream fs; private AutoResetEvent waitHandle = new AutoResetEvent( false ); // public void DownloadPage( string url) { wr = WebRequest.Create(url); wr.BeginGetResponse(AfterGotResponse, null ); } // private void AfterGotResponse(IAsyncResult ar) { var resp = wr.EndGetResponse(ar); var stream = resp.GetResponseStream(); var reader = new StreamReader(stream); string html = reader.ReadToEnd(); // true fs = new FileStream( @"c:\temp\file.htm" , FileMode.CreateNew, FileAccess.Write, FileShare.None, 1024, true ); var bytes = Encoding.UTF8.GetBytes(html); // fs.BeginWrite(bytes, 0, bytes.Length, AfterDoneWriting, null ); } // , wait handle private void AfterDoneWriting(IAsyncResult ar) { fs.EndWrite(ar); fs.Flush(); fs.Close(); waitHandle.Set(); }

This solution still flowers. Imagine, for example, that you additionally need to download and save asynchronously all the pictures, and only when they are all saved open the folder in which they were recorded. Using the paradigm above, this is a real nightmare.

Solution through anonymous delegates

The first thing you can do is group the pieces of functionality into anonymous delegates [ 1 ]. Then we get something like this:

private AutoResetEvent waitHandle = new AutoResetEvent( false ); public void DownloadPage( string url) { var wr = WebRequest.Create(url); wr.BeginGetResponse(ar => { var resp = wr.EndGetResponse(ar); var stream = resp.GetResponseStream(); var reader = new StreamReader(stream); string html = reader.ReadToEnd(); var fs = new FileStream( @"c:\temp\file.htm" , FileMode.CreateNew, FileAccess.Write, FileShare.None, 1024, true ); var bytes = Encoding.UTF8.GetBytes(html); fs.BeginWrite(bytes, 0, bytes.Length, ar1 => { fs.EndWrite(ar1); fs.Flush(); fs.Close(); waitHandle.Set(); }, null ); }, null ); }

This solution looks good, but if the call chain is really large, the code will not be readable and difficult to manage. This is especially true when, for example, the execution of a chain needs to be suspended and canceled.

Solution using asynchronous workflows

Workflow is an F # construct. The idea is approximately the same - you define a certain block in which some operators (such as let , for example) are redefined. Asynchronous workflow is such a workflow within which the operators ( let! do! And others) are redefined so that these operators allow you to “wait” for the operation to complete. That is, when we write

async { ⋮ let ! x = Y() ⋮ } 

this means that we make a call to BeginYyy() for Y , and when the result is available, we write the result in x .

Thus, the analogue of downloading and writing a file to F # will look something like this:

// / // F# type WebRequest with member x.GetResponseAsync() = Async.BuildPrimitive(x.BeginGetResponse, x.EndGetResponse) let private DownloadPage(url:string) = async { try let r = WebRequest.Create(url) let ! resp = r.GetResponseAsync() // let! use stream = resp.GetResponseStream() use reader = new StreamReader(stream) let html = reader.ReadToEnd() use fs = new FileStream( @"c:\temp\file.htm" , FileMode.Create, FileAccess.Write, FileShare.None, 1024, true ); let bytes = Encoding.UTF8.GetBytes(html); do ! fs.AsyncWrite(bytes, 0, bytes.Length) // with | :? WebException -> () } // , - Async.RunSynchronously(DownloadPage( "http://habrahabr.ru" ))

Using clever syntactic constructions, F # allows us using specially created "primitives" (such as GetResponseAsync() and AsyncWrite() ) to make calls with Begin / End semantics, but without dividing them into individual methods or delegates. Oddly enough, you can do about the same thing in C #.

Solution using asynchronous enumerator

Jeffrey Richter, the well-known author of the book CLR via C #, is also the author of the PowerThreading library. This library [ 2 ] provides a number of interesting features, one of which is an implementation of the asynchronous workflow analogue in C #.

This is done very simply - we have a certain “manager of tokens” called AsyncEnumerator . This class actually allows you to interrupt the execution of the method and continue it again. How can I interrupt the execution of a method? This is done using a simple yield return .

Using AsyncEnumerator easy. We take and add it as a parameter to our method, and also change the return value to IEnumerator<int> :

public IEnumerator< int > DownloadPage( string url, AsyncEnumerator ae ) { ⋮ } 

Next, we write code using BeginXxx()/EndXxx() , using three simple rules:

Each BeginXxx () receives ae.End() as a callback parameter.
Each EndXxx () as a token IAsyncResult gets ae.DequeueAsyncResult()
Every time we need to wait, we make a yield return X , where X is the number of operations started.

This is what our download method looks like when using AsyncEnumerator :

public IEnumerator< int > DownloadPage( string url, AsyncEnumerator ae) { var wr = WebRequest.Create(url); wr.BeginGetResponse(ae.End(), null ); yield return 1; var resp = wr.EndGetResponse(ae.DequeueAsyncResult()); var stream = resp.GetResponseStream(); var reader = new StreamReader(stream); string html = reader.ReadToEnd(); using ( var fs = new FileStream( @"c:\temp\file.htm" , FileMode.Create, FileAccess.Write, FileShare.None, 1024, true )) { var bytes = Encoding.UTF8.GetBytes(html); fs.BeginWrite(bytes, 0, bytes.Length, ae.End(), null ); yield return 1; fs.EndWrite(ae.DequeueAsyncResult()); } }

As you can see, the asynchronous method is now recorded in a synchronous form - we even managed to use using for the file stream. The code has become more readable, unless of course additional returns yield returns are considered.

It now remains only to call this method:

static void Main() { Program p = new Program(); var ae = new AsyncEnumerator(); ae.Execute(p.DownloadPage( "http://habrahabr.ru" , ae)); } 

Conclusion

The problem of chains of asynchronous calls was not so terrible. For simple situations, anonymous delegates will do; for complex ones, there are asynchronous workflows and AsyncEnumerator , depending on which language is closer to you.

Chains are simple, but what to do with whole dependency graphs? About this - in the next post. ■

Notes

↑ It is noteworthy that you can initially make separate methods, and then "zainlaynit" them using ReSharper'a.
↑ The library is really interesting - I advise you to open it in Reflector, there are a lot of tasty things there. Also note that the library license only allows you to use it on Windows, which will surely piss off Mono fans.

Source: https://habr.com/ru/post/71625/

All Articles