This site uses cookies for analytics, personalized content. By continuing to browse this site, you agree to this use. Learn More
All about Async/Await, System.Threading.Tasks, System.Collections.Concurrent, System.Linq, and more…
June 30, 2009Jun 30, 200906/30/09More and more, developers are realizing the significant scalability advantages that asynchronous programming can provide, especially as it relates to I/O.
Consider an application that needs to copy data from one stream to another stream, such as is being done in the following synchronous implementation:
static void CopyStreamToStream(Stream input,
June 24, 2009Jun 24, 200906/24/09In concurrent programs, race conditions are a fact of life but they aren’t all bad. Sometimes, race conditions are benign, as is often the case with lazy initialization.
The problem with racing to set a value, however, is that it can result in multiple objects being instantiated when only one is needed.
June 24, 2009Jun 24, 200906/24/09In a previous post, it was demonstrated how for loops with very small loop bodies could be parallelized by creating an iterator over ranges, and then using Parallel.ForEach over those ranges. A similar technique can be used to write parallel loops over iteration spaces of non-integers.
June 22, 2009Jun 22, 200906/22/09One of the great features that crosses all of Parallel Extensions types is a consistent approach to cancellation (see https://blogs.msdn.com/pfxteam/archive/2009/05/22/9635790.aspx). In this post we explore some of the ways cancellation is used in Parallel Extensions and explain the guidance we developed.
June 19, 2009Jun 19, 200906/19/09As has been discussed previously, one of the new features in the Task Parallel Library is TaskCompletionSource<TResult>, which enables the creation of a Task<TResult> that represents any other asynchronous operation.
There are a wide variety of sources in the .NET Framework for asynchronous work.
June 13, 2009Jun 13, 200906/13/09As Ed Essey explained in Partitioning in PLINQ, partitioning is an important step in PLINQ execution. Partitioning splits up a single input sequence into multiple sequences that can be processed in parallel. This post further explains chunk partitioning, the most general partitioning scheme that works on any IEnumerable<T>.
June 9, 2009Jun 9, 200906/9/09The Asynchronous Programming Model (APM) in the .NET Framework has been around since .NET 1.0 and is the most common pattern for asynchrony in the Framework. Even if you’re not familiar with the name, you’re likely familiar with the core of the pattern.
June 6, 2009Jun 6, 200906/6/09The Parallel class represents a significant advancement in parallelizing managed loops. For many common scenarios, it just works, resulting in terrific speedups. However, while ideally Parallel.For could be all things to all people, such things rarely work out, and we’ve had to prioritize certain scenarios over others.
June 3, 2009Jun 3, 200906/3/09The core entity in the Task Parallel Library around which everything else revolves is System.Threading.Tasks.Task. The most common way of creating a Task will be through the StartNew method on the TaskFactory class, a default instance of which is exposed through a static property on Task,
June 2, 2009Jun 2, 200906/2/09The Task Parallel Library is centered around the Task class and its derived Task<TResult>. The main purpose of these types is to represent the execution of an asynchronous workload and to provide an object with a means to operate on that workload,
