The operating system will not change the affinity masks, ever. These exist so that you can explicitly tell the OS (which is now free to ignore this anyways) which processors to use. The only place where this would happen without your knowledge would be if a library set this, or if the user, as an administrator, overrides the affinity masks via the task manager or a similar tool (neither of which is likely). Personally, I think this is overkill unless you are explicitly messing with the affinity masks (which I don’t recommend doing…)

This will be the same as Environment.ProcessorCount, provided you didn’t explicitly change your processor affinity masks for your application. That being said, in general, I usually recommend leaving processor affinity alone, especially on modern operating systems (Vista & esp. W7).

The Windows process scheduler does a very good job of handling this…

While Environment.ProcessorCount does a good job at giving you the # of processors in the system, it will *not* give you the number of processors allocated to your process (which may change while the process is running!). I use this little chunk of code to give me the true number of cores my process can use:

//
// Copyright (c) 2008 All Rights Reserved
//
// Jesse C. Slicer
// jslicer@spamcop.net
// 2008-08-05
// Part of the Aesop.Diagnostics.dll assembly.

namespace Aesop.Diagnostics
{
#region Using Directives

// System namespaces
using System;
using System.Diagnostics;

#endregion

#region Class Definition : ProcessInfo

///
/// Privides a single property which gets the number of processor threads
/// available to the currently executing process.
///
internal static class ProcessInfo
{
#region Internal Static Properties

///
/// Gets the number of processors.
///
/// The number of processors.
internal static uint NumberOfProcessorThreads
{
get
{
using (Process currentProcess = Process.GetCurrentProcess())
{
uint result;

if (currentProcess == null)
{
result = (uint)Environment.ProcessorCount;
}
else
{
const uint BitsPerByte = 8;
uint loop = BitsPerByte * sizeof(uint);
uint processAffinityMask =
(uint)currentProcess.ProcessorAffinity;

result = 0;
while (loop != 0)
{
–loop;
result += processAffinityMask & 1;
processAffinityMask >>= 1;
}
}

return (result == 0) ? 1 : result;
}
}
}

#endregion
}

#endregion
}

Thanks for the reply, but I can not open the link in my country. Would you please copy the text, and send it to my mail box?

Here’s an article describing one approach. Using SelectedItems is tricky, though.

http://bit.ly/alNF72

-Reed

This post was mentioned on Twitter by Caspar_Kleijne: From Windows Forms to WPF with MVVM http://reedcopsey.com/talks/from-windows-forms-to-wpf-with-mvvm/ #wpf #csharp…

This post was mentioned on Twitter by Caspar_Kleijne: Implementing Parallel Patterns in .NET http://reedcopsey.com/talks/implementing-parallel-patterns-in-net/ #csharp #Parallel…

Happy to hear this is now documented! Thanks for the update.

-Reed

Thanks for the article!
And just FYI, the documentation for this feature became available with the last documentation update for VS 2010 RC.
http://msdn.microsoft.com/en-us/library/system.dynamic.expandoobject(VS.100).aspx

I should have written “to host the aggregation delegate *and maintain a per-thread accumulator variable*, which would be significantly more cumbersome.”