Speed and Performance of LINQ

I was wondering today if anyone had produced any benchmarks on the speed and performance of LINQ, so I had a look around and found that LINQ 2 SQL is 4 times faster than the Entity Framework.  Why is this?  It is due the the fact that the Entity Framework is a more generic solution, where as LINQ to SQL can be more fine tuned to the underlying database structure.

Here are a few links I found that might explain things in more details

ADO.NET Entity Framework Performance Comparison

How Slow is ‘Slow’?

Tools for Linq to SQL and ADO.NET Entity Framework

I have found LINQ to SQL and the Entity Framework has a few missing features, one of these is the ability to update the designer diagrams, and this is where Huagati DBML come to play.

Huagati DBML/EDMX Tools is an add-in for Visual Studio that adds functionality to the Linq2SQL/DBML diagram designer in Visual Studio 2008, and to the ADO.NET Entity Framework designer in Visual Studio 2008 SP1.



In object-oriented programming, mock objectsare simulated objects that mimic the behavior of real objects in controlled ways. A computer programmer typically creates a mock object to test the behavior of some other object, in much the same way that a car designer uses a crash test dummy to simulate the dynamic behavior of a human in vehicle impacts.

It is possible to perform integration testing on the Membership Provider, take a look at this blog entry to find out more Integration testing the MembershipProvider

Within the Project we are using Rhino MocksOren Eini is doing a great job with this framework, and I think it’s the only one that seems to be keeping up with the latest features in .NET, other than TypeMock. Plus, it’s totally free to use. It’s also the only one other than TypeMock which does not require you to input strings for method names you’d like to mock, which is cool. It’s compelling to use it but the project is currently maintained by just one person. If Oren decides to drop it, or for any reason stop working on it, the book might turn out outdated quite quickly. Plus, it’s not very widely used, though it seems to be gaining in popularity.


Introduction to Mocking with Rhino Mocks


Code Samples


RPS – Calculation Model

Calculation Model

There are a number of calculations and data transformations that need to take place in order to produce the correct Leakage Calculation.

In order to complete the Leakage Calculation as fast as possible we are going to separate the calculations and data transformations in to different processes and control these processes using a Windows Service.

In order for a Windows Service to handle separate processes we will be using the Multi Threading abilities of the .NET Framework.

[edit]Windows Service Installation

To install a Windows Service, you could create an installation program that encapsulates the executable for deployment, which I find time consuming and inefficient when testing an application. Or, you could install the service though the InstallUtil.exe process that comes with the .NET Framework.

I created a simple batch file, install.bat, to simplify installation (and therefore testing) of the service. The batch script is shown below; uninstallation is as simple as creating another batch file, uninstall.bat, with exactly the same script, only substituting the /i (for install) with /u (for uninstall).

[edit]WCF (Windows Communication Foundation


We needed to be able to communicate with the Window Service running on the server, from anywhere on the network and the Internet if needed. So the best possible solution was to use [Microsofts WCF], as it is very flexible and configurable.

[edit]Service Contract

We need to implement a service contract, this provides an interface that we can use to be able to communication with the service.


Provides a method to invoke a command to the service, mainly used for testing and debugging


Get a list of Calculation that are available to be processed


Start all the calculations


Start a single calculation process by its name


Stop all calculations and abort their threads


Stop all calculations and abort their threads


Return if any calculations are still running


Display the activity of all the processes that have ever happened since the service started

This returns back a String Array, and in each string a comma delimited structure.

Name, Id, Date/Time, Status


Returns the activity for a given Id

This returns back a String Array, and in each string a comma delimited structure.

Name, Id, Date/Time, Status


Clears all the Activity information

[edit]Multi Threading


Before we start the thread we need to ensure that when the Windows Service is closed, that all the threads are stopped. To do this you must set the thread to a background process withIsBackground

When a thread terminates because of its parent process, it stops dead, and no finally blocks are executed.

The same situation arises when a user terminates an unresponsive application via the Windows Task Manager, or a process is killed programmatically via Process.Kill.

Therefore Restarting the Windows Service will cause the threads to stop in their tracks, which is perhaps what you are after if you restart or stop a service.


Abort will work on a thread in almost any state – running, blocked, suspended, or stopped. However if a suspended thread is aborted, a ThreadStateException is thrown – this time on the calling thread – and the abortion doesn’t kick off until the thread is subsequently resumed.



The application configuration file can be configured to handle the different calculations, we are using the standard .NET configuration settings, using a Section Group, within the Config Sections tag, of WaterNet, and implementing the leakage section handler, as seen below:

To configure the separate calculations you add each calculation in to the leakage tag, as seen below:

Here is a list of possible configuration options available for the calculation plugins


The name of the Calculation Required


The assembly name to be used, comprising of the method and the Assembly name, both including the full namespace. Required


sets the maximum number of threads available for this process to run at any one time default = 1


Indicating whether or not a thread is a background thread. default = True


Indicating the scheduling priority of a thread.

default = Normal

A thread can be assigned any one of the following priority values:









Continuous Integration

Task today is to decide and implement an Continuous Integration build process, I will be looking at two options CruseControl and Team City.  The are a lot more but for the purpose of the current .NET environment these are the two I’ll be looking at.

When working in a team, the developer needs to know that any changes he makes and stores in to your repository will work for others.  When the developer submits code to the repository they must first update their code to reflect the changes in the repository since they took their copy. The more changes there are to the repository, the more work the developer must do before submitting their own changes.

Eventually, the repository may become so different from the developer’s baseline that they enter what is sometimes called, “integration hell,” where the time it takes to integrate is greater than the time it took to make their original changes. In a worse case scenario, the changes the developer is making may have to be discarded and the work redone.

Continuous Integration is the practice of integrating early and often, so as to avoid the pitfalls of “integration hell”. The ultimate goal is to reduce timely rework and thus reduce cost and time. When done well, continuous integration has been shown to achieve these goals.

After speaking and Googling for each of the products, I quickly came to the  conclusion that although a number of clients I have work with before have been using CruseControl I have found it quite hard to setup and the configuration of XML configuration files can be a bit of a nightmare, and as such we just need a tool to work and not have to maintain.  So for the rest of this article I will be focusing on Team City by JetBrains.

I will be using version 4.5.1. TeamCity-4.5.1.exe (231 mb)

What I like about this product is the licensing, currently the Professional version is free for up to 20 users and 20 build configurations, and when the project get larger you purchase an enterprise license, currently £1,560, ideal way of working and getting you to use the produce.

It’s worth watching this short introduction video from Dime Cast, to find out how easy it is to create and use Team City.

The Server automates the integration process by monitoring the team’s source control repository directly. Every time a developer commits a new set of modifications, the server will automatically launch an integration build to validate the changes. When the build is complete, the server notifies the developer whether the changes that they committed integrated successfully or not.

Effectively, integration becomes as easy as checking in code. Using an automated integration server not only makes integration easy, it also guarantees that an integration build will happen. There is no danger of developers forgetting to validate their changes after checking in.

The Team City offers several key features:

• Integration with a variety of Source Control systems

• Integration with other external tools, such as NAnt and Visual Studio

• Can build multiple projects on one server

• Remote management and reporting

So down to the installation, once downloaded (231mb file), I installed using all the default settings and it worked, very easy to setup.

Next was to setup a project, again quite easy, I was attaching to a Visual SourceSafe (VSS) solution, I ran in to my first issue as I was getting directory authentication failed.  This was because the running “TeamCity Web Server” was using my System login and it did not have permissions to the network drive for the VSS.  A quick change to the TeamCity Build Server service login and it all worked.

I ran the build on a simple project and it worked without a hitch.

Next was to install the System Tray Notifier, quite simple, going to the “My Settings & Tools” tab brings a list of download, after a simple download and run, then pointing the HTTP location of the Team City installation, it worked.

What can I say it’s all just too easy to setup.

Pre-tested Commit

One issue I had, but not with Team City, is that if you are using MS Test, the built in Visual Studio 2008 testing tool, then you will need to run MS Test.  But to run MS Test it is tightly coupled with Visual Studio.  Which means to run MS test you’ll need to install a version of Visual Studio on your Continous Intergration machine.  Therefore it might be worth using NUnit for testing.

One very nice feature of Team City is the ability to perform a Pre-tested Commit, this is possible when you install the Visual Studio Addin

An approach which prevents committing defective code into a build, so the entire team’s process is not affected.

Submitted code changes first go through testing. If it passes all of the tests, TeamCity can automatically submit the changes to version control. From there, it will automatically be integrated into the next build. If any test fails, the code is not committed, and the submitting developer is notified.

The TeamCity plugins for IntelliJ IDEA, Microsoft Visual Studio 2005/2008 and Eclipse extend the respective IDE with the remote run and pre-tested commit features. Developers test their changes by performing a Remote Run. A pre-tested commit is enabled when commit changes if successful option is selected. 




Beyond Continuous Integration: Continuous Monitoring with Owen Rogers

Setting up CruiseControl.NET to be a Continuous Monitoring Server