Rowan Beach Blog

Reactive Extensions for .NET (Rx)

Thu, 12 Apr 2012 21:47:46 GMT

The pace at which Microsoft are releasing new technologies at the moment is little short of astonishing. I had heard about the reactive framework a while ago but I didn't know it had actually shipped in any form yet. I ended up finding a use for this for the first time yesterday on a Silverlight project when I noticed that System.Reactive.dll had been installed as part of the Silverlight toolkit. On this app I'm creating a domain layer that will be shared by the Silverlight application on the client side and an asp.net application on the server side. I'm using a shared code approach for this at least until Silverlight 4 is released (via Visual Studio's 'Add existing item -> Add as link'). I had originally thought this would preclude me from using the reactive extensions in the shared domain model but then I stumbled across this: http://msdn.microsoft.com/en-us/devlabs/ee794896.aspx. Basically Microsoft have already released the Reactive Extensions for 3 platforms - Silverlight, .NET 3.5 sp1 and .NET 4.0. So I was able to download the .NET 3.5 sp1 version and use the Reactive framework in both versions of my domain layer as I wanted to.

For a basic overview of the reactive framework, check out the Microsoft devlabs site (http://msdn.microsoft.com/en-us/devlabs/ee794896.aspx). Here's the most pertinent quote from the front page of the site:

Rx is a superset of the standard LINQ sequence operators that exposes asynchronous and event-based computations as push-based, observable collections via the new .NET 4.0 interfaces IObservable and IObserver. These are the mathematical dual of the familiar IEnumerable and IEnumerator interfaces for pull-based, enumerable collections in the .NET framework.

Here’s a simple example (with most of the non-pertinent code removed from the classes) of how I’m using the IObservableinterface where I would otherwise use a standard CLR event pattern.

public class Plan
{
    private readonly IList _selectedSurveyElements; private readonly Subject _surveyElementAdded; public Plan() { SurveyElementAdded = _surveyElementAdded = new Subject(); _selectedSurveyElements = new List(); _assetPlans = new List(); } public IObservable SurveyElementAdded { get; private set; } public virtual IEnumerable SelectedSurveyElements { get { return _selectedSurveyElements; } } public void AddSurveyElement(SurveyElement surveyElement) { _selectedSurveyElements.Add(surveyElement); _surveyElementAdded.OnNext(surveyElement); } }

public class AssetPlan
{
    private readonly IList _surveyElementPlans; public AssetPlan(Asset asset, Plan plan) { Asset = asset; Plan = plan; _surveyElementPlans = new List(); plan.SurveyElementAdded .StartWith(plan.SelectedSurveyElements.ToArray()) .Subscribe(x => _surveyElementPlans.Add(new SurveyElementPlan(x, plan))); } public Asset Asset { get; private set; } public Plan Plan { get; private set; } public IEnumerable SurveyElementPlans { get { return _surveyElementPlans; } } }

The ‘interesting’ part here, is in the constructor for AssetPlan – the elements currently attached to the plan are converted to an IObservable and then concatenated with any elements that are added to the plan in the future (plan.SurveyElementAdded) and all of them are operated on inside the lambda. This would take more lines of code and be less ‘declarative’ using an event pattern.

Expression Studio

Thu, 12 Apr 2012 21:47:44 GMT

I bought Expression Studio 3 a while back – it’s really not bad at all. Expression design is not up to Adobe Illustrator standards by any means but for my purposes it’s very serviceable. Personally the only feature I really found myself wishing for after using Illustrator is the gradient mesh. Fingers crossed for gradient mesh support in Expression Design version 4…

I designed the new Rowan Beach logo and web site graphics with Expression Design – it only took a few hours to get something looking half decent even though I was pretty new to the software (and some would say challenged from a design perspective) – the software is a lot simpler than Illustrator which makes it faster to pick up and use. Partly that’s because it doesn’t have the same feature set as Illustrator but I think it’s also because it’s new software with the benefit of a clean, fresh UI design.

Expression Blend is great for laying out Silverlight / WPF application screens (I’ve been using it mostly for Silverlight really) although it sometimes does nasty things to the XAML (e.g. it often adds negative margins all over the place when you surround something with a different layout container). If you stay in split view and keep an eye on the XAML that is being churned out it really works quite well. Overall I still tend to do a lot of layout in the visual studio XAML editor though - the better auto-complete support with Resharper is great and being able to hit Ctrl+K, Ctrl+D to quickly reformat the XAML is very handy. I find that I normally swap back and forth between Visual Studio and Expression Blend when doing Silverlight layouts. Blend is pretty much indispensable for doing key-frame animations, especially for parts and states model transitions – those would be much more of a pain to code by hand in the XAML I wonder how things will change when Visual Studio 2010 is released, as that will have GUI designer support for XAML – time will tell. Oh, I should mention, Expression Blend can open Visual Studio .sln files which is really handy – both apps will auto load changes made in the other app too which works well normally, although occasionally I find that I need to restart Blend as it seems to get confused by changes that have occurred in Visual Studio.

As for the other tools in Expression studio, well I’m sure I’ll find a use for them eventually :)

ASP.NET MVC 2 Validation changes

Thu, 12 Apr 2012 21:47:43 GMT

It looks like the ASP.NET MVC team have changed the way model validation will work for the upcoming version 2 of the MVC framework. This was totally in response to user feedback on Twitter and various blog posts, and while it’s a good change in itself, it’s pretty remarkable for a couple of reasons.

1 – It shows Microsoft are really listening to people these days

2 – The change seems to have been implemented in less than a week – even if it’s a fairly simple change, that’s still a pretty good turnaround time for what is a fairly major component of ASP.NET MVC 2.

Here’s Scott Gu’s post http://twitter.com/scottgu/statuses/8097596794

And here’s Ayende’s take on the original issue http://ayende.com/Blog/archive/2010/01/21/when-the-design-violates-the-principle-of-least-surprise-you.aspx which, as (almost) always, seems to make a lot of sense.

Silverlight UI thread dispatcher helper class

Thu, 12 Apr 2012 21:47:41 GMT

A simple class to manage dispatching calls to a UI thread in a silverlight application (might work in WPF too, I haven't tried it!)

    public static class UIThread
    {
        private static readonly Dispatcher Dispatcher;

        static UIThread()
        {
            Dispatcher = Deployment.Current.Dispatcher;
        }

        public static void Invoke(Action action)
        {
            if (Dispatcher.CheckAccess())
                action();
            else
                Dispatcher.BeginInvoke(action);
        }
    }

WCF services without adding a service reference

Thu, 12 Apr 2012 21:47:40 GMT

One way to avoid the spaghetti code and awkward namespaces that arise from using the Add Service Reference in Visual Studio is to extract your service interface code (including any DTO’s) into a separate assembly and share this assembly between your projects. You can also do this by referencing the same code files if you don’t want to share the assembly. Doesn’t this produce tight coupling though? Not really - you are sharing an interface, not implementation – the fact that the interface is a CLR object or a few C# files rather than a WSDL file is incidental.

    public static class WcfServiceFactory
    {
        public static T BuildServiceProxy<T>(string serviceUri)
        {
            var basicHttpBinding = new BasicHttpBinding
                                       {
                                           MaxReceivedMessageSize = 2147483647,
                                           MaxBufferSize = 2147483647,
                                           SendTimeout = TimeSpan.FromMinutes(10),
                                           ReceiveTimeout = TimeSpan.FromMinutes(10)
                                       };

            var endpointAddress = new EndpointAddress(serviceUri);
            var service = new ChannelFactory<T>(basicHttpBinding, endpointAddress).CreateChannel();
            return service;
        }
    }

This is a sample WcfServiceFactory class you can use to create a proxy that can then be injected via your DI container (or however you decide to instantiate it).

Entity Framework June 2011 CTP–enums!

Thu, 12 Apr 2012 21:47:38 GMT

The ADO.NET team at Microsoft just announced the release of the Microsoft Entity Framework June 2011 CTP.

There are a few nice features in there – one that I have been looking forward to is the enum support. Until now EF could not store enum values in the DB – the obvious way around this was to have a wrapper property in your entity class which exposed the enum value as an int or whichever data type your enum is based on. This works but it is a bit messy, so baked in enum support is a welcome feature.

My current work with Entity Framework is mostly based around code first so I decided to create a quick sample to see how enum support worked in code first.

First I installed the bits from here http://www.microsoft.com/download/en/details.aspx?displaylang=en&id=26660. I actually only installed the EF_JUNE_2011_CTP.msi as I didn’t need any designer or tools support for this quick test – it’s called code first for a reason

I fired up Visual Studio and created a new console app called EFEnumSupportTest. I like console apps for investigating new UI agnostic framework features as there’s barely any extraneous UI code to distract you from what you are trying to investigate.

To use the EF CTP you need to change the target framework for your app to the June 2011 CTP in the properties dialog for the project.

I added a reference to the EF CTP dll which on my machine was here:

C:\Program Files (x86)\Microsoft Entity Framework June 2011 CTP\bin\.NETFramework\System.Data.Entity.dll

Then the code. As this was a simple test I put all the code in the Program.cs file

Here is the whole file…

using System.Data.Entity;

namespace EFEnumSupportTest
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            var db = new EnumTestContext();
            db.Cars.Add(new Car {Make = "Bentley", CarType = CarType.Saloon});
            db.Cars.Add(new Car {Make = "Jaguar", CarType = CarType.Saloon});
            db.Cars.Add(new Car {Make = "Aston Martin", CarType = CarType.Saloon});
            db.Cars.Add(new Car {Make = "Land Rover", CarType = CarType.Estate});
            db.SaveChanges();
        }
    }

    public class Car
    {
        public int Id { get; set; }
        public string Make { get; set; }
        public CarType CarType { get; set; }
    }

    public enum CarType
    {
        Convertible = 1,
        Saloon = 2,
        Estate = 3
    }

    public class EnumTestContext : DbContext
    {
        public IDbSet<Car> Cars { get; set; }
    }
}

Ctrl+F5 and everything works, database created, data in database. (By default this uses .\SQLEXPRESS – this can be changed in the config file of course)

Nice. Code first really does make things easy and enum support is a welcome addition. Hopefully custom conventions, second level caching and migration support will make it in there soon!

A System.Reactive property change observer

Thu, 12 Apr 2012 21:47:36 GMT

I recently read Mike Taulty’s post on creating a FlickR searcher with Silverlight and Microsoft’s System.Reactive extensions. In his post, Mike says this about the way his property observer works: “That feels a bit weird and perhaps I should have passed a lambda into my FromPropertyChange wrapper function to grab the value from this.SearchText rather than do this?”

As we had implemented pretty much the exact the thing Mike describes in a recent project I thought I’d share it here (I was going to just post the code in the comments on Mikes blog but code snippets in blog comments rarely format well).

I’ll show you how to take the code that we wrote and integrate into the FlickR searcher that Mike wrote, replacing his property handler. First you’ll need to grab the code that Mike wrote – it’s available from his blog post.

Open the ObservableEx.cs file and paste the following code into the ObservableEx class.

        public static IObservable<TProperty> ObservePropertyChanges<T, TProperty>(this T notifyPropertyChanged, Expression<Func<T, TProperty>> property)
            where T : INotifyPropertyChanged
        {
            var propertyName = property.GetMemberInfo().Name;
            var func = property.Compile();

            var observablePropertyChanges = Observable.FromEventPattern<PropertyChangedEventHandler, PropertyChangedEventArgs>(
                h => notifyPropertyChanged.PropertyChanged += h,
                h => notifyPropertyChanged.PropertyChanged -= h)
                .Where(x => x.EventArgs.PropertyName == propertyName)
                .Select(x => func.Invoke(notifyPropertyChanged));

            return observablePropertyChanges;
        }

        public static MemberInfo GetMemberInfo(this Expression expression)
        {
            var lambda = (LambdaExpression)expression;

            MemberExpression memberExpression;
            if (lambda.Body is UnaryExpression)
            {
                var unaryExpression = (UnaryExpression)lambda.Body;
                memberExpression = (MemberExpression)unaryExpression.Operand;
            }
            else memberExpression = (MemberExpression)lambda.Body;

            return memberExpression.Member;
        }

There are 2 methods here – GetMemberInfo is just a helper method to get a MemberInfo object from a Lambda expression. This is used so we can get a MemberInfo object for the property lambda. The first method, ObservePropertyChanges, is a bit more interesting – we pass in an object that implements INotifyPropertyChanged (note the ‘this’ keyword so we can use this as an extension method) and a Func Expression – in practice this means we will pass a property lambda in. The method returns an IObservable for the property type we passed in.

Now open up the MainViewModel.cs file and find the InitialiseSearchTextSubscription method. Comment out the code in there and paste in this code instead:

this.ObservePropertyChanges(x => x.SearchText)
                .Where(text => text.Length > Constants.MinSearchStringLength)
                .Throttle(TimeSpan.FromMilliseconds(Constants.SearchTextTimeoutMs))
                .ObserveOnDispatcher()
                .Subscribe(OnNewSearch);

As you can see, this is pretty similar to the code Mike had already written to do the same thing. There are two main differences. First, we’re not using a ‘magic string’ to reference the property we want to observe(SearchText in this case) – we can use a strongly typed lambda – with all the benefits that gives us re. compile time type checking, refactoring etc. Secondly we don’t have to ‘select’ the property from the object we’re observing – the value is passed to us in the observable sequence.

Hope this is useful to someone

Orchard

Thu, 12 Apr 2012 21:44:21 GMT

I recently migrated this blog from dasBlog to the Orchard CMS. It all went pretty smoothly – I followed the instructions here pretty much, and everything was fairly simple. There was nothing really wrong with dasBLog I hasten to add, I just wanted to try Orchard and this seemed like a good opportunity to do it.

Blog archives don’t seem to be working at the moment, which I’ll investigate, although as I mostly use this blog for re-finding my own code snippets, it doesn’t really matter…

Fixed that issue as per: http://orchard.codeplex.com/workitem/18064

Now I have the next issue described here: http://teelahti.fi/blog/fixing-some-orchard-cms-blog-problems