From the client perspective, the administration of the rules would look something like the following:

Simple enough concept.  Historically, given such a requirement, you'd likely end up with some fudged SQL string (if querying a database), and/or a whole lot of conditional logic.  The application already uses Linq2SQL, so I didn't want to go backwards by introducing some extensive SQL string generation.

The first Linq based option I came across was the Dynamic Linq Query Library, which essentially enables you to use SQL-like strings as expressions in your conditional clauses.  Nice, but it still smelled a bit like the SQL string concatenation of old.

The second option I looked at was PredicateBuilder.  It's a neat solution for the right problem, but it assumes that you know the properties/columns you're querying against at compile time.

So, I decided to have a play around with Expression Trees, in an effort to dynamically generate my conditional expressions at runtime.  I hadn't really delved much into this area before, so I figured it'd be a good learning experience, even if it didn't end up working out.  To cut to the chase, the method I ended up with for parsing my rules into Lambda Expressions looks like the following:

public static Expression<Func<T, bool>> GetExpression<T>(
	string propertyName, string operatorType, string propertyValue)
{
	var isNegated = operatorType.StartsWith("!");
	if (isNegated)
		operatorType = operatorType.Substring(1);

	var parameter = Expression.Parameter(typeof (T), "type");
	var property = Expression.Property(parameter, propertyName);

	// Cast propertyValue to correct property type
	var td = TypeDescriptor.GetConverter(property.Type);
	var constantValue = Expression.Constant(td.ConvertFromString(propertyValue), property.Type);

	// Check if specified method is an Expression member
	var operatorMethod = typeof(Expression).GetMethod(operatorType, new[] { typeof(MemberExpression), typeof(ConstantExpression) });

	Expression expression;

	if (operatorMethod == null)
	{
		// Execute against type members
		var method = property.Type.GetMethod(operatorType, new[] {property.Type});
		expression = Expression.Call(property, method, constantValue);
	}
	else
	{
		// Execute the passed operator method (e.g. Expression.GreaterThan)
		expression = (Expression) operatorMethod.Invoke(null, new object[] {property, constantValue});
	}

	if (isNegated)
		expression = Expression.Not(expression);

	return Expression.Lambda<Func<T, bool>>(expression, parameter);
}

Which can be executed with a call like the following:

foreach (var rule in rules)
{
	applicants = applicants.Where(
		GetExpression<Applicant>(
			rule.MemberName, // The Applicant property
			rule.Operator, // Equals, Contains, GreaterThan, etc
			rule.Value)
		);
}

The rules are looped over, and Linq does its magic by combining all the separate rules with AND statements in the resulting query.

A few things to note:

• Operators are just the method names to be called, against the Expression type, or any other CLR or custom type.  If you put a ! in front of the operator, it negates the method result (!Contains would read 'Does Not Contain').
• Reflection isn't necessary for building an expression, I just use it here to enable runtime operator implementation, against both the Expression class and potentially any other class.
• If you wanted to combine your rules with OR statements, it could be done easily enough with logic similar to what PredicateBuilder uses.
• There is possibly/probably better ways to do this - if you know one, speak up!

Is this necessarily any better than using the Dynamic Linq library?  A bit - it doesn't really give me any compile-time type safety benefits, but I could potentially handle certain exceptions that I perhaps wouldn't be able to detect using Dynamic Linq, such as casting the value to the correct type.  On top of that, I like it more, it feels more robust, and doesn't require external libraries to work.  If nothing else, it gave me an excuse to get my head around some lower-level Expression Tree stuff :)

Silverlight 4 not only brings in all these features, but also a pile of others.  Interestingly, they seem to be making a direct pitch against Adobe AIR with many of the features.  The new Elevated Trust Applications feature (for out-of-browser apps), enables a host of features typically reserved for desktop applications: Local file access; Notifications API; Full-screen full-keyboard access; Cross-domain policy-free networking; and Drop targets.  Of course, features aside, the huge advantage of the Silverlight desktop approach over AIR is that there is only one runtime plugin required.

At the speed Microsoft is moving forward with Silverlight, Adobe is going to have to start seriously upping their commitment to the Flash platform if they want to stay at the top of the game.  Up to now, they could always give the argument of Flex being more feature-rich, and the ease of adaptation to the desktop with AIR - with both of these arguments now void, and Microsoft firmly remaining miles ahead in the developer tooling scene, Adobe's work is cut out.  They still have greater marketplace penetration with Flash player, but that lead is only going to narrow also.

You've got to love competition!

I have to think though, perhaps the effort would have been better spent creating a port of Blend for the Mac... it seems to me that only a tiny minority of developers would opt for Eclipse over Visual Studio; whereas I'd guess nearly all designers would prefer to work natively within MacOS.

I can kind of understand why they've done it, but I can only hope there's another project underway with that Blend port...

Having used the refactoring-and-[insert feature here]-anaemic Flex Builder 3 at length on a few recent projects, life just seems to get better and better in Visual Studio land.

Documentation for coding a Silverlight 3 player against IIS Smooth Streaming is a little sparse.  IIS.net has several articles on the server setup, but I couldn't find anywhere obvious regarding the client connection.

Unlike progressive video playback, you can't just point the MediaElement.source at the video path then call play().  After a bit of searching, most people were talking about some AdaptiveStreamingSource class, which isn't available in the base SL toolkit, but rather only found in SmoothStreaming.dll within the template players generated from Expression Encoder!

Per some handy forum posts, the steps required are:

1. With Expression Encoder installed, go to C:\Program Files\Microsoft Expression\Encoder 3\Templates\en, select any template, and copy the SmoothStreaming.xap file.
2. Rename your copied .xap file to .zip, unzip, and take out the SmoothStreaming.dll and PlugInMssCtrl.dll files.
3. Reference these assemblies in your project, and you can then start using AdaptiveStreamingSource.

So, once you can finally access the required assemblies, you can then invoke your IIS Smooth Streaming service with something along the lines of the following:

var mediaPath = "testClip_h1080p.ism/manifest";
var source = new AdaptiveStreamingSource
{
   ManifestUrl = new Uri(mediaPath, UriKind.RelativeOrAbsolute),
   MediaElement = streamElement // the xaml MediaElement
};
source.StartPlayback();

Make sure you put the trailing '/manifest' after your stream path.

Simple enough, once you've figured out the basics! Not exactly sure what MS were thinking by not including the SmoothStreaming assemblies in the SL3 toolkit? Surely they realise not everyone wants to use a templated player. Or have I missed something here?

The solution was simple enough - run the VS Command Prompt, and enter:

devenv /resetskippkgs

Problem solved.  Apparently a good one to try whenever you lose formatting or Intellisense features.

Among other apps, I need to run Visual Studio 2008 and SQL Server 2008.  Using Bootcamp crossed my mind, but I didn't like the the idea of rebooting into Windows every time I wanted to look at something dev-related.

So, I downloaded the trial of VMWare Fusion 2.05, installed a shiny new copy of Windows 7 Pro, installed VS2008 Pro, SQL2008, ReSharper, etc, and prepared to be amazed by my new efficient setup.

In short, it was pretty painful - everything just seemed to lag.  I was expecting it to be a bit slower than running natively, but after 20 minutes I realised it just wasn't going to work.  I googled to see if this was a common experience, and came across this fairly comprehensive comparison between Fusion and Parallels which concludes "Parallels Desktop is the clear winner running 14-20% faster than VMware Fusion".  That's an impressive difference on any benchmark!

One very nice feature of both Fusion and Parallels is that you can import the competitor's virtual image into the other.  So after reading this comparison, I figured I had nothing to lose - the next option was to just set up in Bootcamp which still wasn't appealing.  I downloaded and installed Parallels 4, imported my Fusion virtual image, and 20 mins later I booted up the new Parallels image.

This was exactly what I was hoping for - the experience was vastly superior.  No obvious lag when opening/closing programs, responsive, didn't slow down my other Mac programs at all, and just slicker.  Build times of existing VS projects may be a bit slower than running natively (understandable given only one cpu core is allocated to the virtual OS - I think), but overall it feels pretty snappy, and definitely not slow to the point I'd bother rebooting into Bootcamp.  It's worth pointing out that I allocated 2gb memory (of 4gb total) to running each Fusion and Parallels - so they were on a fairly level playing field.

Parallels: 1 - Fusion: 0

I recently helped a colleague out with an article on Flex vs. Silverlight in the Enterprise.  Both of us have a strong .NET background, and have more recently been heavily involved on a massive enterprise-scale Flex application.  Although I still stand by the original article, I realise it's impossible to accurately and fairly detail each platforms' strengths and weaknesses in one post.

So, I plan to start a bit of a series - comparing different user experiences as created with Silverlight and Flex, and hopefully reaching a conclusion on the benefits of each platform, based upon developer experience/efficiency, and of course how the end result meets the original client requirements.

Each post will focus on a technical area that you may find within any enterprise RIA.  Example areas could be video streaming, datagrid customisation, push messaging, theming/skinning, just to name a few.

It's as much for my own benefit as anyone else's - in order to deliver the best client experience, you HAVE to know what the best tools or platform are for any given situation!