Atlantic Breeze

Using Rebus Service Bus from F# with DotNet Core

noreply@blogger.com (Sean Kearon) — Fri, 15 Jun 2018 16:06:00 +0000

UPDATE December 2020

There is an improved and updated version of this article here:

https://seankearon.me/posts/2020/12/rebus-sagas-fsharp/

This post is about how to use Rebus from F# using DotNet Core. Code for the below is here.

What is Rebus?

Rebus is a free, open-source service bus written in .NET. Source code is in GitHub and, whilst it’s absolutely free to use, there are also professional support services provided by rebus.fm if you need them. It is very similar to other .NET service busses like NServiceBus (commercial) or MassTransit (free).

Why not Functions as a Service?

You can use something like Azure Functions or AWS Lambda and easily knock up a simple message-based architecture.

Azure Functions give you a lot of integration points and management tooling out of the box and you can install on your own box so you don’t even need to be tied to the cloud. They’ve even got durability and orchestration now.

It’s all super cool and could well be all you need for most scenarios. Services busses, like Rebus, NServiceBus or MassTransit have a whole lot of additional things that are not available out of the box with FaaS today, such as:

Publish/Subscribe (with more than one subscriber!)
Support for complex workflows (sagas)
Can be used in anywhere: web apps, desktop apps, services, the cloud…
Groovy stuff like deferred messages

That’s not a full list and I’m not saying FaaS > Service Bus or FaaS < Service Bus. My reasons for choosing Rebus here are:

I’ve been using it for years and trust it.
I’m already deploying a .NET Core Web API and want to host my bus in that.

A Service Bus Inside a .NET Core Web API?

Really? WTF??? I’ve been handling complex, long-running workflows inside an Azure Web App for a couple of years now (read my previous article here). That implementation is using Rebus with C# on .NET 4.x and has been running like a dream for years. As it’s in an Azure Web App, you can scale it up or down flicking a switch. I love it because it’s so simple!

So, given that I am writing a web API, I thought I’d use Rebus inside that. My API is written using F#, .NET Core and Giraffe. I’ve never seen anything about Rebus with F# before, but F# is just .NET and has excellent interoperability with C#.

By the way, I’m using F# because it’s expressive, concise and is a beautiful language for modelling domains. Read more from the venerable Scott Wlaschin here:

https://fsharpforfunandprofit.com/ddd/

https://fsharpforfunandprofit.com/posts/no-uml-diagrams/

Scott’s book, Domain Modelling Made Functional is also an excellent read. If you’re coming to F# from C# then I recommend Get Programming with F# by Isaac Abraham as well as Scott’s website.

Anyway, let’s get started!

Create .NET Core API with Giraffe

Instructions on how to set up a Giraffe app using dotnet new are in Giraffe’s docs here. The command line I used was: dotnet new giraffe –lang F# –V none.

This will give you a basic, functional .NET Core web API project. To that, add the following Rebus Nuget packages: Rebus & Rebus.ServiceProvider.

After that, you should be able to run your API and get a response from ~/api/hello. Here’s the routing configuration at this stage. Cool, eh?

Configure Rebus

We’re loosely following Rebus’ .NET Core configuration that you can find in their GitHub here. Instead of using Rebus’ in-memory transport as in the previous link, I’m going to use the file system transport. This is a great transport to use when hacking on Rebus as you can see your messages as files, and failed messages will be dropped into the “error queue”, which is a folder named “error”. By default, Rebus serialises messages to JSON with Base64 encoding of the message body, so they’re pretty easy to read. Error messages are added to the message as headers. Sweet!

Create a Message

Firstly, we need a message that we will send to Rebus. In Rebus, messages are modelled using .NET classes. Our message is going to be a very simple command to tell the bus to say hello. Here is is:

So, this is an F# record type that holds a single string field called Name. The CLIMutable attribute tells the compiler to generate IL that’s more friendly for the .NET serialisers – read about that on Mark Seeman’s blog here.

Create a Message Handler

Next, we need something to handle those messages. In Rebus, that’s a class that implements IHandleMessates<MyMessageType>, these are then registered into the bus. Rebus gives you fine-grained control over these are handled, but we only need a very simple handler. Here is what the interface looks like

Here’s what our F# implementation to handle our messages of type Commands.SayHello looks like:

This is a class in F# with a default constructor that implements the IHandleMessages<Commands.SayHello> interface. (A good place to start reading about classes is here.)

Rebus, being written in C# uses System.Threading.Tasks.Task for concurrency. F# has it’s own support for concurrency using Async workflow, and these are not the same things. You can, however, convert between the two models.

It’s worth noting that Giraffe works with Task/Task<T> and not F#’s Async. It does this to avoid having to always convert.

If you look at the code above, we are using F#’s Async and then piping that to RunAsRebusTask to convert back to a Task. Here’s how I’m doing that (using code from Veikko Eeva's comment here):

Configure and Start the Bus

Lastly, we need to configure and start Rebus’ bus. We do that like this:

This is nearly identical to the C# equivalent. The two notable changes are when we pipe output to ignore, which is needed because only the last expression in a block can return a value in F#, and the use of the different F# lambda syntax fun x –> …..

By default, Rebus will retry handling a message 5 times before it fails. If you’re hacking on Rebus, you may want only one exception in your message. You can configure the number of retries like you see on line 47 (again, a slightly different syntax to what you’d use in C#)

Then just hook that method up in your .NET Core service configuration as follows

Send a Message to the Bus

All good, we’ve got our Rebus bus running and waiting to handle messages. We just need to send it a message.

In my last article, I used a timer inside the web app to send a message. This was because I wanted to be able to leave it running for a day or so and come back to see that the bus had stayed running over that time. This time, I’m going to send a message to the bus as a result of a POST call to the API.

Set the Routing

Change the routing section to add a POST call, like this:

Note that there is no “fish” between the route and the handler when you use routef.

Create an HTTP Handler

We’re using Giraffe’s routef function to configure a route that passes off to sayHello. The implementation of which looks like this:

This function receives the string parameter passed from the routing and returns an HttpHandler. You can see it uses task { … } starting on line 23, which is Giraffe’s Task implementation mentioned earlier.

Line 25 does the business and sends a new message to the bus. We then return OK with a message saying the world is good.

On line 24 you can see that it uses an extension method on the ctx parameter (which is of type HttpContext). This is how you retrieve registered services from inside your HTTP handlers. If you’re coming from a C# background you may be expecting to see some sort of dependency injection. Dependencies are more explicit in a functional language – here they come from being passed in as a parameter. Read more about dependency management in functional programming here. In an OO codebase, line 24 would be called a Service Locator and lots of people would get very hot and bothered if they saw that. Don’t worry, it’s fine. The world isn’t going to end and your codebase will stay nice and maintainable!

All Done – Run it!

Run the project, and then post to our API and you get back a 200 OK with a nice message:

If you look in the console output from the app, you’ll see that our message has been handled by our message handler, which has printed out a nice message for us:

And there you have it – an F# implementation of a Rebus service bus running inside a Giraffe .NET Core Web API app!

Closing Thoughts

You can easily adapt the code above to run in other hosts, such as a console app, a service or a desktop app.

Remember that you’re not limited to using the file system to transport your messages.. Rebus provides a whole load of transports that you can use, ranging from RabbitMQ, Azure Storage Queues to databases like RavenDB, Postgres and SQL Server. You can see a list of what’s supported in .NET Core on this thread.

If you’re going to host in an Azure Web App, don’t forget to set the app to be “always-on”, as shown at the end of my previous article. You can also read a little about how to scale your bus in there too.

Code for the above is here.

Creating a new Fable React/Redux project

noreply@blogger.com (Sean Kearon) — Wed, 23 Aug 2017 17:54:00 +0000

React and Redux

React is Facebook’s JavaScript library for building user interfaces. It’s a joy to develop with and has a “learn once, write anywhere” philosophy that allows you to use your React skills to build not just JS based UI, but also Node-based server-side apps and mobile apps using React Native.

Redux is a predictable state container for JavaScript apps that is commonly used with React apps. It brings a whole pile more awesome to the table with things like time travelling debugging. There’s a bunch of free tutorial videos linked from the project’s home page.

All in all, the developer experience for using React is very joyful. The only downside is that setting things up can be difficult. I think this comment applies to a lot of the JavaScript world at the moment, but this is recognised and there is a lot of effort to make getting started easier. For example, check out the create-react-app project.

I’ve got to say thanks here to @nicklanng for introducing me to the joys of React and Redux – your lunchtime lightning talk changed my dev-life, mate! :)

Fable

The Fable Compiler compiles F# into JavaScript. It’s tag line is:

The compiler that emits JavaScript you can be proud of!

Or, in the words of Tomas Petricek,

JavaScript you can take home to meet your mother.

You’ve gotta love that description!

So, basically you can write beautiful, type safe, immutable F# code and Fable will translate it into JavaScript for you. That’s another level of awesome and I encourage you to take a look at the amazing samples to see what can be done with Fable. You can even set a breakpoint in Chrome and you’ll see the F# code in the Chrome dev tools! Oh my…

Whilst things like TypeScript and Facebook Flow are very good to help you write complex JavaScript apps, having the F# compiler behind takes that support to a whole new level.

Why not Elm? Elm also brings the benefits of a functional type-checked language to web development. and it’s certainly an awesome language. For me, the choice of Fable comes down to the fact that it can keep growing my F# skills whilst doing web development (the used key is the brightest, right?), and I can also leverage the wonderful “learn once, write many” approach of React to write native mobile apps. (Sure, there’s some talk about using Elm with React Native if that floats your boat.)

You even stop at breakpoints in Chrome in your F# code - tell me that that’s not just totally amazing!

But…

But setting up a Fable React/Redux project isn’t the easiest thing to do, particularly when you’re starting out. So, if you’d like to take Fable with React and Redux out for a spin, but didn’t know where to get started, read on.

Getting Started

Firstly, head over to Fable’s page about getting set up and install all the shizzle you’ll need (.Net Core, Yarn, etc.). You can find that here:

http://fable.io/pages/getting-started.html

Then follow the steps below to create your first Fable React/Redux project and start hacking:

1 – Create a Project

We’re going to create a project called “fableredux”. If you want, change that to something else, but make sure you use your name throughout the rest of the instructions. (You’ll be working mainly in your console.)

dotnet new fable -n fableredux
cd fableredux

2 - React and Redux

Install the NPM modules we’ll need:

yarn add react react-dom fable-core fable-react redux
yarn install (might not be needed)

3 - Configure webpack

Locate the file webpack.config.js. We’re going to add the externals section to tell webpack about the external dependencies. If the section is already present, just add the entries for react and redux, as below:

    ...
    devServer: {
        contentBase: resolve('./public'),
        port: 8080
    },
    // This section needs React and Redux
    externals: {
        "react": "React",
        "redux": "Redux"
    },
    module: {
    ...

4 - Update References

The Fable sample app loads the React and Redux JS dependencies from disk in in it’s index.html file. We’ll stick with that approach.

Copy index.html and the supporting files in the \lib folder from the Fable Redux sample and replace the files in the project’s \public folder. You can get those from here:

https://github.com/fable-compiler/samples-browser/tree/master/public/redux-todomvc/

5 - Add Fable.React

Use Paket to add the Fable.React Nuget package to the project (assumes Paket is on the path).

paket add fable.react

Also, make sure there is an entry for Fable.React in src\paket.references. Add it if it doesn’t already exist.

6 – Add Some Fable Code

Let’s get the Fable F# code in now. Replace the contents of App.fs with the contents of the App.fs from the Redux-ToDoMVC from the Fable samples. You can get that here:

https://github.com/fable-compiler/samples-browser/blob/master/src/redux-todomvc/App.fs

Make sure to change the line that says:

module ReduxTodoMVC

To the following (or whatever you named your project at the start):

module fableredux

7 - Restore and Build

cd src
dotnet restore
dotnet build

You should see a message that the build has succeeded.

8 - Run it!

Now you’re ready to run the project (sometimes I needed to close and re-open my console here as it complained about not finding an executable matching dotnet-fable. YMMV!):

dotnet fable yarn-start

Then open http://localhost:8080 and enjoy!

Getting Help

The Fable community is awesome so drop by their Gitter room (and thanks to @rkosafo for assistance getting me over some bumps along the way!):

https://gitter.im/fable-compiler/Fable

Running Rebus Service Bus in an Azure Web App

noreply@blogger.com (Sean Kearon) — Sun, 19 Jun 2016 07:47:00 +0000

What’s all this?

Rebus is a lean service bus running in .NET that is also free and open source. It’s created and is maintained by Mogens Heller Grabe, and it even has stickers! It’s a whole pile of awesome and I warn you that it may change the way you build software forever. You can find more delights in the Rebus wiki. Mogens also wrote an article about using Rebus in a web application, which you can find here:

http://mookid.dk/oncode/archives/4008

Rebus is similar to other .NET Service Buses, like NServiceBus, MassTransit and EasyNetQ. You can also host these buses in Azure web apps (note that NServiceBus is commercial and EasyNetQ only supports RabbitMQ for message transport and does not support long running processes (sagas)).

Azure Web Apps are fully managed service in Azure that lets you easily deploy, run and scale your apps, APIs and websites. They are beautifully simple things to work with and to manage. They really do just work!

Rebus is typically run as a Windows service on a server or VM. Can I really run a server-side service in an Azure Web App, I hear you ask? Yes you can, and that’s just what we’re going to do!

Is there code?

Yes there is! You can get it from here:

https://github.com/seankearon/rebus-in-azure-wep-app

Choose your toppings

A quick read through the Rebus docs shows that it supports a whole bunch of message transports, types and storage mechanisms and it has support for most of the current IoC containers. I’m going to use Autofac as our DI container and Azure Service Bus as our message transport medium. I’ll also be using Visual Studio 2015 with Web API 2 (because Rebus doesn’t support ASP.Net Core at time of writing).

Why Autofac?

You don’t need a DI container when working with Rebus as it has one baked right in. I always use Autofac (because it rocks) and I’m going to use to show a how little configuration you need once you’re set up.

Why Azure Service Bus?

Like other message queues, Azure Service Bus has built in pub/sub mechanisms and can do lots of wonderful things for you at huge scale. We’re just going to be using it as a message queue for and let Rebus will deal with all the message handling, subscriptions, orchestration and all that malarkey.

Why Azure Web Apps?

These beasties are super easy to develop, debug, deploy, manage and scale. You can scale your service to huge capacity using Azure, or keep it pared down to a minimum (free!). The Azure infrastructure takes care of all the maintenance patching for you and will make sure your service is restarted if it stops. In my view, this is probably one of the best developer experiences around!

Guess this has to be SBaaS: Service Bus as a Service!

Create the Web API project

Start by creating a new ASP.NET Web API project:

Select the Empty project template and add references for Web API:

You should end up with something like this:

Add Rebus and Autofac packages

Install the packages by opening the Nuget Package Manager Console and running this:

install-package Rebus.Autofac

install-package Rebus.AzureServiceBus

This will bring in both Rebus and Autofac along with the Rebus package for interop with Autofac and Azure Service Bus. Then run the following command to add the package that allows Autofac to work with ASP.Net Web API 2:

install-package Autofac.WebApi2

Configure the Autofac container

I’m going to use Autofac to start up the Rebus bus when the app starts. Start by creating the following a configuration class for Autofac:

This sets up the Autofac container and then registers it with ASP.Net Web API on line 21. You know – if you’re just going to use Rebus and you’re not going to inject dependencies into any controllers, then won’t need that line.

Take a look at line 15. This tells Autofac to {scan the assembly](http://docs.autofac.org/en/latest/register/scanning.html) and register all Autofac modules it finds. I’m using that as I’m going to be putting the rest of my container configuration into a module which we’ll see later.

Line 19 is where we pass the Autofac container into our Rebus configuration, which we’ll see later. The last thing is to call the configuration when the app starts up:

That’s all the Autofac configuration needed. Let’s configure Rebus next.

Configure the Rebus bus

The following class is responsible for the bus configuration:

The container parameter on line 12 is an Autofac container passed in from the Autofac configuration earlier. On line 14 we pass that container into the Rebus Autofac adapter which will make Rebus use our Autofac container and will also register Rebus’ types into our container so we can use them later.
Read more in the Rebus docs here.

You’ll need to add a connection string for your Azure Service Bus – or you can remove lines 18 – 21 and uncomment line 21 to use your file system as the message transport to run locally.

Line 22 tells Rebus where to send messages that you give it. Read more about that in the docs here.

The lines 25 and 26 start a timer to give us a simple heartbeat so we can see that the bus is running when it’s in Azure.

Registering handlers and getting the heart beating

Our heartbeat is going to work by having a simple timer running that publishes a message to the bus every few seconds. Then we have a handler that receives that message and updates a simple counter to increase the heart beat count. This is going to show us the magic of our bus running in the Azure Web App.

So, the next part is to set up the and also register any and all Rebus message handlers into our Autofac container.

Lines 15 to 17 registers all the Rebus message handlers in this assembly by using Autofac’s assembly scanning. A message handler is a class than received a message from the bus and does things with it.

Rebus has a lot of rich support for controlling how and when this happens – see the docs for more.

Starting on line 20 we add a simple timer that sends a message to the bus every few seconds. I’m using Autofac’s named registration so that I know which timer I’m getting back from the container when I start it up.

The message

In Rebus, messages are just simple POCO types. I am using this one for our heartbeat:

The handler

The Rebus message handler is the class that receives the message. Again, it’s just a very simple class which looks like this:

All it does is to tell the heart to beat! It’s worth noting in case you are new to Rebus – you can have more than one handler for this message type and Rebus will take care of getting the message to all your handlers.

The heart

The heart is just a static class that keeps a count of not many times it has beaten and tells us when it was last refreshed.

The controller

Just so that we can see the heartbeat, we’re going to add a simple Web API controller to allow access to the internal state.

Bring it to life

Run the project in Visual Studio and it will open a browser. Navigate to /heartbeat and you’ll see something like this:

Refresh the browser and you’ll see the number of heart beats increases every 5 seconds, which means our Rebus bus is sending and receiving messages. Woohoo – happy days!

An easy way to see the message content (which is JSON serialised by default), swap the Rebus transport to use the file transport in your RebusConfig class:

Getting an error?

You might get an error about not being to resolve the AzureServiceBusTransport. That will be because you haven’t set up the connection string in RebusConfig.

What’s all this doing?

Let’s review how all this is working.

We have an ASP.NET Web API app that configures an Autofac container when it starts up.
The Autofac container scans the assembly for Autofac modules and it finds a module that does two things.
The Autofac module it finds scans the current assembly and then registers all the Rebus handlers that it finds in that assembly.
The Autofac module then registers a timer that is configured in the module to send heart beat messages to the bus every few seconds.
The Autofac container is then built and passed into our Rebus configuration.
The Rebus configuration sets up a Rebus bus that uses Azure Service Bus as its message transport.
The Rebus configuration then starts the Rebus bus and makes it available from inside the Autofac container.
Then Rebus configuration resolves our timer from the Autofac container and starts it.
It’s worth noting here that when the timer starts inside the Autofac container, it resolves the Rebus bus directly from the Autofac container.
The timer send a message to the Rebus bus, which puts it into the Azure Service Bus queue.
The Rebus bus is monitoring the Azure Service Bus queue and it detects the message, opens it and passes it to the handler that we’ve built to handle those messages.
The message handler then tells the heart to beat.

Deploy to Azure Web Apps

The last part is to publish all this goodness to an Azure Web App. There are plenty of ways to publish an Azure Web App, including publishing from Git. I’m just going to use Visual Studio for that.

Right click the solution and choose Publish:

You might need to sign into your Microsoft Account at this point. Select the Azure App Service target:

Select an App Service, or click New to create one:

Enter the details and click Create:

Then click Publish in the next screen to publish to Azure:

You’ll see something like this (with links for how to set up Git deploy if you’re interested!):

Navigate to /heartbeat to see Rebus running in an Azure Web App:

Getting an error?

Did you set the Azure Service Bus connection string?
Scaling out and keeping it running

If your use case is to have a service bus running in the cloud, then you’ll most likely want it to stay on. Azure Service Bus will unload an app if it’s idle for a period of time, but you can configure it to keep the app on at all times.

Note that you always on is not available in the free Azure plan, you need Basic or Standard mode for this. You can read more about that here:

https://azure.microsoft.com/en-gb/documentation/articles/web-sites-configure/

As for scaling, it’s super easy to scale to giddy heights. Read more here:

https://azure.microsoft.com/en-gb/documentation/articles/web-sites-scale/

Enjoy!

Using PowerShell as the Visual Studio Developer Command Prompt

noreply@blogger.com (Sean Kearon) — Sat, 15 Aug 2015 09:44:00 +0000

Overview

The Visual Studio Developer Command Prompt is a command window that loads up a bunch of useful environmental enhancements when it starts. This let's you access things like sn.exe from your command window. However, it loads up in cmd.exe and I prefer using PowerShell 'cos it's proper useful! This article shows one way making PowerShell act like the Developer Command Prompt.

Adjust your PowerShell Profile

When PowerShell loads it looks for a profile file under your user profile and loads that if found. By default, the profile file is:

\WindowsPowerShell\Microsoft.PowerShell_profile.ps1

Note that you can access your documents folder path from PowerShell like so:

$([environment]::getfolderpath("mydocuments")

If that file isn't there, create it, add the following code and save it:

Adjust the environment in the last line above according to your VS installation.

Load in PowerShell

Open up a new PowerShell window (existing windows will not have loaded the profile we've just saved). Type sn and to show that you don't have access to sn.exe:

Then type As-VSPrompt and hit . This will load up the Developer Command Prompt profile. Type sn and again and you see sn.exe reporting for duty:

Installing a Service using Topshelf with OctopusDeploy

noreply@blogger.com (Sean Kearon) — Sun, 25 Jan 2015 10:24:00 +0000

I was using OctopusDeploy to install a Rebus service endpoint as a Windows Service from a console application created using Topshelf.

Octopus has built-in support for Windows Services that uses sc.exe under the hood. I'd used this many times previously without hitch, but for some reason the install seemed to start before the service was fully removed. As Topshelf can do all the service set up, I decided to try using that instead.

My deployment step in Octopus was configured to use the standalone PowerShell scripts. Installing using Topshelf is simple - just call the executable using the commandline install --autostart. Removing a Topshelf service is just as simple - call the executable using the uninstall commandline.

The only hard part is finding the executable path for the service so that you can remove the service before re-deploying. PowerShell doesn't have built-in support for this at time of writing, but you can do that pretty easily using WMI. The following function is based on David Martin's SO answer and finds the executable path from the service name:

From that point, it's pretty easy to remove the service using Topshelf:

An alternative approach would be to use a known installation location each time and derive the executable path using Octopus' powerful variables.

References
The code for the pre-deployment and post-deployment tasks can be found in this gist.
The full Topshelf command line reference is here.

Using IIS URL Rewrite

noreply@blogger.com (Sean Kearon) — Fri, 31 Oct 2014 19:56:00 +0000

This article is about creating IIS URL Rewrite Rules using Powershell. The Powershell functions that we use apply generally to reading and writing to .NET configuration file (web.config, app.config, etc.), and so can be applied to tasks like updating connection strings.
The functions used are:

Get-WebConfigurationProperty
Add-WebConfigurationProperty
Set-WebConfigurationProperty

Although these are powerful, being well documented is not their strongest feature! There are also a couple of simple pitfalls with the URL Rewrite Rules, which I’ll point out. Note that for the following to work, you’ll need to have the IIS URL Rewrite extension installed in IIS. You can install this using the Web Platform Installer, or using Chocolatey.

Files for this article can be found here.

The test website

So we can test our rewrite rules we’ll use a simple website structured as follows:

Each leaf folder has two HTML files, 1.html and 2.html and there’s a page of links at the root:

To help test the rewrite rules, the HTML files indicate where they are in the structure:

Introduction to rewrite rules

The rules can be maintained in the IIS Manager by double clicking URL Rewrite in features view:

There is a rich GUI that lets you maintain the rules and which does validation against your input:

The above rule redirects any URL section matching “1.html” to “2.html”. You’ll see this in the site’s config file:

The rules are stored in the config file. The config file that’s changed depends on whether you apply the rules at the level of the virtual directory, website or the server. If the rules apply at the server level they are stored in the main IIS config file here:

%windir%\system32\inetsrv\config\applicationHost.config

After this rule has been applied, recycle the app pool or reset IIS and then when accessing http://localhost/simple-rewrite/1.html you’ll be taken to http://localhost/simple-rewrite/2.html.

Using Powershell

Firstly, make sure you have the WebAdministration module loaded:

Import-Module WebAdministration

To create the above rule using Powershell, run the following script (see CreateRule1.ps1):

Add-WebConfigurationProperty `-pspath 'IIS:\Sites\Default Web Site\simple-rewrite' `-filter '/system.webserver/rewrite/rules' `-name "." `-value @{name='Rule 1'; patternSyntax='ECMAScript'; stopProcessing='True'}
Set-WebConfigurationProperty `-pspath 'IIS:\Sites\Default Web Site\simple-rewrite' `-filter '/system.webserver/rewrite/rules/rule[@name="Rule 1"]/match' `-name url `-value '1.html'
Set-WebConfigurationProperty `-pspath 'IIS:\Sites\Default Web Site\simple-rewrite' `-filter '/system.webserver/rewrite/rules/rule[@name="Rule 1"]/action' `-name . `-value @{ type="Redirect"; url='2.html'; redirectType="SeeOther" }

The pspath parameter is the website path in the format used by the WebAdministration module. The filter parameter is the XPath to select the element we’re interested in. Here it’s under rules/rule and has a name attribute with the value “Rule 1”.

To remove the rule, run the following script (see RemoveRule1.ps1):

Clear-WebConfiguration `-pspath 'IIS:\Sites\Default Web Site\simple-rewrite' `-filter '/system.webserver/rewrite/rules/rule[@name="Rule 1"]'

Note that Clear-WebConfiguration removes the rule using the name selector and will raise an error if the rule is not found. W If you want to test whether the rule exists, use Clear-WebConfiguration as follows:

$existing = Get-WebConfigurationProperty `-pspath 'IIS:\Sites\Default Web Site\simple-rewrite' `-filter '/system.webserver/rewrite/rules/rule[@name="Rule 1"]' -name *
if ($existing) {
Clear-WebConfiguration `-pspath 'IIS:\Sites\Default Web Site\simple-rewrite' `-filter '/system.webserver/rewrite/rules/rule[@name="Rule 1"]'
}

Rule processing order and redirect exclusions

The rules are processed in the order they appear in IIS Manager and the config file. A rule can be set to stop processing of subsequent rules. These two combine to make an effective way to create an exception to a redirect. Say you wanted to redirect all “1.html” URLs to “2.html” except for “~b/c/1.html”. To achieve this add in the following rule above the more general redirect:

Your configuration will look something like:

Using rule conditions

Let’s say you want a rule that applies to POSTs to a particular URL but which only contain certain parameters in the query string. Such as a POST to:
~/b/2.html?paramA=Z

Let’s say we want to detect parameter values of X, Y or Z. You can do this using rule conditions. The completed rule looks like this in IIS Manager:

In the configuration, this rule looks like:

And can be scripted as follows:

Add-WebConfigurationProperty `-pspath 'IIS:\Sites\Default Web Site\simple-rewrite' `
-filter '/system.webserver/rewrite/rules' `-name "." `-value @{name='Rule 1 Post Exception'; patternSyntax='ECMAScript'; stopProcessing='True'}
Set-WebConfigurationProperty `-pspath 'IIS:\Sites\Default Web Site\simple-rewrite' `
-filter '/system.webserver/rewrite/rules/rule[@name="Rule 1 Post Exception"]/match' `-name url `-value "b/2.html"
Add-WebConfigurationProperty `-pspath 'IIS:\Sites\Default Web Site\simple-rewrite' `
-filter '/system.webserver/rewrite/rules/rule[@name="Rule 1 Post Exception"]/conditions' `-name "." `-value @{input="{REQUEST_METHOD}"; pattern='POST'}
Add-WebConfigurationProperty `-pspath 'IIS:\Sites\Default Web Site\simple-rewrite' `
-filter '/system.webserver/rewrite/rules/rule[@name="Rule 1 Post Exception"]/conditions' `-name "." `-value @{input="{QUERY_STRING}"; pattern='paramA=(X|Y|Z)'}

Notes and gotchas

Rules are relative to the site root

Once you realize that the redirect URLs are relative to the site root, it’s all very obvious. Gaining that realisation can take some time! So for the example site above, the following rule will do nothing:

IIS Manager has code completion for conditions

When you add a condition in IIS Manager, you get code completion after typing the first “{“ (such as in the POST exception rule above):

Files get locked and browsers cache pages

When you’re developing the rules config file is being touched by TIIS, IIS Manager, Notepad++, Powershell and goodness know what else. Your super-modern browser is being super-modern helpful and caching the HTML pages. Sometimes you just need to recycle the app pool to see the updated rule. Other times, you need to do an IIS reset, clear your browser cache and restart your tool windows.

Default values are not written

When the rule’s action type is None and it stops processing of other rules, the configuration written by the IIS Manager GUI is like this:

Following the same pattern for creating the rule in a script, you can run something like this (see CreateExceptionRule.ps1):

Add-WebConfigurationProperty `-pspath 'IIS:\Sites\Default Web Site\simple-rewrite' `-filter '/system.webserver/rewrite/rules' `-name "." `-value @{name='Rule 1 Exception'; patternSyntax='ECMAScript'; stopProcessing='True'}
Set-WebConfigurationProperty `-pspath 'IIS:\Sites\Default Web Site\simple-rewrite' `-filter '/system.webserver/rewrite/rules/rule[@name="Rule 1 Exception"]/match' `-name url `-value 'b/c/1.html'
Set-WebConfigurationProperty `-pspath 'IIS:\Sites\Default Web Site\simple-rewrite' `-filter '/system.webserver/rewrite/rules/rule[@name="Rule 1 Exception"]/action' `-name . `-value @{ type="None" }

The above script writes the following to the configuration file.

Note that the action element is not written. It seems that the Powershell command knows that <action type=”None”> is the default and doesn’t bother to write it, but the IIS Manager GUI writes it anyway. If you didn’t know that you may spend a lot of time trying to work out why your Powershell isn’t doing what you think it should!

Simple UI testing with Nightwatch.js

noreply@blogger.com (Sean Kearon) — Sat, 11 Oct 2014 08:37:00 +0000

This week I was introduced to Nightwatch.js by my colleague Matt Davey. Nightwatch provides a clear and simple syntax for writing your UI tests and uses NodeJS and Selenium to run the tests.

Having played with Canopy for UI testing, the high readability of the test syntax impressed me from the start. We used it to nail down a reproduction of a bug we were working in our test environment.

Test scenario

Our test did something like this

Logs into a site using known credentials.
Clicks through to a place in the UI.
Changes and saves a value.
Asserts that the new value is being displayed in another area of the UI.

The test syntax

The test syntax looks like this:

The syntax is clean, easy to read and all in a one file. One of the CSS selectors is pretty evil, but you can get that from the browser’s context menu in the inspector (which I learnt this week too!):

Setting up the test runner

Setting up to run the test is very simple to do on any development or test machine. You the components are:

NodeJS
NPM
Nightwatch
A Selenium Server

You can install Java, NodeJS and Nightwatch using Chocolatey by opening a command window and running:

choco install javaruntime
choco install nodejs.install
npm install -g NightWatch

Note that Chocolatey seems to install the Node packages under Chocolatey's folders, and NPM then places the Nightwatch module into the nodejs.commandline folder under \tools. In there is a batch called Nightwatch.cmd in there that we need to access. So, we need to add the following to our path:

C:\ProgramData\chocolatey\lib\ nodejs.commandline.X.Y.Z\tools

(where X.Y.Z is the NodeJS version we’ve installed.)

Then we need to start up a Selenium server. It would be nice to use Chocolatey here too, but the version of Selenium from the package at time of writing is too old. So, download the latest Selenium driver (JAR) from here (which is 2.43 at time of writing).

Rename the Selenium JAR file to selenium-server-standalone.jar and save it to C:\selenium\. Then start up a Selenium Server for opening a new command window (as admin) and typing:

java -jar "C:\selenium\selenium-server-standalone.jar"

That’s the setup done, now let’s run the test.

Running the test

Save your test (similar to the code above) to a file, let’s say repro.js, into a folder. Create a sub-folder called “examples\custom-commands” (which Nightwatch wants to find, not sure why!).
Then open another command window and change to the folder containing the test file and run the following:

nightwatch --test repro.js

Job done!

Testing TypeScript with Jasmine in Visual Studio

noreply@blogger.com (Sean Kearon) — Mon, 11 Aug 2014 09:49:00 +0000

This post is about setting up testing for TypeScript with Jasmine in Visual Studio, but it should be pretty much the same using QUnit.

To set this up, start a new MVC project and let’s get Knockout and Jasmine installed into the project, along with their TypeScript definitions:

Install-Package knockoutjs
Install-Package knockout.typescript.DefinitelyTyped
Install-Package JasmineTest
Install-Package jasmine.typescript.DefinitelyTyped

We’re using the Jasmine Nuget package called JasmineTest. There is a similar one on Nuget called Jasmine-JS, the difference being that JasmineTest will add a controller and view to let you run your tests. We’ll be using that in a second to let us debug the tests. Now run and browse to ~/jasmine/run and you’ll see this:

This is the view added by the JasmineTest package. It is an HTML page (SpecRunner.cshtml) and has the references for the example Jasmine specs that ship with Jasmine. We are going to be using to let us debug out tests.

So, let’s write some tests. For simplicity we’re going to put the model and the tests into the same file. So we add a TypeScript file called Tests.ts to your /Scripts folder and add the following lines to that file, giving this:

Running tests with ReSharper

If you have ReSharper installed, then the R# Test Runner will recognise the Jasmine test and allow you to run them. To set this up for a smooth experience, first install PhantomJS and set the path to phantomjs.exe in Resharper | Options | Tools | Unit Testing | JavaScript Tests.

R# will need to find the .JS files for the .TS references. R# will look for and use a file that is named the same as the Definitely Typed TS file, but ending with .JS. For us, this means copying knockout-3.1.0.js from /Scripts to /Scripts/typings/knockout and renaming it to knockout.d.js:

After that you can just run the tests as you would in C#:

Running tests with Chutzpah

You can also use the Chutzpah test runner to run Jasmine tests in Visual Studio. You can install that from Tools | Extensions and Updates here:

Once installed, you just right click the TypeScript file that contains the tests and select the item Run JS Tests. This puts the test results into the Visual Studio Output window by default, but there is a Visual Studio extension that gives integration with the Visual Studio Test Explorer.

If you go ahead and run the tests as shown above you’ll get an error. This is because Chutzpah resolves referenced JS files differently to R#. For this to run, we need to add a reference to the JS file in the TS test for Chutzpah to pick up. This is documented here and looks like this:

/// <chutzpah_reference path="knockout-3.1.0.js" />

Debugging tests in Visual Studio

As far as I can tell, there is currently no support from either R# or Chutzpah for debugging TS tests from either test runner in the IDE. However, we can do that by going back to our SpecRunner.cshtml that was installed with the JasmineTest Nuget package.

Just add the JS references along with a reference to our test file to the HTML shipped with the package:

Note that we are referencing Tests.js instead of the TS file. Then place a break point in the test in the TS file, run a browse to ~/Jasmine/Run:

Job done! Source code is here: https://bitbucket.org/seankearon/typescript-testing-in-studio

Does Windows Azure comply with UK/EU Data Privacy Law?

noreply@blogger.com (Sean Kearon) — Fri, 29 Mar 2013 12:21:00 +0000

Update, November 2016

Times have changed and the content of my article from 2013 may no longer be correct due to a recent ruling by the European Court of Justice. Read more here:

http://uk.businessinsider.com/european-court-of-justice-safe-harbor-ruling-2015-10

TL;DR

Yes, it does. The Information Commissioner’s Office in the UK considers that Windows Azure provides adequate protection for the rights of individuals with regard to their data that is held on Windows Azure.
Given that you have the other relevant measures in place to comply with the Data Protection Act, this means that you go ahead and use Windows Azure to store your customers’ personal information. As Microsoft comply with the EU/US Safe Harbor Framework, the data can be considered to remain solely within the EU geographic region.

Background

As developers we often need to store information about individuals, such as their name and email address. When people share this information with us, they expect that we will treat the information properly and respect their privacy.
In the UK, the Data Protection Act provides a legal framework to define how companies capture and process information about individuals. For instance, they may choose to let you send them an email newsletter, but tell you that they do not want to receive then from other companies that you work with.
In the UK, the Information Commissioner’s Office (ICO) is the body responsible for upholding information rights and privacy for individuals. The ICO can and do fine companies who do not treat individuals information properly. These fines are quite large too!

To the Cloud

As developers we increasingly want to be able to use hosted cloud services to build our web sites and internet enabled applications. There are a number of choices out there that include large offerings such as Windows Azure and Amazon Web Services, but also more targeted offerings such as MongoHQ.
If we store any information about an individual (in the UK the law relates to living individuals), then any cloud service that we use as developers must ensure that the data about the individuals is protected.

Keep it local

Other member states of the European Union have similar data protection laws and there is a common legal framework to protect the rights of individuals in the EU.
To be able to benefit from the protection that this legal framework gives, the individual’s data has to remain physically within the EU. If the data were to be held in another country outside of the EU, then the laws of that country would apply to that data. For example, the US has a very different approach to the protection of individuals data than we do in the EU.

Back to the Cloud

Let’s look at how Amazon AWS and Microsoft Azure - two popular US cloud providers - handle this.
Amazon make the statement that any data hosted in one of their EU regions will remain within that region. You can read that here. Okay, not much detail in that, but it sounds fine.
Azure talk a little more about this than Amazon and you can read about that here. If you are eagle eyed, then you will notice that data in Azure EU regions will generally remain in the EU, but may be shipped to the US for disaster recovery purposes.
Oh dear, that sounds like it breaks the condition that data has to remain physically within the EU.

Can I use Azure then?

Yes, you can. The reasons for this - also stated on Azure Trust Centre Privacy page – is that Microsoft are certified as complying with the EU/US Safe Harbor Framework.
This is a legal framework between the EU and the US Department of Commerce that essentially provides EU compliant data protection for data that is moved to the US under the Safe Harbor Framework. The ICO deem that the Safe Harbor Framework provides adequate protection for the rights of the individual whose data may be transferred to the US by Microsoft. You can read about that here.

That’s simple then – why the doubt?

So, if it’s that easy, why am I writing this article in the first place? Well, I’ve been looking at Azure for a while now and wanting to use it for some of my applications. The advice I had received in the past was basically that once the data was in the US, other US laws, such as the Patriot Act, could override the Safe Harbor Framework and remove the legal protections provided by the Safe Harbor Framework.
If that was the case, then I would need treat it as if it were being shipped outside of the EU and under the jurisdiction of different data protection laws. Not something that my customers would want to hear! Also, the reason why I’d been using Amazon AWS.
I recently spun up a build server on an Azure VM and I absolutely loved the experience of using Azure. I was thinking what a shame it was that I couldn’t use it more and so I got in touch with the venerable Mr Hanselman, Microsoft developer evangelist extraordinaire, to say “please can we use Azure in Europe?” (I had previously tried other routes, but without getting any answers).
Scott kindly took my question back to the Azure team and then came back with a bunch of challenges for me. The summary of those being that all I needed was already on the Azure Trust Centre Privacy page. And, he was quite right too!
I got onto the phone to the ICO and asked them about it, and they confirmed that this provided “adequate protection for the rights of individuals” and that there are exceptions to data protection law to allow circumstances such as the Courts or the Police to have access as part of their investigations – both in the EU as well as the US – and that I could now just focus on complying with the Data Protection Act requirements.
Awesome – my future is now on Azure!

A note of caution

It’s worth remembering that the location of the data is just one part of the process of protecting your customers’ data. You need to make sure that you comply with all other aspects of the relevant data protection laws.
Generally, the more sensitive the information and the more people about whom you hold that sort of information, the less likely you will be able to host it externally.
In the UK, if you’re not sure about how to go about things, contact the ICO for advice – they’re very helpful people!

Embedded RavenDB Indexes with Obfuscation

noreply@blogger.com (Sean Kearon) — Wed, 23 May 2012 17:04:00 +0000

I ran into an issue today with using RavenDB from an obfuscated assembly. RavenDB started giving some nasty looking errors like:

System.InvalidOperationException: Could not understand query:
-- line 2 col 43: invalid NewExpression

After bashing my head against this for too long, I had run out of ideas and so I posted the problem on the RavenDB group. One of the really good things about RavenDB is the amazing support from both the Hibernating Rhinos team and the community on this group. So, pretty soon it was problem solved!

The problem: the obfuscation was renaming the anonymous types that are used when defining indexes from code in RavenDB.

The solution: either put your types into a non-obfuscated assembly or tell the obfuscator to stop renaming anonymous types. Let’s look at the second option a bit more.

Okay, so how do you detect an anonymous type? One way is to look at their names. The compiler gives anonymous types names and puts the text “AnonymousType” into the name. For example:

new { Name = "Sean"}.GetType().Name // Gives: <>f__AnonymousType0`1

Simple enough, but there is a caveat: the naming of anonymous types is an implementation detail and may vary with different compiler implementations. You cannot rely in this working with different compilers.

So, with that in mind, let’s look at a solution…

Different obfuscators allow you to add obfuscation rules in various ways. In this repo there is an example of using Eazfuscator with a RavenDB index. (Note that you will need to install Eazfuscator to be able to run the code.) All that is needed is to use an assembly scoped ObfuscationAttribute to prevent renaming of any type whose name contains the text “AnonymousType”:

[assembly: Obfuscation(Feature = "Apply to type *AnonymousType*: renaming", Exclude = true, ApplyToMembers = true)]

Bingo, everything works as it should again…happy days!

RavenDB Magic – Modelling Polymorphic Collections

noreply@blogger.com (Sean Kearon) — Sat, 21 Apr 2012 08:32:00 +0000

I'm starting to port my main application over to RavenDB. A driving design principle for RavenDB is to reduce friction for the developer and the main reason I’m choosing RavenDB is to make my life easier. Here's one example of that...

Let’s say that you’ve got a model with a marker interface and some types implementing that interface. Something like this:

   public interface ILookup { }

   public class IntegerLookup : ILookup
   {
      public int Number { get; set; }
   }
   
   public class StringLookup : ILookup
   {
      public string Text { get; set; }
   }

Then you have a type that holds a collection of the interface:

   public class Container
   {
      public ILookup[] Lookups { get; set; }
   }

All good so far, and now you want to store this in a database. Not quite so simple! If you’re using a relational database, whether through an ORM or another means, you will have to do quite a bit more work to get your objects into the database and back.

However, if you’re using RavenDB then your work is done! Well, nearly - all you need to do is to add an Id property to your container to tell RavenDB to store it as a root:

   public class Container
   {
      public string Id { get; set; }
      public ILookup[] Lookups { get; set; }
   }

That’s it – the rest is pure Raven magic! Here’s a test showing how Raven it handles it:

   [Test]
   public void can_store_polymorphic_collection()
   {
      using (var store = new EmbeddableDocumentStore
      {
         DataDirectory = "Data",
         RunInMemory = true
      })

      {
         store.Initialize();

         var holder = new Container
               {
                  Lookups = new ILookup[]
                              {
                                 new StringLookup {Text = "Hello"},
                                 new IntegerLookup {Number = 123}
                              }
               };

         using (var session = store.OpenSession())
         {
            session.Store(holder);
            session.SaveChanges();
         }

         using (var session = store.OpenSession())
         {
            var h = session.Load<Container>(holder.Id);

            Assert.That(h.Lookups
               .OfType<StringLookup>().Single().Text == "Hello");
            Assert.That(h.Lookups
               .OfType<IntegerLookup>().Single().Number == 123);
         }
      }
   }

You just new up an instance of Container, add in a couple of ILookup instances, then save it. When I load it back up, it’s all there just as you need it to be. Now, that is seriously impressive!

RavenDB & NServiceBus -

noreply@blogger.com (Sean Kearon) — Thu, 28 Jul 2011 20:17:00 +0000

The upcoming version 3.0 of everyone’s favourite service bus, NServiceBus, will now use RavenDB for saga persistence. This makes it even easier to work with sagas in NSB.
Very cool! Even better than that, it looks like RavenDB will be available for NServiceBus Express users too. You can read Udi’s comment here.
Big thanks to Ayende and Udi for getting these two elegant technologies together like this.

Mocking DbContext Entity Framework 4 Code First CTP5 with NSubstitute

noreply@blogger.com (Sean Kearon) — Sun, 27 Feb 2011 21:07:00 +0000

Take an Entity Framework 4 Code First model, something like this:

   1: public class Customer

   2: {

   3:    public int Id { get; set; }

   4:    public string Name { get; set; }

   5: }

6:

   7: public class CustomerContext : DbContext, ICustomerContext

   8: {

   9:    public DbSet<Customer> Customers { get; set; }

  11: }

I now want to write some tests and I'm going to mock the DbContext using NSubstitute. I first try something like this:

   1: [Test]

   2: public void can_mock_customer_context()

   3: {

   4:    var context = Substitute.For<CustomerContext>();

   5:    context.Customers.Returns(

   6:       new DbSet<Customer>(

   7:          new[]

   8:          {

   9:             new Customer {Name = "Sean"}

  10:          })

  11:       );

  12:    Assert.AreEqual(1, context.Customers.Count());

  13: }

The problem is that the DbSet constructor is internal (as of EF4 Code First CTP5). So, let's abstract our DB access to a simple interface and replace DbSet<T> with the IQueryable<T> interface, ending up with the below:

   1: public interface ICustomerContext

   2: {

   3:    IQueryable<Customer> Customers { get; set; }

   4: }

This interface can be implemented like so:

   1: public class CustomerContext : DbContext, ICustomerContext

   2:   {

   3:      public DbSet<Customer> Customers { get; set; }

   4:      IQueryable<Customer> ICustomerContext.Customers { get { return Customers; } }

   5:   }

Now all we need to do is to use an implementation of IQueryable<T> in our mock. I'm going to use EnumerableQuery<T> which gives me the following test that now passes:

   1: [Test]

   2: public void can_mock_customer_context()

   3: {

   4:    var context = Substitute.For<ICustomerContext>();

   5:    context.Customers.Returns(

   6:       new EnumerableQuery<Customer>(

   7:          new[]

   8:          {

   9:             new Customer {Name = "Sean"}

  10:          })

  11:       );

  12:    Assert.AreEqual(1, context.Customers.Count());

  13: }

  14:    }

I'm new to NSubstitute but it seem to be the lowest friction mocking library out there. Just perfect for use with Entity Framework 4 Code First - certainly the lowest friction ORM there is today!

Note that we could have used the repository pattern to wrap the DbContext instead of a simple interface, the approach is almost identical.

Update: Ro Miller has an alternative approach using fakes that does a better job of surfacing IDbSet. Check it out here: http://romiller.com/2010/09/07/ef-ctp4-tips-tricks-testing-with-fake-dbcontext/.

Package Manager With Source Download

noreply@blogger.com (Sean Kearon) — Thu, 17 Feb 2011 20:05:00 +0000

I was skinning up some code and I used my package manager of choice to add NLog to the project. All good, very easy and away I coded.

The project required a single DLL as an output. So, I thought hey – I’ll use Paul Stovell’s Tape to save using ILMerge in the build. Good plan, but after 5 minutes browsing the NLog source on GitHub it realised I was not sure how to find the version I needed. That’s fine, ILMerge is pretty easy to use so I used the build to save the day.

On the same day (today) I read this post about ReSharper 6 features and suddenly realised how powerful it would be for package managers to be able to give me the source, not just binaries. Now that’s a killer feature and would be even better if the source came with a single file option so I didn’t even have to run Tape.

Oh, please, soon…

A Better Deal

noreply@blogger.com (Sean Kearon) — Thu, 03 Feb 2011 01:19:00 +0000

Red Gate are now going to charge for Lutz Roeder’s Reflector. This tool has been free for it's life – more years than I care to remember. Its as much part of a software developer’s toolkit as a hammer is part of a builder’s toolkit.

I have dealt with Red Gate as part of a very small company and as part of a very large company. I am sorry to say that each time I have come away feeling less than happy. Any company that sends be a maintenance bill at the end of year one that exceeds my original purchase price isn't going to make me happy to deal with them!

Reading Red Gates’ pricing strategy, written by their co-founder, Neil Davidson, I struggle to believe their other CEO, Simon Galbraith, when he says how sorry he is about charging for Reflector. I just kept thinking that they just want my cash - like the other times I’ve dealt with them.

Maybe Galbraith and Davidson should go and listen to Seth Godin’s pricing advice. Maybe then I’d want to buy stuff from them!

35USD is good value for Reflector and I may have to buy a copy. I’d really just rather buy from another company and get a better deal.

Install the Full .Net 4 Framework with Tarma Installer

noreply@blogger.com (Sean Kearon) — Sat, 23 Oct 2010 14:12:00 +0000

If you haven’t seen Tarma InstallMate before, the you need to check this little beauty out. It’s a fully featured installer that have been using it in production for just under a year now and the end-user setup installer just drops out of the end of my build process – sweet!

There’s one thing that is very different with Tarma and all the other installers out there – Tarma doesn’t charge stupid rip-off money like all the other suppliers seem to like to do. You can get their top-of-the-range product for under $90USD per developer. Couple that with totally superb support, rock solid performance and a really rich feature set, Tarma’s a total winner!

Out of the box, Tarma has support for a number of prerequisites like .Net Framework, Access runtimes and Windows Installer. However, it doesn’t differentiate between the Full and Client Profiles for .Net 4 – if the Client Profile is detected then it will not install the full framework and I need to get the full framework onto my user’s machine.

Detecting the Installed Framework Version

To detect which version of the .Net Framework 4 has been installed, you need to check the presence of the following registry keys.

HKLM\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Client
HKLM\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full

More details on that here.

We can set up Tarma to do that easily, like this:

Read Registry Key into a Variable

Go to Symbolic Variables and add a new variable called IsFullDotnet4. Then use Tarma’s support for symbolic expressions to read whether the registry key exists by setting the new variable’s value to this:

<$rkaccess(<HKLM>\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full)>

It should now look like this:

Adjust Prerequisites Condition

Go to the prerequisites section and adjust the condition to install the .Net 4 Runtime by setting the condition to this:

NOT IsFullDotnet4

It should look something like this:

That’s all you need – Tarma will now upgrade .Net 4 Client Profile installations to the Full version.

Replacing Strings in XPObject.SetPropertyValue with Lambdas

noreply@blogger.com (Sean Kearon) — Mon, 04 Oct 2010 18:45:00 +0000

I came across a post on Aussie Alf’s blog today about removing magic strings from the persistent property setters in the XPO ORM from DevExpress.

The Aussie Alf blog is written by Michael Proctor who is a member of the DevExpress community DXSquad, specialising in XPO. The blog is a superb resource for any XPO developers and really worth reading. Michael is also a very active member on the DevExpress forums and may well come to your help with an XPO issue there.

XPO uses a classic INotifyPropertyChanged pattern and passes a string of the changed property name into SetPropertyValue method. You can see this below:

 public class Customer : XPObject
{
   private string _number;
   public string Number
   {
      get { return _number; }
      set { SetPropertyValue("Number", ref _number, value); }
   }
}
 

The problem with this approach is that the compiler can’t determine whether the string is correct or not, leaving you open to potential runtime errors. Michael’s solution to this to generate a helper class that can be used in the property setter and he has a Visual Studio plugin that generates and refreshes the helper class for you based on your domain model.

This is a great approach to the problem and you can read more about it on the homepage for Michael’s plugin, XPO_EasyFields.

Michael’s XPO_EasyFields plugin uses the free DXCore Visual Studio plugin from DevExpress. Personally, I use Resharper and don’t have DXCore installed, so I thought I would share my approach to removing the magic strings - I use a helper class and lambdas to do this. It looks like this:

 public class Customer : XPObject
{
   private string _number;
   public string Number
   {
      get { return _number; }
      set { SetPropertyValue(Property<Customer>.Name(x => x.Number), ref _number, value); }
   }
}
 

This relies on the use of a generic Property class and a helper method that gleans the property name from a Linq Expression. The property class looks like this:

 public static class Property<T>
{
   public static string Name(Expression<Func<T, object>> expression)
   {
      if (expression == null) throw new ArgumentNullException("expression");
      if (expression.Body is MemberExpression) return ((MemberExpression)expression.Body).Member.Name;
 
      if (expression.Body is UnaryExpression && ((UnaryExpression)expression.Body).Operand is MemberExpression)
      {
         return ((MemberExpression)((UnaryExpression)expression.Body).Operand).Member.Name;
      }
 
      throw new ArgumentException(string.Format("Could not get property name from expression of type '{0}'",
                                                expression.GetType()));
   }
}
 

The magic comes from translating the little lambda expression x => x.Name to a string. If I remember right, I originally based this on some code from Jeremy Miller, but there are various implementations out there. Here’s and elegant one from Paul Stovell that’s focused purely on INotifyPropertyChanged.

As Paul mentions in the above link, it’s worth noting that there is a performance hit when using this approach. Michael’s approach of generating the code does not have any performance hit. You may need to consider the performance issue if you have very high rates of properties being set.

I did some simple performance tests that show a 10-15x overhead with my approach compared to Michael’s. However, this only becomes relevant with a very large number of property sets. For my usage scenarios the added quality benefit outweighs the performance hit, but you will need to carefully consider your scenario.

Lastly, to take this further, and get an even tighter syntax, I add this helper method to my persistent classes:

 protected void Set<T>(Expression<Func<Customer, object>> property, ref T holder, T value)
{
   SetPropertyValue(Property<Customer>.Name(property), ref holder, value);
}
 

This allows the setter to be even more compact:

 private string _number;
public string Number
{
   get { return _number; }
   set { Set(x => x.Number, ref _number, value); }
}
 

The downside is that you need the helper method in each class. Down to taste that really, but I always go for the tighter syntax wherever possible!

You can get the code from bitbucket and browse the salient parts here.

Sometimes It Just Works

noreply@blogger.com (Sean Kearon) — Thu, 21 Jan 2010 23:11:00 +0000

Some things in life that just do what they say they will do and when this happens you get blown away.

VMware Workstation says it lets you use Visual Studio to debug an application that is running on a virtual machine. I used this recently and was blown away by how easy it was to set up and by how amazingly useful it was.

The story is that I released a new build for informal testing, but it could not be installed. I installed it onto a clean XP VM (yeah, I should have done that already…) and got the error myself. However, there was no error information coming back from the application as the failure was happening before the logging layer was instantiated.

I was stuck. I could reproduce, but had no other information to help. Then I remembered that VMware Workstation had the facility to debug apps running on VMs. So, I followed the instructions (yes, I was desperate enough to read the VMware help file!!) and set up a VM for remote debugging. This was pretty swift to achieve and I then started a debugging session on the VM from Visual Studio.

Almost immediately I could see what was happening: it was my bad – I’d just forgotten to include a third-party assembly with the build. My dev box was happily loading it from the GAC and so I couldn’t see I’d missed anything.

VMware Workstation just did what it said it would do. in doing so, it got me out of a sticky situation. Also, it says it has the ability to record and replay a debugging session…maybe next time, eh?

In the meantime, and whilst loving the things that go right, here’s a shot of the error from VS debugging on the VM:

Friendly OS Name from WMI

noreply@blogger.com (Sean Kearon) — Thu, 07 Jan 2010 19:24:00 +0000

When you want to find out what operating system your application is running on, System.Environment.OSVersion is not very readable. You can get a nice friendly name using WMI like this:

  1: private static string GetOSName()
  2: {
  3:    const string query = "SELECT * FROM Win32_OperatingSystem";
  4:    var searcher = new ManagementObjectSearcher(query);
  5:    var results = from x in searcher.Get().OfType<ManagementObject>()
  6:            select x.GetPropertyValue("Caption");
  7:    return results.Any() ? results.First().ToString() : "Unknown";
  8: }

This will give you something like "Microsoft® Windows Server® 2008 Enterprise ".

Cloud Computing – SMD Services

noreply@blogger.com (Sean Kearon) — Sat, 18 Apr 2009 08:10:00 +0000

Rinat Abdullin has recently put up an interesting post about cloud computing, along with another post as a response to a comment of mine. Rinat pointed out the benefits cloud scenarios bring when there is a need for distributed computing resources, highlighting Amazon’s recent announcement along with Microsoft’s offerings in that space.

I agree with Rinat that distributed computing scenarios are clearly winners for cloud computing. However, my view is that one of the critical success factors for the success of cloud computing will be developer adoption. If you have developers using your product it will succeed (as a cloud platform), if you don’t then…well, you get it! My view is that the larger organisations who already have their own infrastructure will certainly adopt cloud resources, but it will not be these organisation that will drive the adoption of cloud technologies. It will be the small to medium enterprises (SME) for whom the effort to host themselves is a large compared to their overall effort to stay in business.

What is going to drive SME uptake – having software that delivers business advantage. How does this get to them – by developers producing it for them. Making your cloud platform accessible and usable for developers will drive wider adoption.

In Rinat’s second post he mentions a scenario where if he had had a cloud platform like Azure available, cost could have been saved. He also outlines the basis for how cloud computing will reduce the overall costs of the adoption of a the provided in the cloud – the larger data centres selling their idle CPU cycles.

He then points out that there is fast evolving market for hosted developer environments where you can easily and cheaply access version control, wiki, issue tracker services, etc. In an earlier post I mentioned one such provider, WUSH, with whom I have had a positive experience throughout the last year in the smaller scale development work I do out of normal working hours.

It is this area – developer services – that I see as the key to making cloud computing ubiquitous. If you can provide developers with full-lifecycle support from your platform they will come in their droves. By full lifecycle, I mean support for planning, production, test and live all in an integrated set of cloud services.

As mentioned, there we see some support for planning and some aspects of production already out there (search for “hosted subversion”, take a look at Scrumy or Manymoon, etc.), and you can but cost efficient test and live environments (by renting your own server). But to get other aspects running, like a build or CI environment, involves setting it up yourself on a server you have rented yourself. However, doing that would not be using SaaS beyond having a server hosted in the cloud. Unfortunately, I know of no decently priced build service that for commercial projects.

What do I want to see? In the short term, I’m missing a ~~sensibly~~ cheaply priced build services for commercial projects (see James Kovac’s recent announcement of their new Team City service for OS projects). In the longer term I want to be able to have a fully hosted CI environment that prices me by disk and CPU usage.

The ultimate goal: Microsoft to host TFS and reduce the cost of adoption for SMDs (small to medium developers :) ) to the Team System versions of Visual Studio.

In the meantime, will I be using the current set of cloud services? Absolutely, both in my production processes as an SMD and for services that my clients will use. And, I am doing this for the the reasons Rinat has outlined!

Double Click to Open Visual Studio Solutions in Vista/2008

noreply@blogger.com (Sean Kearon) — Mon, 15 Dec 2008 20:15:00 +0000

For a while I have been running Visual Studio under Vista (x32) and now I’m using Workstation 2008 (very happily too!). I have UAC on, but have a policy setting to automatically elevate without showing a prompt. (I absolutely can’t live with the dialogs…see here and here for more info).

I have also Visual Studio set to run as administrator, and that’s where the problem starts: I have not been able to open solution files by double clicking them.

I am very grateful to “Sajeev Prasad / Arun Arcot” response to this post for the solution.

Basically, set both IDE and the loader (%programfiles%\Common Files\Microsoft Shared\MSEnv\VSLauncher.exe) to run as administrator and you can then double click to open solutions.

Thanks Sajeev and Arun!

ReSharper Plugins

noreply@blogger.com (Sean Kearon) — Mon, 15 Dec 2008 01:17:00 +0000

I’ve been using ReSharper since it’s first EAP release (late 2003 or early 2004, if I am right) and quite simply would not want to code without it.

ReSharper is a platform that can be easily extended and it is worth noting that there are a number of excellent plugins available that to make your ReSharper experience even better.

I mentioned Scout in an earlier post, but there are plugins for NHibernate, Gallio, xUnit and also for stuff like helping extract resources for internationalisation.

Check here for more details.

XML Editor - Liquid XML Studio

noreply@blogger.com (Sean Kearon) — Mon, 15 Dec 2008 00:44:00 +0000

I’ve just started using a great XML editor: Liquid XML Studio. I used it when creating some XSDs the other day. It’s really easy to use, and has a great graphical interface too.

The thing I really really like is the feature to generate an instance of the schema. The only other tool I’m aware of that does this is the BizTalk schema editor – but that’s a bit more of a heavyweight tool than I usually need!

It also has Visual Studio integration (with the visual editor), XPath expression builder, documentation generation and a web service browser. It’s not cheap, but there is a free feature limited Community Edition. There’s also the high end Developer Edition that adds a load of muscle for people working with more complex schemas, such as the OASIS schemas.

Joyful Reflections - ReSharper Scout

noreply@blogger.com (Sean Kearon) — Mon, 15 Dec 2008 00:21:00 +0000

I’ve just found an excellent ReSharper plugin called Scout. This lovely little beast will open Reflector when you choose Go to Declaration. The thing I really love is that Scout also takes care of loading the appropriate assembly in Reflector. I previously had to load the assembly in Reflector before I could browse it, which took time. Scout makes this process seamless.

All you have to do is right click and select Go to Declaration:

Then you get taken to the item in Reflector and the correct assembly is loaded:

Scout will also take you to the Dotnet source code – but I haven’t got around to that yet! You can find lots of other ReSharper plugin goodness here.

Update on XPO and One-Way Associations

noreply@blogger.com (Sean Kearon) — Sat, 29 Nov 2008 07:12:00 +0000

I stated in a previous post that XPO would be supporting one-way multi associations. Unfortunately, this is now not the case. At the time I wrote the previous post, Developer Express had marked my request as accepted, but have now changed that to rejected.

The guys at Developer Express support say that having a two-way association in your object model is fundamental to XPO multiple associations and, as my request was only to simplify code, the feature is now not to be implemented. The bottom line from them was:

"To sum it up, we think that the current design of one-to-many associations in XPO is reliable and transparent. We are not going to change it, unless we have strong arguments for doing so."

Well, although it's a shame that it's not going to be implemented, you can't argue than that!

You can find the request thread here (but may need to register). If you still want to keep your XPO code clean, you can use some IL enhancement with PostSharp - details here.