Following Marek's announcement about Mono's compiler getting full C# 3.0 support and his proof-of-concept which is none other than Luke Hoban LINQ-ified Ray tracer, I'm happy to say that by using Mono's PLINQ and with as little modifications as this:

--- linq-sequential.cs	2008-07-25 11:38:53.000000000 +0200
+++ plinq-parallel.cs	2008-07-25 11:39:04.000000000 +0200
@@ -1,9 +1,9 @@
-internal void RenderSequential(Scene scene)
+internal void RenderParallel(Scene scene)
 {
     int[] rgb = new int[screenWidth * screenHeight];

     var pixelsQuery =
-        from y in Enumerable.Range(0, screenHeight)
+        from y in ParallelEnumerable.Range(0, screenHeight)
         let recenterY = -(y - (screenHeight / 2.0)) / (2.0 * screenHeight)
         select from x in Enumerable.Range(0, screenWidth)
                let recenterX = (x - (screenWidth / 2.0)) / (2.0 * screenWidth)
@@ -65,14 +65,14 @@
                select new { X = x, Y = y, Color = traceRay(new TraceRayArgs(ray, scene, 0)) };

     int rowsProcessed = 0;
-    foreach (var row in pixelsQuery)
+    pixelsQuery.ForAll(row =>
     {
         foreach (var pixel in row)
         {
             rgb[pixel.X + (pixel.Y * screenWidth)] = pixel.Color.ToInt32();
         }
-        rowsProcessed++;
-        if (rowsProcessed % rowsPerUpdate == 0 ||
-            rowsProcessed >= screenHeight) updateImageHandler(rgb);
-    }
+        int processed = Interlocked.Increment(ref rowsProcessed);
+        if (processed % rowsPerUpdate == 0 ||
+            processed >= screenHeight) updateImageHandler(rgb);
+    });
 }

... the code runs approximately 1,5x faster on my dual-core computer. Actually it's rather good although there is still room for improvement (OrderBy fallbacks to the traditional LINQ operator for instance). The Ray tracer here is particularly well suited to parallelization because calling MoveNext() involves a good deal of computation with no-constant time as it depends on how much reflection there is, that's why the processing feels slower on the bottom of the picture.

Following are two screencasts of both sequential and parallel version of the Ray Tracer found in Microsoft ParallelFx CTP samples :

Actually colors are much more good-looking than this, but since GIF format supports 256 colors at most the output is a little fuzzy.

Now off to some multi-threading debug.