Microsoft Developer & Platform Evangelism, in collaboration with the Microsoft Parallel Computing Platform product team, is hosting a developer lab at the Platform Adoption Center on April 12-15, 2010.  This event is for Microsoft Partners and Customers seeking to incorporate either .NET Framework 4 or Visual C++ 2010 parallelism features into their new or existing applications, and to gain expertise with new Visual Studio 2010 tools including the Parallel Stacks and Parallel Tasks debugger tool windows, and the Concurrency Visualizer in the profiler.

Opportunities for attendees include:

• Gain expert design assistance with your Parallel Computing Platform based solution.
  
• Develop a solution prototype in collaboration with Microsoft Software Engineers.
  
• Attend topical presentations and “chalk-talk” sessions.
  
• Your team will be assigned private, secure offices for confidential collaboration activities.

The event has limited capacity, thus enrollment is based on an application process.   Please download and complete the application form then return it to the event management team per instructions included within the form.  Applications will be evaluated based upon the technical solution scenario along with indicated project readiness timelines.  Microsoft event management team members may contact you directly for additional clarification and discussion of your project scenario during the nomination process.

.NET 2.0 introduced Generics to allow enhanced code reusability and type safety.  Since then, generic collections (IEnumerable<T>, List<T>, Dictionary<T>, etc.) have become standard and are recommended over their non-generic counterparts (IEnumerable, ArrayList, HashTable, etc.).  As a result, Parallel.ForEach only supports generic collections, so code like the following will fail to compile.

IEnumerable nonGenericCollection = …;

Parallel.ForEach(nonGenericCollection, currentElement =>

{

});

This issue applies to all non-generic collections (pretty much anything that was added before .NET 2.0), but here are some usual suspects that we’ve seen folks run into: XmlNodeList, DataRowCollection, DataTableCollection.  The error message is typically something like the following:

·         “The type arguments for method ‘System.Threading.Tasks.Parallel.ForEach<TSource>) cannot be inferred from the usage. Try specifying the type arguments explicitly.”

·         “The best overloaded method match for ‘System.Threading.Tasks.Parallel.ForEach<object>(System.Collections.Generic.IEnumerable<object>, System.Action<object>)’ has some invalid arguments.”

Fortunately, the workaround is simple.  Since non-generic collections produce objects (IEnumerator.Current returns Object), it is always possible to produce an IEnumerable<Object> from an IEnumerable.  For example:

static IEnumerable<object> Cast(IEnumerable source)

{

    foreach (object o in source)

        yield return o;

}

Even more fortunately, LINQ already provides this functionality:

public static IEnumerable<TResult>

    Cast<TResult>(this IEnumerable source);

So we can easily fix the initial example using this Cast extension method.

using System.Linq;

…

Parallel.ForEach(nonGenericCollection.Cast<object>(),

    currentElement =>

{

});

I previously posted in November about a paper I’d written on patterns for parallel programming.  The original paper had over 200 snippets of C# code to demonstrate and exemplify the ideas being discussed.  Due to popular demand (and in honor of the many Visual Basic MVPs on campus this week for the MVP Summit), we’ve now posted another version of the paper that uses Visual Basic instead of C#.  You can download both versions of the paper from http://www.microsoft.com/downloads/details.aspx?FamilyID=86b3d32b-ad26-4bb8-a3ae-c1637026c3ee. Enjoy!  And, as usual, feedback is always welcome and encouraged.

We’re hiring! If you’re reading this post, you most likely have an interest in parallel or distributed computing, writing concurrent software, and the like.  Take that interest a step further, and help us make the manycore era a successful reality by coming to work on the Parallel Computing Platform team at Microsoft.

We currently have several exciting positions available:

• Program Manager
• Software Development Engineer Lead
• Software Development Engineer in Test

If you’re interested in any of these, please submit your resume and apply for the job through the "Apply to Job" button on the relevant page. We look forward to hearing from you!

The new parallelization support in the .NET Framework 4 is implemented purely in libraries and the runtime and does not require special compiler support.  Therefore, it is available to all compliant .NET languages.  This includes all of the managed languages that ship as part of Visual Studio 2010 (Visual C#, Visual Basic, Visual F#, and C++/CLI) as well as other Microsoft-provided languages (e.g. IronPython) and 3^rd-party developed languages.  In fact, our samples available at http://code.msdn.microsoft.com/ParExtSamples include examples in multiple languages.

However, some of the APIs in .NET 4 have been designed with certain language capabilities in mind.  For example, C#, Visual Basic, and F# all support lambda expressions and closures, which enable easily defining the bodies for Tasks and parallel loops.  Query comprehensions in C# and Visual Basic, and sequences in F#, can help to write cleaner, more elegant PLINQ queries.  F#’s support for asynchronous workflows and its provision of immutability of data by default are geared towards making it easier to write highly concurrent applications.

In summary, you can introduce parallelism in your application using any .NET language.  Which one is best still depends on your scenario.