Igor Ostrovsky is one of the minds behind the parallel programming support in the .NET Framework. Igor’s recently written a great set of articles for MSDN Magazine to cover “The C# Memory Model in Theory and Practice“.
In both .NET 4 and .NET 4.5, PLINQ supports enumerables with up to Int32.MaxValue elements. Beyond that limit, PLINQ will throw an overflow exception. LINQ to Objects itself has this limitation with certain query operators (such as the indexed Select operator which counts the elements processed),
Astute users of the Task Parallel Library might have noticed three new options available across TaskCreationOptions and TaskContinuationOptions in .NET 4.5: DenyChildAttach, HideScheduler, and (on TaskContinuationOptions) LazyCancellation. I wanted to take a few minutes to share more about what these are and why we added them.
I’ve been asked a few times recently various questions about ExecutionContext and SynchronizationContext, for example what the differences are between them, what it means to “flow” them, and how they relate to the new async/await keywords in C# and Visual Basic.
Since .NET 4’s release, I’ve received several questions about a peculiar behavior of ConcurrentQueue<T> having to do with memory management.
With Queue<T>, List<T>, and other such data structures in the .NET Framework, when you remove an element from the collection,
We’re happy to announce that you can now download an Async Targeting Pack for Visual Studio 11 that lets you target .NET 4 and Silverlight 5. The included DLLs address the previously discussed issue of the Visual Studio 11 Beta compilers being incompatible with the AsyncCtpLibrary* DLLs from the Async CTP;
In a previous post Should I expose asynchronous wrappers for synchronous methods?, I discussed “async over sync,” the notion of using synchronous functionality asynchronously and the benefits that doing so may or may not yield. The other direction of “sync over async”
I get this question a lot:
“Task implements IDisposable and exposes a Dispose method. Does that mean I should dispose of all of my tasks?”
Here’s my short answer to this question:
Lately I’ve received several questions along the lines of the following, which I typically summarize as “async over sync”:
In my library, I have a method “public T Foo();”. I’m considering exposing an asynchronous method that would simply wrap the synchronous one,
Every now and then, I get this question: “is it ok to use nested Parallel.For loops?” The short answer is “yes.” As is often the case, the longer answer is, well, longer.
Typically when folks ask this question,