{"id":2713,"date":"2008-03-16T15:59:32","date_gmt":"2008-03-16T15:59:32","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/pfxteam\/2008\/03\/16\/wrapping-an-apm-implementation-with-futuret\/"},"modified":"2008-03-16T15:59:32","modified_gmt":"2008-03-16T15:59:32","slug":"wrapping-an-apm-implementation-with-futuret","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/dotnet\/wrapping-an-apm-implementation-with-futuret\/","title":{"rendered":"Wrapping an APM implementation with Future"},"content":{"rendered":"

In a previous post, I talked about implementing the Asynchronous Programming Model<\/a> pattern using Future<T> from Parallel Extensions to the .NET Framework<\/a>.  It’s also possible to go in the opposite direction, to create a Future<T> from an existing APM implementation.<\/p>\n

As has been shown in previous examples, in this example we’ll take advantage of the “promise” capabilities provided by Future<T>.  This allows a Future<T> to be created without a Func<T> delegate, such that the future’s Value and Exception properties can be set explicitly, but only once; any thread waiting on the Future<T> will block until one of these properties is set.<\/p>\n

\n

static<\/span> Future<\/span><T> Create<T>(
    Action<\/span><AsyncCallback<\/span>> beginFunc,
    Func<\/span><IAsyncResult<\/span>, T> endFunc)
<\/span>{
<\/span>    <\/span>var <\/span>f = Future<\/span><T>.Create();
<\/span>    <\/span>beginFunc(iar => {
<\/span>        <\/span>try<\/span> { f.Value = endFunc(iar); }
<\/span>        <\/span>catch<\/span> (Exception<\/span> e) { f.Exception = e; }
<\/span>    <\/span>});
<\/span>    <\/span>return<\/span> f;
<\/span>}<\/span><\/p>\n<\/blockquote>\n

This Create<T> method first creates a Future<T> as a promise.  It then calls a delegate provided by the caller to start the asynchronous action using the relevant BeginXx method; as an argument to that action, this code passes a delegate that will be called back by the asynchronous operation when it completes; the APM method will pass an IAsyncResult, which will then be passed in this callback to the endFunc delegate provided by the caller.  That endFunc will call the EndXx method, and will use the resulting value or exception to set the Future<T>.<\/p>\n

As an example of using this, consider a FileStream.  FileStream exposes a BeginRead method:<\/p>\n

\n

IAsyncResult<\/span> BeginRead(
    byte<\/span>[] array, int<\/span> offset, int<\/span> numBytes,
    AsyncCallback<\/span> userCallback, object<\/span> stateObject)<\/span><\/p>\n<\/blockquote>\n

as well as a corresponding EndRead method:<\/p>\n

\n

int<\/span> EndRead(IAsyncResult<\/span> asyncResult);<\/span><\/p>\n<\/blockquote>\n

If we want to create a Future<T> that represents an asynchronous read operation on a FileStream, we could do so with our new Create method as follows:<\/p>\n

\n

var<\/span> readFuture = Create<int<\/span>>(
    <\/span>ac => fs.BeginRead(buffer, 0, buffer.Length, ac, null<\/span>),
    <\/span>fs.EndRead);<\/span><\/p>\n<\/blockquote>\n

I can now go off and do something else, and when I later get readFuture’s Value, I’ll block until the asynchronous operation completes (or return immediately with the result if it’s already completed).  If the FileStream was created to support asynchronous I\/O operations and if the underlying version of Windows supports asynchronous I\/O, while the read request is happening, no threads will be used, and yet I’ll still have a valid Future<T> to represent the operation.<\/p>\n

There are of course other possible designs for and implementations of such a Create method.  An alternate implementation might look like this:<\/p>\n

\n

static<\/span> Future<\/span><T> Create<T>(
    IAsyncResult<\/span> iar, Func<\/span><IAsyncResult<\/span>, T> endFunc)
<\/span>{
<\/span>    <\/span>var<\/span> f = Future<\/span><T>.Create();
<\/span>    <\/span>ThreadPool<\/span>.RegisterWaitForSingleObject(
            iar.AsyncWaitHandle, delegate <\/span><\/span>{
<\/span>        <\/span>try<\/span> { f.Value = endFunc(iar); }
<\/span>        <\/span>catch<\/span> (Exception<\/span> e) { f.Exception = e; }
<\/span>    <\/span>}, null<\/span>, -1, true<\/span>);
<\/span>    <\/span>return<\/span> f;
<\/span>}<\/span><\/p>\n<\/blockquote>\n

Here’s I’m using the same promise functionality of Future<T>, but instead of using the callback functionality of the APM, I’m relying on ThreadPool’s RegisterWaitForSingleObject functionality.  When the provided IAsyncResult’s AsyncWaitHandle is signaled (which will happen when the asynchronous operation completes), my delegate will be called to call endFunc and set the Future<T>’s Value or Exception property as shown previously.  This version can be used as follows:<\/p>\n

\n

var<\/span> readFuture = Create<int<\/span>>(
    fs.BeginRead(buffer, 0, buffer.Length, null<\/span>, null<\/span>),
    fs.EndRead);<\/span><\/p>\n<\/blockquote>\n

Now comes the interesting question…<\/p>\n

We don’t currently have a Create method like this on Future<T>.  You can write your own as has been shown here, but is this important enough for us to include one on Future<T> itself?  Do you have such a need in your applications?  Should we provide deeper support to further enable this kind of integration? Let us know \ud83d\ude42<\/p><\/p>\n","protected":false},"excerpt":{"rendered":"

In a previous post, I talked about implementing the Asynchronous Programming Model pattern using Future<T> from Parallel Extensions to the .NET Framework.  It’s also possible to go in the opposite direction, to create a Future<T> from an existing APM implementation. As has been shown in previous examples, in this example we’ll take advantage of the […]<\/p>\n","protected":false},"author":360,"featured_media":58792,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[7908],"tags":[7911,7909,7912,7914],"class_list":["post-2713","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-pfxteam","tag-code-samples","tag-parallel-extensions","tag-task-parallel-library","tag-threadpool"],"acf":[],"blog_post_summary":"

In a previous post, I talked about implementing the Asynchronous Programming Model pattern using Future<T> from Parallel Extensions to the .NET Framework.  It’s also possible to go in the opposite direction, to create a Future<T> from an existing APM implementation. As has been shown in previous examples, in this example we’ll take advantage of the […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts\/2713","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/users\/360"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/comments?post=2713"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts\/2713\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/media\/58792"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/media?parent=2713"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/categories?post=2713"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/tags?post=2713"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}