{"id":55933,"date":"2010-04-04T13:34:00","date_gmt":"2010-04-04T13:34:00","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/pfxteam\/2010\/04\/04\/parallelextensionsextras-tour-1-linq-to-tasks\/"},"modified":"2010-04-04T13:34:00","modified_gmt":"2010-04-04T13:34:00","slug":"parallelextensionsextras-tour-1-linq-to-tasks","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/dotnet\/parallelextensionsextras-tour-1-linq-to-tasks\/","title":{"rendered":"ParallelExtensionsExtras Tour – #1 – LINQ to Tasks"},"content":{"rendered":"

(The full set of ParallelExtensionsExtras Tour posts is available here<\/a>.)<\/em> <\/font><\/p>\n

The <\/font>.NET Framework developer center<\/font><\/a> provides a concise description of Language Integrated Query (LINQ):<\/p>\n

<\/font><\/font><\/p>\n

LINQ is a set of extensions to the .NET Framework that encompass language-integrated query, set, and transform operations. It extends C# and Visual Basic with native language syntax for queries and provides class libraries to take advantage of these capabilities.<\/p>\n

<\/font><\/font><\/em><\/p>\n

These “operations” are more of a pattern than anything else, in that there isn’t just one implementation of them.  <\/span>Rather, any framework that wishes to follow the structure set forth by LINQ can do so, implementing the operators in a manner that befits the nature of the framework.  <\/span>There is a primary implementation of these LINQ operators against any IEnumerable<T> (an implementation typically referred to as LINQ to Objects<\/a>), but that’s just the beginning.  <\/span>There’s a parallelized implementation of LINQ to Objects in the form of Parallel LINQ to Objects, or PLINQ<\/a>.  <\/span>There’s an implementation that targets SQL Server databases, known as LINQ to SQL<\/a>.  <\/span>There’s an implementation that targets IObservable<T> known as Reactive Extensions<\/a>.  <\/span>And many more.  <\/span>What’s more, the C# and Visual Basic language syntax for these queries targets the aforementioned pattern rather than a specific implementation of that pattern, and as a result, it works with most of these providers in an easily pluggable manner.<\/p>\n

<\/font><\/font><\/p>\n

ParallelExtensionsExtras<\/font><\/a> includes an implementation of a subset of the LINQ operators.  <\/span>This implementation targets System.Threading.Tasks.Task instances rather than enumerables or observables or whatever other source.  <\/span>In doing so, it enables usage of the language syntax for writing asynchronous code, in very much the same manner that Reactive Extensions does, albeit in a much more limited form.<\/p>\n

<\/font><\/font><\/p>\n

Let’s start by looking at a very simple query against enumerables:<\/p>\n

<\/font><\/font><\/p>\n

IEnumerable<string> result = from item in enumerable<\/p>\n

<\/font><\/p>\n

 <\/span>            <\/span>                <\/span>select item.ToString();<\/p>\n

<\/font><\/p>\n

\n

 <\/font><\/p>\n<\/p>\n

The C# compiler compiles this query to the equivalent of the following:<\/p>\n

<\/font><\/font><\/p>\n

IEnumerable<string> result = enumerable.Select<int,string>(<\/font><\/p>\n

    (int item) => return item.ToString());<\/p>\n

<\/font><\/p>\n

\n

 <\/font><\/p>\n<\/p>\n

This code utilizes the LINQ Select method, and specifically the following override:<\/p>\n

<\/font><\/font><\/p>\n

public static IEnumerable<TResult> Select<TSource, TResult>(<\/p>\n

<\/font><\/p>\n

    <\/span>this IEnumerable<TSource> source, <\/p>\n

<\/font><\/p>\n

    <\/span>Func<TSource, TResult> selector);<\/p>\n

<\/font><\/p>\n

\n

 <\/font><\/p>\n<\/p>\n

This is the specific implementation of the select pattern for IEnumerable<T>, but any type can be substituted in for it (for the “X” in the below signature):<\/p>\n

<\/font><\/font><\/p>\n

public static X<\/b><TResult> Select<TSource, TResult>(<\/p>\n

<\/font><\/p>\n

    <\/span>this X<\/b><TSource> source, <\/p>\n

<\/font><\/p>\n

    <\/span>Func<TSource, TResult> selector);<\/p>\n

<\/font><\/p>\n

\n

 <\/font><\/p>\n<\/p>\n

As long as a type has an accessible method (or extension method) that fits this pattern, the C# compiler may bind to it.  <\/span>So, we can substitute “Task” for “X”, giving us:<\/p>\n

<\/font><\/font><\/p>\n

public static Task<\/strong><TResult> Select<TSource, TResult>(<\/p>\n

<\/font><\/p>\n

    <\/span>this Task<\/strong><TSource> source, <\/p>\n

<\/font><\/p>\n

    <\/span>Func<TSource, TResult> selector);<\/p>\n

<\/font><\/p>\n

\n

 <\/font><\/p>\n<\/p>\n

Now we just need to figure out how to implement this method.  <\/span>Given a Task<TSource> source, we need to get its result of type TSource, run it through a selector function to produce a TResult, and a return a new Task<TResult> that will provide the resulting value.  <\/span>Ideally, we’d do this in an asynchronous manner, such that the resulting Task<TResult> would represent the asynchronous processing of the selector function with the result of the input Task<TSource> once it had completed.  <\/span>As it turns out, this is trivial to do with Task’s ContinueWith method:<\/p>\n

<\/font><\/font><\/p>\n

public static Task<TResult> Select<TSource, TResult>(<\/p>\n

<\/font><\/p>\n

    <\/span>this Task<TSource> source, <\/p>\n

<\/font><\/p>\n

    <\/span>Func<TSource, TResult> selector)<\/p>\n

<\/font><\/p>\n

{<\/p>\n

<\/font><\/p>\n

    <\/span>return source.ContinueWith(t => selector(t.Result));<\/p>\n

<\/strong><\/font><\/p>\n

}<\/p>\n

<\/font><\/p>\n

\n

 <\/font><\/p>\n<\/p>\n

By implementing just that one extension method, we can now successful write the following C# code:<\/p>\n

<\/font><\/font><\/p>\n

Task<string> result = from x in Task.Factory.StartNew(<\/font><\/p>\n

                          () => ProduceInt())<\/p>\n

<\/font><\/p>\n

                      <\/span>select x.ToString();<\/p>\n

<\/font><\/p>\n

\n

 <\/font><\/p>\n<\/p>\n

That alone isn’t all that interesting.  <\/span>What if I wanted to chain multiple tasks together, for example:<\/p>\n

<\/font><\/font><\/p>\n

Task<string> result = from x in Task.Factory.StartNew(<\/font><\/p>\n

                          () => ProduceInt())<\/p>\n

<\/font><\/p>\n

                      <\/span>from y in Task.Factory.StartNew(<\/font><\/p>\n

                          () => Process(x))<\/p>\n

<\/font><\/p>\n

                      <\/span>select y.ToString();<\/p>\n

<\/font><\/p>\n

\n

 <\/font><\/p>\n<\/p>\n

Now I’m looking to asynchronous execute ProduceInt() to give me an integral value x<\/em>.  <\/span>Then I want to asynchronously process x<\/em> and produce a new value y<\/em>, at which point I want to asynchronously process y<\/em> by getting its string representation, and I want a resulting Task<string> to represent that.  <\/span>This pattern of multiple from clauses is handled by the C# compiler with the SelectMany operator.  <\/span>Here is the relevant signature of SelectMany for enumerables:<\/p>\n

<\/font><\/font><\/p>\n

public static IEnumerable<TResult> SelectMany<\/font><\/p>\n

        <TSource, TCollection, TResult>(<\/p>\n

<\/font><\/p>\n

    <\/span>this IEnumerable<TSource> source, <\/p>\n

<\/font><\/p>\n

    <\/span>Func<TSource, IEnumerable<TCollection>> collectionSelector, <\/p>\n

<\/font><\/p>\n

    <\/span>Func<TSource, TCollection, TResult> resultSelector);<\/p>\n

<\/font><\/p>\n

\n

 <\/font><\/p>\n<\/p>\n

Given a source, this method runs the collectionSelector function for each item in the source, producing an enumerable for each item.  <\/span>That item and its resulting enumerable are then provided to a resultSelector function, which produces the final result that’s yielded as part of SelectMany’s output enumerable.  <\/span>The same thing is possible for Task, again by substituting “Task” anywhere we see “IEnumerable”:<\/p>\n

<\/font><\/font><\/p>\n

public static Task<\/b><TResult> SelectMany<\/font><\/p>\n

        <TSource, TCollection, TResult>(<\/p>\n

<\/font><\/p>\n

    <\/span>this Task<\/b><TSource> source, <\/p>\n

<\/font><\/p>\n

    <\/span>Func<TSource, Task<\/b><TCollection>> collectionSelector, <\/p>\n

<\/font><\/p>\n

    <\/span>Func<TSource, TCollection, TResult> resultSelector);<\/p>\n

<\/font><\/p>\n

\n

 <\/font><\/p>\n<\/p>\n

This method is a bit more complicated to implement, but it is still just a few lines of code by taking advantage of ContinueWith:<\/p>\n

<\/font><\/font><\/p>\n

public static Task<TResult> SelectMany<\/font><\/p>\n

        <TSource, TCollection, TResult>(<\/p>\n

<\/font><\/p>\n

    <\/span>this Task<TSource> source,<\/p>\n

<\/font><\/p>\n

    <\/span>Func<TSource, Task<TCollection>> collectionSelector,<\/p>\n

<\/font><\/p>\n

    <\/span>Func<TSource, TCollection, TResult> resultSelector)<\/p>\n

<\/font><\/p>\n

{<\/p>\n

<\/font><\/p>\n

    <\/span>return source.ContinueWith(t =><\/p>\n

<\/font><\/p>\n

    <\/span>{<\/p>\n

<\/font><\/p>\n

        <\/span>Task<TCollection> ct = collectionSelector(t.Result);<\/p>\n

<\/font><\/p>\n

        <\/span>return ct.ContinueWith(_ => <\/font><\/p>\n

            resultSelector(t.Result, ct.Result));<\/p>\n

<\/font><\/p>\n

    <\/span>}).Unwrap();<\/p>\n

<\/font><\/p>\n

}<\/p>\n

<\/font><\/p>\n

\n

 <\/font><\/p>\n<\/p>\n

First, we continue from the source to signal us when it’s completed.  <\/span>At that point, we run the collectionSelector with the source’s result in order to produce the intermediate Task<Collection>.  <\/span>When that intermediate task has completed (which we again know by using ContinueWith), we run the result selector over the two previous results to produce the final value.  <\/span>Of course, this result of the second ContinueWith call (which produces a Task<TResult>) is being returned as a the result of the first ContinueWith call, such that the outer ContinueWith is actually returning a Task<Task<TResult>>.  <\/span>But SelectMany needs to return just a Task<TResult>.  <\/span>The Unwrap method provided by the Task Parallel Library handles this conversion, providing a Task<TResult> that asynchronously represents the combination of the outer and inner tasks from the Task<Task<TResult>>. With that in place, we can successfully write the desired query with two from clauses.<\/p>\n

<\/font><\/font><\/p>\n

I’ve omitted some details from these implementations, but you get the basic jist.  <\/span>The LinqToTasks.cs file in <\/font>ParallelExtensionsExtras<\/font><\/a> provides a set of more complete implementations, covering Select, SelectMany, Where, Join, GroupJoin, GroupBy, OrderBy, and more.  <\/span>How useful this LINQ implementation is in practice is arguable, but at the very least it provides for an interesting thought exercise as well as a set of examples for doing some complicated asynchronous logic with ContinueWith.<\/p>\n

<\/font><\/font><\/p>\n

Enjoy!<\/p>\n

<\/font><\/font><\/p><\/p>\n","protected":false},"excerpt":{"rendered":"

(The full set of ParallelExtensionsExtras Tour posts is available here.)  The .NET Framework developer center provides a concise description of Language Integrated Query (LINQ): LINQ is a set of extensions to the .NET Framework that encompass language-integrated query, set, and transform operations. It extends C# and Visual Basic with native language syntax for queries and provides […]<\/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":[7907,7911,7924,7912],"class_list":["post-55933","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-pfxteam","tag-net-4","tag-code-samples","tag-parallelextensionsextras","tag-task-parallel-library"],"acf":[],"blog_post_summary":"

(The full set of ParallelExtensionsExtras Tour posts is available here.)  The .NET Framework developer center provides a concise description of Language Integrated Query (LINQ): LINQ is a set of extensions to the .NET Framework that encompass language-integrated query, set, and transform operations. It extends C# and Visual Basic with native language syntax for queries and provides […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts\/55933","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=55933"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts\/55933\/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=55933"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/categories?post=55933"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/tags?post=55933"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}