The goal is to create a simple Service in Windows 7 (or other similar OS’s) with Visual Studio 2010 that simply starts, sleeps for 15 seconds, then stops.  I realize this is not that useful, but basically, it covers the case of building a service that actually does something and when finished stops.  In my personal case, my thread has a while(true) loop which keeps looking for new work and only completes when certain conditions are met (like a fatal error that is non recoverable).

Microsoft has given us a pretty good set of docs and walk through.  You can find them all here:  http://msdn.microsoft.com/en-us/library/y817hyb6.aspx

The Steps

Create a new Visual Studio Project of type “Windows Service”

Once the project is created, make sure you have the design surface up for Service1 [Design] and right click on it and say “Add Installer”.

Now, you’ll get to “gear” icons that you can set properties for.  They are “serviceProcessInstaller1” and “serviceInstaller1” as follows:

Select “serviceProcessInstaller1” and in it’s properties window change the account to “LocalSystem”.  You should have a screen that looks like the following:

Then, on the other gear “serviceInstaller”, change the nanes as follows.  I’m naming my service “MyDoNothingService”.

Now, rebuild your project and you’ll get an exe file in your /bin/Debug folder.  Open that folder with the Visual Studio Command Prompt (elevated as admin).  To install the service, enter the command:

InstallUtil WindowsServiceCreateSample.exe

You should get some messages that end with “The Commit phase completed successfully”, then “The Transaction install has completed”.

Now, you should see that you have the service in your services panel (you can get there by going to control panel / Administrative / Services or simple run “services” from your start button.

(sorry for the rename here to MyServiceTest, but I got distracted and had to come back and rename the project)

So, now we want to add something to this project.  Let’s just add to the OnStart event of Service1.cs something that starts a thread that sleeps for 15 seconds, then stops the thread.  Very simple code as follows:

  protected override void OnStart(string[] args)
        {
            new Thread(()
                      =>
            {
                Thread.Sleep(15000); // sleep 15 seconds
                this.Stop();
            }).Start();
        }

Now, before we can install the service, we first need to uninstall it.  Very easy, just add a /u to the end of your install command.

InstallUtil WindowsServiceCreateSample.exe /u

You should be greeted with “The uninstall has completed.”.

Now, when you try and reinstall, sadly, you might get this error: “Error 1001. The specified service has been marked for deletion”.  If you do, thanks to a post by Mr. Laxdel, all you have to do is exit your services dialog and restart the service.

Assuming you left the default autoLog set to true as follows:

In your event viewer, you should see you service starting and stopping as follows:

Conclusions

That was pretty straight forward.  Hopefully, you can follow along and generate the same thing yourself.  Here is the source code attached for a visual studio 2010 project if for some reason you have trouble recreating it yourself.  HTH’s!

SV Code Camp is happening next weekend with well over 200 sessions.  The conference is really technology agnostic and try hard to keep it that way, but I am an ASP.NET guy these days so I think it reasonable I take my Code Camp Coordinator hat off for the moment and put on my ASP.NET hat.  As an ASP.NET Microsoft MVP, I feel I’m in a good position to give a tour of some sessions in ASP.NET and throw in my own 2 cents.  Below are a list of these sessions in no particular order.

Demystifying ASP.NET MVC, $(Lino).MVC{getknowledge()}

Sunday, October 9th 9:45AM

MVC (Model View Controller) is one of the hottest patterns around building web sites these days no matter what the technology. When Microsoft first introduced Web programming to Visual Studio, they did it such that almost anyone who had done windows programming (VB or other) could quickly come up to speed and build a web site. Personally, this what sucked me into web programming. Drag a button, drag a textbox, double click on the button and add some code to set the text box and WHAM, you have a web site. Unfortunately, as things get more complicated, this model does not scale so well. ASP.NET’s MVC implementation does scale, it takes a little bit of flipping your mind around if you are Web Forms programmer, but definitely worth learning about and seeing if it’s right for you.

Lino Tadros is one of my favorite presenters and I’m sure will give you a much better understanding of MVC and how it fits into the ASP.NET programming model. I strongly recommend this one. Lino is the CEO for one of the top Application development and training companies in the world that partners with Microsoft, Falafel Software. In other words, GO TO THIS SESSION!

Pragmatic JavaScript, jQuery & Ajax with ASP.NET

Saturday, October 9th 1:45PM

Damian Edwards is a Program Manager on the Microsoft ASP.NET team.  That’s right, he is flying here from Redmond just to present to us.  He’s also an awesome presenter and we are extremely lucky to have him at Code Camp!   Damien will tak about using JQuery while building sites with the Microsoft ASP.NET framework.  Something Damien knows very very well.  For those who don’t know, Damien is also leading the next generation efforts around ASP.NET WebForms which is the technology 90% of who use ASP.NET use (it’s what the silicon valley code camp web site is built with).

DON’T MISS THIS PRESENTATION!

WebMatrix In Depth

Saturday, October 9th  5:00PM

John Sheehan, one of the best guys I know at explaining complex things is presenting this session on WebMatrix.  I’m not sure everyone would agree with me, but for those people that really don’t like the heavy weight feeling of building web applications with Visual Studio, WebMatrix will make you feel right at home. It’s much lighter weight and also gives tons of punch.  Come see John and ask him a million questions!  He loves that.

All the sessions Tagged ASP.NET can be found here:  http://www.siliconvalley-codecamp.com/Sessions.aspx?sortby=title&by=category&tag=3

Say you have an existing Microsoft Windows Forms Application and you want to create a class library for it to reference.  For some reason, I’ve been stuck with this problem for a while now and I accidentally found the “unintuitive” button by accident of how to do this. My expectation was that when I created a new solution in Visual Studio 2010, that it would show 1 project in the solution and then to add more projects, I’d right mouse button on the solution and say “Add New Project”.  Sadly, the solution explorer does not show me my solution, just the one project I have in it, regardless of whether I opened it directly (for which I think it creates it’s own solution) or I opened from my newly minted solution file.

That is, here is what I get when I create an empty solution, then add one project to it (no solution showing!)

So, I just discovered that when you go and “create a new project”, you get a dropdown in the “Solution Name” that says either “Add to Solution” or “Create new solution”.  Cleary, I want the first one.

Now, my solution is back and I can add more projects to it as I would expect.

This is not a big deal, but it did have me confused for a while so I thought I’d blog about it.

HTH’s.

Today, I accidentally figured out a way to stop it.  Simply go to the web project and right mouse button on your project and say “Publish”. You will be immediately presented with an option to stop the deployment!

That’s it.  Simple, but pretty undiscoverable IMHO.

This post shows a very simple technique for processing a gzip compression on a background thread using c# with Visual Studio 2010.  What is unique here is we are using no statics to do it.  I’m not totally against using statics, but in general, it is best to avoid them.  I’ve heard the notorious Ward Bell say statics are evil and have had many cases where they have bitten me.  Since I heard Ward say this, I’ve been trying to avoid them where I can.

The Simple Problem

The problem is to simply compress a file to bytes and return to us the compressed, uncompressed and byte array of the result.  We can pass parameters into a thread, however we can not return them (when I say thread, I mean the anonymous method that processes our data).

Some Code

So, to that end, Let’s create a main method as below.  Notice that it creates a very simple anonymous method which executes the code cryptoCopress.CompressFile(…), then simply starts that thread.  Once the thread starts, it simply waits for the thread to end by looping every 50 milliseconds on the thread.IsAlive method.  Finally, when it returns, it simply looks at the cryptCompress object for the results.  No Statics!

private static void Main(string[] args){    var cryptCompress =        new CryptCompress();    var thread =        new Thread(            () =>            cryptCompress.CompressFile                (@"G:\NoBackup\ext-3.2.1\ext-all-debug-w-comments.js"));    thread.Start();

    int cnt = 0;    while (thread.IsAlive)    {        cnt++;        Console.WriteLine("Waiting... " + cnt);        Thread.Sleep(50);    }    Console.WriteLine("Before Compression KBytes: {0}",                        cryptCompress.BeforeCompressionBytes/1000);    Console.WriteLine("After Compression KBytes: {0}",                        cryptCompress.AfterCompressionBytes/1000);}

Now, Lets look at the CryptCompress class.  Notice that it’s basically got one public method (CompressFile) and 3 public properties that will be used to hold the return values.  This way, the main method that started the thread can get the results.  Again, notice that there is no word static any place in this project.

public class CryptCompress{public byte[] CompressedBytes { get; set; }public long BeforeCompressionBytes { get; set; }public long AfterCompressionBytes { get; set; }

public void CompressFile(string fileName){    using (var fileStream =         new FileStream(fileName, FileMode.Open, FileAccess.Read))    {        var uncompressedBytes = new byte[fileStream.Length];        fileStream.Read(uncompressedBytes, 0,             (int) fileStream.Length);        CompressedBytes = CompressGzip(uncompressedBytes);        BeforeCompressionBytes = fileStream.Length;        AfterCompressionBytes = CompressedBytes.Length;        fileStream.Close();    }}

/// <summary>/// Take a simple stream of uncompressed bytes and compress them/// </summary>/// <param name="uncompressedBytes"></param>/// <returns></returns>public byte[] CompressGzip(byte[] uncompressedBytes){    using (var memory = new MemoryStream())    {        using             (var gZipStream =                 new GZipStream(memory, CompressionMode.Compress, true))        {            gZipStream.Write                (uncompressedBytes, 0, uncompressedBytes.Length);        }        return memory.ToArray();    }}}

The Results

When we run this, notice that it takes 3 iterations (or 150 milliseconds) to complete. I’m only compressing a small file so no surprise.  The file is actually 2.7 Megabytes and compress to .7 Megabytes.

That’s it for now! Hope this helps.

To save anyone some time who wants to do the same thing, I’ve created a VS2010 project from the example, added a very simple Windows C# console application that consumes the service, as well as made some small changes in a very nice Windows Presentation Foundation (WPF) calculator project so that the calculator does it operations inside the windows service rather than in the calculator itself.

In this article, I’ve attached the source code (with my small changes and additions) for you to work with and change as you like.

First, here is the project:

Now, let’s talk about the details

The Visual Studio 2010 Solution Itself

There are three projects in this solution.  The service itself which is called WCFServiceInmanagedWindowsService, Console Application and Calculator.

WCFServiceInManagedWindowsService Project

This project is really what is taken from the MSDN article. It’s got almost no change and is primarily created by following the directions in the article.  There are a couple batch files added for creating and deleting the service itself in the root of that project directory, but that’s about it.  All the code is in a file called service.cs.

To Add the service, go to the “Service Reference”/”Add Service” Dialog and enter the address of the service (you can find it in the app.config file).

http://localhost:8000/ServiceModelSamples/service

Notice that the methods exposed are Add/Divide/Multiple and Subtract.

To start the actual service, after rebuilding the project, execute the bat file InstallService.bat in the root directory.  Make sure you build the release version because this script installs the service from the release directory. Once started, you will see it in the services application as follows:

Then, start the service by running the command: “net start WCFWindowsServiceSample”  If you get the error: “No connection could be made because the target machine actively refused it 127.0.0.1:8000”, this likely means you did not start your service.

The Console Application

The Console application is new and very simple. All you have to do is create a new windows c# console project, use the “Add Service” DialWCFWindowsServiceSampleog and point it at  ( http://localhost:8000/ServiceModelSamples/service ) as follows:

Now, you can simply write a console app with the following code and you will be calling the service correctly.  Here is the code:

class Program    {        static void Main(string[] args)        {            var calculatorClient = new CalculatorClient();

            var answer = calculatorClient.Add(5, 4);            Console.WriteLine("Answer to Adding 5 + 4: {0}", answer);            Console.ReadKey();

        }    }

And, when we run it, now surprise, we get 9!

…

The Calculator Application

Just to show a real life use of the service, I grabbed the codeplex project http://code.google.com/p/wpf-mvvm-calculator/.

Then, modifying a small section of code inside (after adding the service reference of course, just like we did in the above console project, we now have a calculator that adds by calling a service for the answer.  Here is the modified code:

try           {               // Establish the connection to the Service               var calculatorClient = new CalculatorClient();               var firstOperand = Convert.ToDouble(FirstOperand);               var secondOperand = Convert.ToDouble(SecondOperand);

               var stopwatch = new Stopwatch();               stopwatch.Start();

               switch (Operation)               {                   case ("+"):                       result = calculatorClient.Add(firstOperand, secondOperand).ToString();                       break;

                   case ("-"):                       result = calculatorClient.Subtract(firstOperand, secondOperand).ToString();                       break;

                   case ("*"):                       result = calculatorClient.Multiply(firstOperand, secondOperand).ToString();                       break;

                   case ("/"):                       result = calculatorClient.Divide(firstOperand, secondOperand).ToString();                       break;               }

               stopwatch.Stop();

And, when we run the calculator, it looks like this:

Conclusions

In this post, we simply implemented the source as a Visual Studio 2010 project from the MSDN article on how to build a windows service using WCF.  It’s been pointed out that we are better off using named pipes for this kind of application for better performance, but our purpose here was just to elaborate on the existing application.

Hope this helps.

So, let me explain by example. 

At the moment, I’m debugging the Silicon Valley Code Camp web site project and I’m checking a boolean I set called DoValidation.  I’m trying to figure out why it is changing, but first I have to figure out when.  So, I set a break point on the line as shown below:

Now, I hover over the variable I want to pin and press the little pin icon shown here:

I then see the following with my little watch window right in line with my code.

I can even click the little chevron under the pin and add a comment as I show next.

The nice thing is that this stays here just like your break point until you close it.  A very convenient feature.

This article is very short.  In the actual presentation, there was not much time to talk about this so a brief overview was done.  Basically, it’s all standard WCF stuff.  The idea is that the Silverlight Business Template adds logging in and supports Authentication just like an asp.net application does.  It uses the DomainDataSource to do the bridging between the silverlight clientside app, and the web application.  Authorization is built into the login module also so that you can assign attributes to your domainservice classes to restrict access.

That is, if you only want people who are logged in able to access one of your methods, you simply tag it as follows with the [RequiresAuthentication] attribute.

If you only want a certain logged in user role to be able to access a certain method, you tag it as follows

This of course solve the server side only.  On the client side, you need to call methods that are exposed through the domain data.  http://www.silverlightshow.net/items/Silverlight-3-with-Ria-Authentication-service.aspx discusses much of this on the client side.

In this section, we will talk about what happens when the users presses the “Sessions” hyperlink from the speakers page.  If you remember from the last article, we used a special converter on the Speakers.xaml page and bound that to the hyperlink titled sessions as shown below.

When this link is clicked, the navigation created is as follows:

http://localhost:9951/Presentation1TestPage.aspx#/Sessions?SpeakerId=903

// Executes when the user navigates to this page.

protected override void OnNavigatedTo(NavigationEventArgs e)

{

    //Handle SpeakerId

    var qs = NavigationContext.QueryString;

    if (qs.ContainsKey("SpeakerId"))

    {

        this.sessionsOverviewDomainDataSource.FilterDescriptors =

            new FilterDescriptorCollection();

        this.sessionsOverviewDomainDataSource.FilterDescriptors.Add(

              new FilterDescriptor("AttendeeId",

                  FilterOperator.IsEqualTo, qs["SpeakerId"]));

    }

}

This simply adds a filter to the current DomainDataSource that filters the column AttendeeId with the passed in query parameter SpeakerId.

The resulting page looks as follows assuming Peter Kellner’s Session link was clicked.

The video referenced in this article goes into building this page in more details, but fundamentally, the major point is just the query parameter.

In this article, we will use the the Visual Studio 2010 Beta2 Tooling to create a Sessions DataGrid.  We will add a Pager to it as well as a Silverlight busy indicator which will show while the data is loading.  In Article 1, we build a simple DataGrid with code behind, in this article, it will all be declarative in XAML built with the Visual Studio 2010 designer.

First thing we need to do is add a new Silverlight Navigation Page to the Silverlight project (not the web project) in the Views folder.

Then, copy the code from the Home Page to get the top two default sections that appear on every page as follows:

And the actual code:

<StackPanel x:Name="ContentStackPanel"
            Style="{StaticResource ContentStackPanelStyle}">
    <TextBlock x:Name="HeaderText" Style="{StaticResource HeaderTextStyle}"
               Text="{Binding Path=ApplicationStrings.HomePageTitle,
               Source={StaticResource ResourceWrapper}}"/>
    <TextBlock x:Name="ContentText" Style="{StaticResource ContentTextStyle}"
               Text="Home page content"/>
    <Image Height="393" Name="image1" Stretch="Uniform" Width="467"
               Source="/Presentation1;component/Images/IMG_1504.JPG" />
</StackPanel>

Change text to “Speaker page content” and change the resource string to ApplicationString.SpeakerPageTitle and update the ApplicationStrings.resx file as follows:

Then, drag a DataGrid to the Speaker.xaml design surface (after removing the image tag which was the picture on the home page we copied over).

Now, we do what Microsoft calls “Connect the Dots DataBinding”.  That is, we go to the Data Sources Tab

Drag the SpeakersShort2009 box (shown in yellow below) to the DataGrid showing on the design surface.

That automatically creates a bunch of xaml including the RIA Domain DataSource, which includes a reference to the correct query method and the correct Domain Context.  Very nice!

<riaControls:DomainDataSource AutoLoad="True" Height="0"
                                      LoadedData="speakersShort2009DomainDataSource_LoadedData"
                                      Name="speakersShort2009DomainDataSource"
                                      QueryName="GetSpeakersShort2009Query" Width="0">
            <riaControls:DomainDataSource.DomainContext>
                <my:DomainServiceSVCC />
            </riaControls:DomainDataSource.DomainContext>
        </riaControls:DomainDataSource>

Now, we do the same thing with the DataPager (which may have to add to the toolbox with “Choose Items” That gives us some xaml that looks like the following.

<data:DataPager Height="26"
                HorizontalAlignment="Left" Margin="720,325,0,0"
                Name="dataPager1" VerticalAlignment="Top"
                Width="200"
                PageSize="10"/>

Notice that I put PageSize in.  That does not happen by default, and in my presentation, I forgot this and for a while could not figure out why the paging was not working.  Try and not make the same mistake!

Then, drag the same DataSource as we dragged to the DataGrid and drop it on the Paging control as follows:

That automatically binds the DataPager to the same DomainDataSource as the DataGrid’s DomainDataSource.  Here is the XAML created.

 <data:DataPager Height="26" Name="dataPager1" Width="200"
   Source="{Binding ElementName=speakersShort2009DomainDataSource, Path=Data}" />

The next thing is to use the new “Reset-All” for styling.  It’s very simple.  Right click on the design surface and simply click “Layout/Reset” as follows:

Now, when we run this, we get:

Finally, to put a “Busy Indicator” control on the page, we simply drag out the busy Indicator onto the design surface. It likely will not be in your toolbox, so like the DataPager, you will need to add it to the toolbar as follows:

Then, drag it from the toolbox right onto the DataGrid as follows:

Then, once it’s on the DataGrid (and in the XAML), you need to right click on it and change some of it’s properties.

First, set the “IsBusy” property by checking the checkbox, then resize the control itself so it shows the text and is a pleasant size.

The next step is a little more tricky.  You need to find the property in the BusyIndicator called DataContext. Right click on that as follows and press “Apply Data Binding”.

Now, you are setting the Source so first select “ElementName”, then chose speakersShort2009DomainDataSource as follows:

Then, go to the “Path:” and set the property “DomainContext” and the method to “IsLoading” as follows:

What this has done is created a binding expression using a very nice Visual Studio 2010 Tool.  It’s assigned that binding expression to the DataContext of the DomainDataSource.

<riaControls:DomainDataSource AutoLoad="True" Height="0"
         LoadedData="speakersShort2009DomainDataSource_LoadedData_2"
                              Name="speakersShort2009DomainDataSource"
                              QueryName="GetSpeakersShort2009Query" Width="0"
   DataContext="{Binding ElementName=speakersShort2009DomainDataSource, Path=DomainContext.IsLoading}">
    <riaControls:DomainDataSource.DomainContext>
        <my:DomainServiceSVCC />
    </riaControls:DomainDataSource.DomainContext>
</riaControls:DomainDataSource>

Now, when we finally run our program, we first get the busy indicator as the data is being asynchrously loaded which looks like this:

Then, when the data finally loads, looks like the following:

Notice the paging control at the bottom, and notice the BusyIndicator has gone away.

That’s it for this article.  In the next article, we will style this page as well as add Converts to show the Speakers picture and add a hyperlink to the sessions associated with each speaker.

The actual presentation was done at the Microsoft office in San Francisco.

	Title Of Each Article	Video Included With Each Post
Part 1	Introduction To RIA Services In Silverlight (This Article)	7 Minutes
Part 2	Basic RIA Services And DataGrid With  VS 2010 Tooling	14 Minutes
Part 3	Adding A DataGrid With Connect The Dots DataBinding in VS 2010	13 Minutes
Part 4	Adding a Navigation Page to a Silverlight Business Application Template	11 Minutes
Part 5	Adding Speakers Page Template With Converters In Visual Studio 2010 Beta2	11 Minutes
Part 6	Adding A Sessions Page That Includes a Query Parameter In Silverlight VS2010 Beta2	10 Minutes
Part 7	Basic Authentication and Authorization In RIA Services	5 Minutes

I’ve heavily borrowed from Brad Abrams PDC09 presentation here and am very thankful for the help.  I’m personally very excited about the opportunities RIA Services gives us as developers to efficiently build powerful multi tier applications without compromise.

I’d recommend going to Brad Abrams PDC09 presentation mentioned above to get a better understanding of what Microsoft was thinking and its plans for RIA Services. The way I see it is RIA Services is built on the WCF Stack.  It basically is a technology that let’s the developer create both client and server code at the same time.  It essentially removes the middle layer form a development perspective, but keeps it there in a very physical way using all the power of WCF.  For example, you create you logic on the server side and that code automatically gets migrated to the client for simplicity of calling.

For those interested where the motivation came from to to this, it’s an interesting story.  Last week, Mathias Brandewinder, the organizer of our local Bay.Net San Francisco user group emailed and asked if I could fill in last minute for the upcoming (actually today’s) bay.net meeting and, could I talk about RIA Services.  Well, 2 years or so ago, I did a quite extensive Silverlight 1.1 project for Leverage Software using the first beta of the .CLR release of Silverlight (C#).  I have to say, it was an awful experience.  So, now at Silverlight 4.0, RIA Services, I’m back and very excited.

By way of people that have helped me in the last week to get this far, just to name a few:  Bruno Terkaly, offering to do whatever he could and giving me tech tips, Michael Scherotter in “going to town” as he says to make the Speaker’s page look really nice in a live meeting, Victor Gaudioso in taking time on his busy weekend to call me  and offer help, Brad Abrams putting up with my list of naive questions and patiently responding, a slew of ASPInsiders who pointed me at an excellent place to host the videos, and David Kelly for giving me a nicely styled Silverlight player to show the videos on this blog.

I’m sitting in the mall below the Microsoft Office in San Francisco where the presentation will be in about 2 hours.  Hopefully, I’ll finish all seven articles and get them posted to the internet very soon.  I did the videos as just practice for my presentation.  They are not polished or edited.  I’m taking the chance of posting them in the hopes that they help someone struggling with all the new features like I have been during the last week.

Finally, this demo is built on live Silicon Valley Code Camp Data that has been collected over the past 4 years.  I can’t really publish that database along with the completed solution before I clean and randomize the attendee data.  Meanwhile, I will post the project code but it will not work until I’ve had a chance to clean up the database.  My thinking is that it’s all positive and better to release the code now rather than wait until I have the database cleaned up.

Below is what the end result of what we are building will look like (if you make it through all the articles and videos).

Attached here is source that you can build with Visual Studio 2010 Beta 2 and it will work with No Database.  The Domain Class is heavily modified from what is presented, but it will allow you to actually run and play with real data.

You all know that I’ve blogged quite a bit about LINQ2SQL.  That technology has saved me a huge amount of programming effort verses using ado.net directly.  We all know that LINQ2SQL is really just a stepping stone to Entity Framework (EF), though Microsoft doesn’t quite say that.  I’m sure, based on how many people are using LINQ2SQL, it will live on and be supported for quite sometime.  Personally, I’ve been waiting for EF to become more mature and then, I assume I’ll start all my new projects with it (EF) and slowly migrate my old ones from LINQ2SQL to EF.  So, time for me to start taking EF more seriously.  It’s baked into the upcoming .net 4.0 and Visual Studio 2010 beta 2.  It’s obviously not done, but from what I’ve seen, when .net 4.0 releases, EF will be ready for prime time.

Now, for the review:

Julie does a great job of introducing Entity Framework and explaining where it fits in, and why you should consider using it.  I was already sold, but now I understand better why.  She then does an excellent job of going through the basics of EF, telling you how to use it, describing the model and all the details necessary to begin using it.  One of the nice features of this book, is it goes beyond the theoretical, and talks about specific implementations.  That is, WCF, WPF, etc.

We all need to get more comfortable with EF and this book is a great starting place.  Julie Lerman is clearly the person to learn this from.  I strongly recommend it.

Programming Entity Framework

http://microsoftpdc.com/Sessions/FT21

With PLINQ, this can be avoided with clean error free code (as long as my method is thread safe).  Here is some simple code that demonstrates this.

var result =
source.AsParallel().Where
  (x => [some condition]).Select(x => [something]);

My understanding is that this will just do my [something] in parallel using as many threads as can be allocated, and when one finishes, the next will just start.

Very Cool, Very Clean!

Another good article is here:  http://www.danielmoth.com/Blog/2009/01/plinq.html 

uh oh, they are telling me to turn off all electronic devices, time to land.