Rock Solid Knowledge Blogs"

formelement is null in ASP.Net MVC Validation

I'm buidling a really simple MVC application as a demo and I've been getting a Javascript "formelement is null" error. A quick google throws up a bunch of 'make sure you add the correct .js files" but I had all those

Turns out that I had added a Master page using a template and thet template contains a

element. This screwa up the validation. Removing that tag fixes the problem

Software Architect Conference 2010

I’m speaking at Software Architect 2010 in October. I’m going to be delivering two sessions on Windows Workflow Foundation 4.0: the first explains the basic architecture and looks at using workflow as a Visual Scripting environment to empower business users. The second looks at building big systems with workflow concentrating on the WCF integration features.

In addition to that I’ll be delivering two all-day workshops with Andy Clymer: Building Applications the .NET 4.0 Way and Moving to the Parallel Mindset with .NET 4.0. The first of these will take a number of new features of .NET 4.0 and show how they can be combined to create compelling applications. The second will look at the Parallel Framework Extensions (PFx) introduced in .NET 4.0 examining both the rich functionality of the library, how it can be best leveraged avoiding common parallel pitfalls and finally looking at patterns that aid parallelisation of your code

Unity, Multiple Constructors and Configuration

I’ve been working with the Unity IoC container from Microsoft Patterns and Practices recently. Its mostly straightforward as IoC containers go but one thing had me puzzled for a while as its not really documented or blogged as far as I can see; so I decided to blog it so hopefully others looking will stumble across this article

Lets start off with a simple example: I have two interfaces: IService and IRepository that live in the Interfaces class library

 1: public interface IService

 2: {

 3: void DoWork();

 4: }

 1: public interface IRepository

 2: {

 3: string GetStuff();

 4: }

I also have two implementations in the Services class library: MyRepository

 1: public class MyRepository
: IRepository

 2: {

 3: public string GetStuff()

 4: {

 5: return "TADA!!";

 6: }

 7: }

and MyService

 1: public class MyService
: IService

 2: {

 3: private IRepository
repository;

4:

 5: public MyService(IRepository
repository)

 6: {

 7: this.repository
= repository;

 8: }

 9: public void DoWork()

 10: {

 11: Console.WriteLine(repository.GetStuff());

 12: }

 13: }

Notice that MyService needs an IRepository to do its work. Now the idea here is I’m going to wire this together via dependency injection and the Unity IoC container. So I have my application

 1: class Program

 2: {

 3: static void Main(string[]
args)

 4: {

 5: UnityContainer
container = new UnityContainer();

 6: UnityConfigurationSection
section = (UnityConfigurationSection)ConfigurationManager.GetSection("unity");

 7: section.Configure(container);

8:

 9: IService
svc = container.Resolve<IService>();

10:

 11: svc.DoWork();

 12: }

 13: }

Notice as we’re using IoC that there are no hard coded dependencies – everything is wired up via the container. However, there must be some information about how the interfaces map to concrete types and this is in the config file

 1: <configuration>

 2: <configSections>

 3: <section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection,Microsoft.Practices.Unity.Configuration"/>

 4: </configSections>

5:

 6: <unity>

 7: <typeAliases>

 8: <!--
Lifetime Managers -->

 9: <typeAlias alias="singleton" type="Microsoft.Practices.Unity.ContainerControlledLifetimeManager"/>

10:

 11: <!--
Interfaces -->

 12: <typeAlias alias="IService" type="Interfaces.IService,Interfaces"/>

 13: <typeAlias alias="IRepository" type="Interfaces.IRepository,Interfaces"/>

14:

 15: <!--
Implementations -->

 16: <typeAlias alias="service" type="Services.MyService,
Services"/>

 17: <typeAlias alias="repository" type="Services.MyRepository,
Services"/>

18:

 19: </typeAliases>

 20: <containers>

 21: <container>

 22: <types>

 23: <type type="IService" mapTo="service">

 24: <lifetime type="singleton"/>

 25: </type>

 26: <type type="IRepository" mapTo="repository">

 27: <lifetime type="singleton"/>

 28: </type>

 29: </types>

 30: </container>

 31: </containers>

 32: </unity>

 33: </configuration>

Now all of this works fine and is simple Unity stuff. We use constructor injection to get the repository implementation into the service constructor. However, I’ve decided the service needs a timeout that I will generally configure in the config file. However to make Unit Testing simple I’ll add another constructor to MyService so I can pass a specific timeout

 1: public class MyService
: IService

 2: {

 3: private IRepository
repository;

 4: TimeSpan
timeout;

5:

 6: public MyService(IRepository
repository, TimeSpan timeout)

 7: {

 8: this.timeout
= timeout;

 9: }

10:

 11: public MyService(IRepository
repository)

 12: {

 13: this.repository
= repository;

 14: timeout
= GetTimeoutFromConfig();

 15: }

16:

 17: private TimeSpan
GetTimeoutFromConfig()

 18: {

 19: return default(TimeSpan);

 20: }

21:

 22: public void DoWork()

 23: {

 24: Console.WriteLine(repository.GetStuff());

 25: }

 26: }

Now I try to run the application and I get a pretty ugly error

Unhandled Exception: Microsoft.Practices.Unity.ResolutionFailedException: Resolution of the dependency failed,
type = "Interfaces.IService", name = "(none)".
Exception occurred while: while resolving.
Exception is: InvalidOperationException - The type Int32 cannot be constructed.
You must configure the container to supply this value. >

Now that’s weird – I have no types that take an Int32! This is caused by Unity’s default behavior where it will try to resolve on the constructor with the most parameters (on the basis that this one will have the most dependencies that can be injected). It tried to resolve the TimeSpan and so looks at the TimeSpan and tries to resolve its constructor which can take an Int32. I actually want to tell it to use a different constructor and I can do this in two ways: annotate the constructor I want to use with the [InjectionConstructor] attribute

 1: [InjectionConstructor]

 2: public MyService(IRepository
repository)

 3: {

 4: this.repository
= repository;

 5: timeout
= GetTimeoutFromConfig();

 6: }

But personally I don’t like this. It forces the services assembly to take a dependency on Unity and the service has knowledge about how its being constructed. What I really want to do is specify this in config. This isn’t very well documented from what I can see but what you do it specify the constructor and how to resolve the parameters against the type mapping in the config – i.e.

 1: <type type="IService" mapTo="service">

 2: <lifetime type="singleton"/>

 3: <constructor>

 4: <param name="repository">

 5: <dependency/>

 6: </param>

 7: </constructor>

 8: </type>

As well as specifying dependencies you can also give explicit values by using <value/> instead of <dependency/>. This model I think is a lot cleaner than the attribute approach.

Windows AppFabric Hits the Streets

Announced today at TechEd – Windows AppFabric is now available

http://blogs.msdn.com/b/endpoint/archive/2010/06/07/windows-server-appfabric-now-generally-available.aspx

Visual Studio 2010 Power Tools

The Visual Studio 2010 Power Tools have just been released. There’s all sorts of goodness in here: new flexible tab handling in the VS shell (vertical tab groups, tabs grouped by project, dropping of rarely used tabs, etc); a new searchable Add Reference dialog; new editor enhancements to make navigation easier and much more

I’ve been playing with it for the last couple of hours and its very neat. Of course I don’t use Resharper or CodeRush (I use too many machines I don’t control to become dependent on them) so some of these features may be available in those tools. But for me the power tools are a welcome addition to the IDE

Software Architecture 2010

Myself and other Rock Solid Knowledge guys have had various talks accepted for Software Architecture conference this October in London.

Rich and myself will be spending a day talking about how to use various bits of .NET 4 technology to build a MVC, WF and Entity Framework based application. The aim to build the app live, so you really get to see how this tech actually ticks.

Through out the week I’ll be doing stuff on Patterns, and Parallel programming.

Finishing the week with another day with Rich talking about parallel programming, all using the latest bits of .NET 4.

Hopefully see you there…

Devweek 2011

Just heard that Dev Week in London is going to run 14th to 18th March 2011. Rock Solid Knowledge will be submitting a variety of talks…If you have some ideas let us know and we will do our best to accommodate.

And yep I’m sure Dr Rock Man will be back for the drop in consultations.

Rock Solid Knowledge Screencasts now Available via iTunes

Rock Solid Knowledge on iTunes is live! We’ve taken the feed to our free screencasts and they are now available through iTunes via the following link

http://itunes.apple.com/gb/podcast/rock-solid-knowledge-screencasts/id365244375

Now you can watch them on the move

Demos from DevWeek 2010

Thanks to everyone who attended any of the Rock Solid Knowledge sessions at DevWeek we now have all our demos available for download

DevWeek 2010

Had a great time again at DevWeek 2010.

All my demos are uploaded to our conference page.

It was the first year we ran our “Ask the Doctor” booth for all those that dropped in I hope you found the advice useful…we certainly had a great time digging into interesting issues, from unit testing, Entity Framework, WCF and general architecture issues..

Demos from DevWeek 2010

Thanks to everyone who attended my sessions at DevWeek 2010. I’ve now uploaded the demos which you can find at the following locations

A Day of .NET 4.0 Demos

Windows Workflow Foundation 4.0 Demos

Creating WCF Services using WF4 Demos

I’ll be around for the rest of the conference so drop by for a chat at our developer clinic in the exhibition area

EF4 And Repository Pattern

Just released a screencast on one possible way to implement the repository pattern using EF4. I’ve been very down on EF over the past year or so, but its nice at last to see it actually starting to be usable.

You can listen to this screencast or other RSK screencasts here

Using advanced filters for custom routing logic in the Routing Service

In my last post I pointed to a screencast I had recorded that showed how to create a custom message filter to plug your own logic into the WCF 4.0 Routing Service. However, the simple custom filter is only the start – you can actually take control of part of the routing table which allows you to make global decisions about which filters match a particular request. On that basis I have created another screencast that shows how to build one of these more complex custom filters. in this case I use the example of a round robin load balancer where you can use a file on the file system to indicate whether a specific endpoint should be considered part of the load balancing algorithm

You can find this last in the series of screencasts on the routing service, along with all the others here, on the Rock Solid Knowledge site

http://rocksolidknowledge.com/ScreenCasts.mvc

Using Custom Message Filters with the Routing Service

I’ve just uploaded a new screencast on the the Rock Solid Knowledge site. This one shows you how to plug your own routing logic into the new Routing Service that is part of WCF 4.0. It uses a custom message filter that can be used to supplement the existing set of filters such as matching on XPath and Action.

You can find the screencast (along with the previous ones in the series) here

http://www.rocksolidknowledge.com/ScreenCasts.mvc

Data Dependent Routing with the Routing Service

Continuing my screencast series on the Routing Service in WCF 4.0, I have just uploaded one on Data Dependent Routing

You can get to the latest screencast (and all of the others) here http://rocksolidknowledge.com/ScreenCasts.mvc

Failover and Multicast with the Routing Service

I have just published my second screencast on one of the new features of WCF 4.0 – the Routing Service. This screencast focuses on enabling multicast and failover with the Routing Service

You can get to the screencast from here http://rocksolidknowledge.com/ScreenCasts.mvc

Demos from BASTA!

Thanks to everyone who attended my two sessions at BASTA! – another thoroughly enjoyable conference. I’ve uploaded the demos

What’s new in Workflow 4.0 – this includes the application with the rehosted designer

Building WCF services with Workflow 4.0

Creating Rich Composite Activities

I my last post I showed that creating a custom composite activity (one that can have one or more children) requires deriving from NativeActivity. The Retry activity that I showed was fairly simple and in particular didn’t try to share data with its child. There appears to be a catch-22 in this situation when it comes to overriding CacheMetadata: if I add a Variable to the metadata (AddVariable) then it can be used exclusively by its children – i.e. the activity itself can’t manipulate the state; if I add a variable as implementation data to the metadata (AddImplementationVariable) then the children cant see it as its seen as purely used for this activities implementation. How then do we create data that can be both manipulated by the activity and accessed by the parent?

The secret to achieving this is a feature called ActivityAction - Matt Winkler talks about it here. The idea is that I can bind an activity to one or more parent defined pieces of data then schedule the activity where it will have access to the data. Its probably best to show this with an example so I have written a ForEachFile activity that you give a directory and then it passes its child the file name of each file in the directory in turn. I’ll show the code in its entirety and then walk through each piece in turn

 1: [ContentProperty("Body")]

 2: [Designer(typeof(ForEachFileDesigner))]

 3: public class ForEachFile
: NativeActivity, IActivityTemplateFactory

 4: {

 5: public InArgument<string>
Directory { get; set; }

6:

 7: [Browsable(false)]

 8: public ActivityAction<string>
Body { get; set; }

9:

 10: private Variable<IEnumerator<FileInfo>>
files = new Variable<IEnumerator<FileInfo>>("files");

11:

 12: protected override void CacheMetadata(NativeActivityMetadata
metadata)

 13: {

 14: metadata.AddDelegate(Body);

15:

 16: RuntimeArgument
arg = new RuntimeArgument("Directory", typeof(string),
ArgumentDirection.In);

 17: metadata.AddArgument(arg);

18:

 19: metadata.AddImplementationVariable(files);

 20: }

 21: protected override void Execute(NativeActivityContext
context)

 22: {

 23: DirectoryInfo
dir = new DirectoryInfo(Directory.Get(context));

24:

 25: IEnumerable<FileInfo>
fileEnum = dir.GetFiles();

 26: IEnumerator<FileInfo>
fileList = fileEnum.GetEnumerator();

 27: files.Set(context,
fileList);

28:

 29: bool more
= fileList.MoveNext();

30:

 31: if (more)

 32: {

 33: context.ScheduleAction<string>(Body,
fileList.Current.FullName, OnBodyComplete);

 34: }

 35: }

36:

 37: private void OnBodyComplete(
NativeActivityContext context, ActivityInstance completedInstance)

 38: {

 39: IEnumerator<FileInfo>
fileList = files.Get(context);

 40: bool more
= fileList.MoveNext();

41:

 42: if (more)

 43: {

 44: context.ScheduleAction<string>(Body,
fileList.Current.FullName, OnBodyComplete);

 45: }

46:

 47: }

48:

 49: #region IActivityTemplateFactory
Members

 50: public Activity
Create(DependencyObject target)

 51: {

 52: var
fef = new ForEachFile();

 53: var
aa = new ActivityAction<string>();

 54: var
da = new DelegateInArgument<string>();

 55: da.Name
= "item";

56:

 57: fef.Body
= aa;

 58: aa.Argument
= da;

59:

 60: return fef;

 61: }

 62: #endregion

 63: }

Ok lets start with the core functionality then we’ll look at each of the pieces that help make this fully usable. As you can see the class derives from NativeActivity and overrides CacheMetadata and Execute – we’ll look at their implementations in a minute. There are three member variables in the class: the InArgument<string> for the directory; an implementation variable to hold the iterator as we move through the files in the directory; the all important ActivityAction<string> which we will use to pass the current file name to the child activity.

Lets look at CacheMetadata more closely. Because we want to do interesting things with some of the state the default implementation won’t work so we override it. As we don’t call the base class version we need to specify how we use all of the state. We add the ActivityAction as a delegate, we bind the Directory argument to a RuntimeArgument and specify the iterator as an implementation variable – we don’t want the child activity to have access to that directly.

Next lets look at Execute. The first couple of lines are nothing unusual – we get the directory and get hold of the list of files. Now we have to store the retrieved iterator in the implementation variable, fileList. We move to the first file in the iteration, if it returns false the list was empty so as long as MoveNext returned true we want to schedule the child activity passing the current file. To do this we use the ScheduleAction<T> member on the context. However, because we’re going to process each one sequentially, we also need to know when the child is finished so we pass a completion callback, OnBodyComplete.

Now in OnBodyComplete we simply get the iterator, move to the next item in the iteration and as long as we’re not finished iterating re-schedule the child again passing the new item in the iteration.

That really is the “functional” part of the activity – everything else is there to support the designer. So why does the designer need help? Well lets look at what we would have to do to build this activity correctly if we were going to execute it from main

 1: Activity
workflow = new ForEachFile

 2: {

 3: Body
= new ActivityAction<string>

 4: {

 5: Argument
= new DelegateInArgument<string>

 6: {

 7: Name
= "item",

 8: },

 9: Handler
= new WriteLine

 10: {

 11: Text
= new VisualBasicValue<string>("item")

 12: }

 13: },

 14: Directory
= @"c:\windows"

 15: };

As you can see, its not a matter of simply creating the ForEachFile, we have to build the internal structure too – something needs to create that structure for the designer - this is the point of IActivityTemplateFactory. When you drag an activity on to the design surface normally it just creates the XAML for that activity. However, before it does that it does a speculative cast for IActivityTemplateFactory and if the activity supports that it calls the interface’s Create method instead and serializes the resulting activity to XAML.

So going back to the ForEachFile activity, you can see it implements IActivityTemplateFactory and therefore, as far as the designer is concerned, this is the interesting functionality – lets take a look at the Create method.We create the ForEachFile and wire an ActivityAction<string> to its Body property. ActivityAction<string> needs a slot to store the data to be presented to the child activity. This is modelled by DelegateArgument<string> and this gets wired to the Argument member of the ActvityAction. We also name the argument as we want a default name for the state so the child activity can use it. Notice, however, we don’t specify the child activity itself (it would be a pretty useless composite if we hard coded this). The child will be placed on the Handler property of the ActivityAction but that will be done in the ActivityDesigner using data binding.

Before we look at the designer lets highlight a couple of “polishing” features of the code: the class declared a ContentProperty via an attribute – that just makes the XAML parsing cleaner as the child doesn’t need to be specified using property element syntax; the Body is set to non-browsable – we don’t want the activities user to try to set this value in the property grid.

OK on to the designer. If you read my previous article there are a couple of new things here. Lets look at the markup – again there is no special code in the code behind file, everything is achieved using data binding

 1: <sap:ActivityDesigner x:Class="ActivityLib.ForEachFileDesigner"

 2: xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

 3: xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

 4: xmlns:s="clr-namespace:System;assembly=mscorlib"

 5: xmlns:conv="clr-namespace:System.Activities.Presentation.Converters;assembly=System.Activities.Presentation"

 6: xmlns:sap="clr-namespace:System.Activities.Presentation;assembly=System.Activities.Presentation"

 7: xmlns:sapv="clr-namespace:System.Activities.Presentation.View;assembly=System.Activities.Presentation"

 8: xmlns:me="clr-namespace:ActivityLib">

 9: <sap:ActivityDesigner.Resources>

 10: <conv:ArgumentToExpressionConverter x:Key="expressionConverter"/>

 11: </sap:ActivityDesigner.Resources>

12:

 13: <Grid>

 14: <Grid.RowDefinitions>

 15: <RowDefinition Height="Auto"/>

 16: <RowDefinition Height="*"/>

 17: </Grid.RowDefinitions>

18:

 19: <StackPanel Orientation="Horizontal" Margin="2">

 20: <TextBlock Text="For
each file "/>

 21: <TextBox Text="{Binding
ModelItem.Body.Argument.Name}" MinWidth="50"/>

 22: <TextBlock Text="
in "/>

 23: <sapv:ExpressionTextBox Expression="{Binding
Path=ModelItem.Directory, Converter={StaticResource expressionConverter}}"

 24: ExpressionType="s:String"

 25: OwnerActivity="{Binding
ModelItem}"/>

 26: </StackPanel>

 27: <sap:WorkflowItemPresenter Item="{Binding
ModelItem.Body.Handler}"

 28: HintText="Drop
activity"

 29: Grid.Row="1" Margin="6"/>

30:

 31: </Grid>

32:

 33: </sap:ActivityDesigner>

Here’s what this looks like in the designer

So the TextBox at line 21 displays the argument name that our IActivityTemplateFactory implementation set up. The ExpressionTextBox is bound to the directory name but allows VB.NET expressions to be used. The WorkflowItemPresenter is bound to the Handler property of the Body ActivityAction, This designer is then associated with the activity using the [Designer] attribute.

So as you can see, ActivityAction and IActivityTemplateFactory work together to allow us to build rich composite activities with design time support

NativeActivity – A Tricky Beast

I’m writing Essential Windows Workflow Foundation 4.0 with Maurice for DevelopMentor. One of the things that I think is less than obvious is the behavior of NativeActivity.

What is NativeActivity I hear you ask? Well there are a number of models for building custom activities in WF4. Most “business” type custom activities will be built using a declarative model in XAML by assembling building blocks graphically. However, what if you are missing a building block? At this point you have to fall back to writing code and there are three options for your base class when writing an activity in code:

CodeActivity
You use CodeActivity when you have a simple synchronous activity. All work happens in Execute and it has no child activities

AsyncCodeActivity
This is new to WF4. Here you have the ability to implement the async pattern (BeginExecute / EndExecute) to perform short lived async operations where you do not want the workflow persisted (e.g. an async WebRequest)

NativeActivity
This gives you full access to the power of the workflow execution engine. However, in the words of Spiderman’s Uncle, “with great power comes great responsibility”. NativeActivity can be a bit tricky so that is what this article is about

I’m going to walk through the code for a Retry activity – where a child activity can be rerun a number of times upon failure. The activity has two InArguments: MaxRetries and RetryDelay. MaxRetries says how many times you will retry the child before giving up. RetryDelay says how long to wait between retries. We could use a Thread.Sleep to do the delay but this would not be good for the workflow engine: we block a thread it could use and there is no way for the engine to persist the workflow – what if we wanted to retry in 2 days? So instead, as part of our implementation, we’ll use a Delay activity.

Now to explain the code we have to take a slight diversion and talk about the relationship between Activity, ActivityInstance and ExecutionContext. I talked about is a while back here when the PDC CTP first came out (that’s what the reference to some base class called WorkflowElement is about) but to expand a little: The Activity is really just a template containing the code to execute for the activity. The ActivityInstance is the actual thing that is executing. It holds the state for this instance of the activity template. Now we need a way to bind the template code to the currently running instance of the activity and this is the role of the ExecutionContext. If you are using a CodeActivity base class then most of this is hidden from you except that you have to access arguments by passing in the ExecutionContext. However, with NativeActivity you have to get more directly involved with this model.

Now how does the workflow engine know what data you need to store in the ActivityInstance? Well it turns out you need to tell it. NativeActivity has a virtual method called CacheMetadata (this post talks about it to some degree). The point being that the activity has to register all of the “stuff” that it wants to use during its execution. Now the base class implementation will do some fairly reasonable default actions but it cannot know, for example, that part of your functionality is there purely for implementation details and should not be public. Therefore, you will often override this when you create a NativeActivity

So without more ado – here’s the code for the Retry activity. I’ll then walk through it

 1: [Designer(typeof(ForEachFileDesigner))]

 2: public class Retry
: NativeActivity

 3: {

 4: public InArgument<int>
MaxRetries { get; set; }

 5: public InArgument<TimeSpan>
RetryDelay { get; set; }

 6: private Delay
Delay = new Delay();

7:

 8: public Activity
Body { get; set; }

9:

 10: Variable<int>
CurrentRetry = new Variable<int>("CurrentRetry");

11:

 12: protected override void CacheMetadata(NativeActivityMetadata
metadata)

 13: {

 14: metadata.AddChild(Body);

 15: metadata.AddImplementationVariable(CurrentRetry);

16:

 17: RuntimeArgument
arg = new RuntimeArgument("MaxRetries", typeof(int),
ArgumentDirection.In);

 18: metadata.Bind(MaxRetries,
arg);

 19: metadata.AddArgument(arg);

20:

 21: Delay.Duration
= RetryDelay;

22:

 23: metadata.AddImplementationChild(Delay);

 24: }

25:

 26: protected override void Execute(NativeActivityContext
context)

 27: {

 28: CurrentRetry.Set(context,
0);

29:

 30: context.ScheduleActivity(Body,
OnFaulted);

 31: }

32:

 33: private void OnFaulted(NativeActivityFaultContext
faultContext, Exception propagatedException, ActivityInstance propagatedFrom)

 34: {

 35: int current
= CurrentRetry.Get(faultContext);

 36: int max
= MaxRetries.Get(faultContext);

37:

 38: if (current
< max)

 39: {

 40: faultContext.CancelChild(propagatedFrom);

 41: faultContext.HandleFault();

 42: faultContext.ScheduleActivity(Delay,
OnDelayComplete);

 43: CurrentRetry.Set(faultContext,
current + 1);

 44: }

 45: }

46:

 47: private void OnDelayComplete(NativeActivityContext
context, ActivityInstance completedInstance)

 48: {

 49: context.ScheduleActivity(Body,
OnFaulted);

 50: }

 51: }

So lets look at the code: first the class derives from NativeActivity (we’ll come to the designer later). This means I want to do fancy things like have child activities or perform long running asynchronous work. Next we see the two InArguments that are passed to the Retry. The Delay is an implementation detail of how we will pause between retry attempts and the Body property is where the activity we are going to retry lives. Finally we have a Variable, CurrentRetry, where we store how many retry attempts we have made. That is the data in the class but remember we need to tell the workflow engine about what we need to store and why – this is the point of CacheMetadata (I read this method name as “here is the metadata for the cache” rather than “I am going to cache some metadata”)

In CacheMetadata the first thing we do is specify that the Body is our child activity. Next we tell the engine that we want to be able to get hold of the CurrentRetry but that its only there for our implementation – we’re not expecting the child activity to try to make use of it. The next 3 lines (17-19) seem a little strange but essentially we’re saying that the MaxRetries argument needs to be accessed over the whole lifetime of the ActivityInstance so we need a slot for that. We next configure out Delay activity passing the RetryDelay as its duration (this is how long we want to wait between retries). Finally we add the Delay, not as a normal child, but as an implementation detail.

OK, Execute is pretty simple – we initialize the CurrentRetry and then schedule the Body. But, because we want to retry on failure, we also pass in a fault handler (OnFaulted)

OnFaulted does the main work. It fires if the child fails. So it checks to see if we have exceeded the retry count and if not retries the Body activity. However, it doesn’t do this directly, first it tells the context that it has handled the error – it also, strangely has to cancel the current child (which is odd as its already faulted) – Maurice talks about this oddity here. Next it schedules the Delay as we have to wait for the retry delay and wires up a completion handler (OnDelayComplete) so we know when the delay is finished. Finally it updates the CurrentRetry.

OnDelayComplete simply reschedules the Body activity, remembering to pass the fault handler again in case the activity fails again.

Oh one thing I said I’d come back to – the designer. I have written a designer to go with this (designers in WF4 are WPF based). The XAML for this is here:

 1: <sap:ActivityDesigner x:Class="WordActivities.ForEachFileDesigner"

 2: xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

 3: xmlns:s="clr-namespace:System;assembly=mscorlib"

 4: xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

 5: xmlns:sap="clr-namespace:System.Activities.Presentation;assembly=System.Activities.Presentation"

 6: xmlns:sapv="clr-namespace:System.Activities.Presentation.View;assembly=System.Activities.Presentation"

 7: xmlns:conv="clr-namespace:System.Activities.Presentation.Converters;assembly=System.Activities.Presentation"

 8: mc:Ignorable="d"

 9: xmlns:d="http://schemas.microsoft.com/expression/blend/2008"

 10: xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" >

 11: <sap:ActivityDesigner.Resources>

 12: <conv:ArgumentToExpressionConverter x:Key="expressionConverter"/>

 13: </sap:ActivityDesigner.Resources>

 14: <Grid>

 15: <Grid.RowDefinitions>

 16: <RowDefinition Height="Auto"/>

 17: <RowDefinition Height="Auto"/>

 18: <RowDefinition Height="*"/>

 19: </Grid.RowDefinitions>

 20: <Grid.ColumnDefinitions>

 21: <ColumnDefinition Width="Auto"/>

 22: <ColumnDefinition Width="*"/>

 23: </Grid.ColumnDefinitions>

24:

 25: <TextBlock Grid.Row="0" Grid.Column="0" Margin="2">Max.
Retries:</TextBlock>

 26: <sapv:ExpressionTextBox Expression="{Binding
Path=ModelItem.MaxRetries, Converter={StaticResource expressionConverter}}"

 27: ExpressionType="s:Int32"

 28: OwnerActivity="{Binding
ModelItem}"

 29: Grid.Row="0" Grid.Column="1" Margin="2"/>

30:

 31: <TextBlock Grid.Row="1" Grid.Column="0" Margin="2">Retry
Delay:</TextBlock>

 32: <sapv:ExpressionTextBox Expression="{Binding
Path=ModelItem.RetryDelay, Converter={StaticResource expressionConverter}}"

 33: ExpressionType="s:TimeSpan"

 34: OwnerActivity="{Binding
ModelItem}"

 35: Grid.Row="1" Grid.Column="1" Margin="2"/>

36:

 37: <sap:WorkflowItemPresenter Item="{Binding
ModelItem.Body}"

 38: HintText="Drop
Activity"

 39: Margin="6"

 40: Grid.Row="2"

 41: Grid.Column="0"

 42: Grid.ColumnSpan="2"/>

43:

 44: </Grid>

 45: </sap:ActivityDesigner>

There is no special code behind, everything is done via databinding.

So as you can see, there are a lot of pieces that need to be put into place for something that seems fairly simple. The critical issue is getting the implementation of CacheMetadata correct – once you have identified all of the pieces of data you need stored the rest falls out nicely.

EF4 Self Tracking Entities – the new DataSet?

A while back I wrote a blog post about DataSets and why you shouldn’t use them on service boundaries. The fundamental issues are:

No non-.NET client has any idea what the data looks like you are sending them
Hidden, non essential data is being passes up and down the wire
Your client gets coupled to the shape of your data (usually a product of the Data Access Layer)

So when I saw that Entity Framework 4.0 supports Self Tracking Entities (STEs) I was interested to see how they would work – after all, automated change tracking is one of the reasons people wanted to use DataSets in service contracts. The idea is that as you manipulate the state the object itself tracks the changes to properties and whether it has been created new or marked for deletion. It does this by implementing an interface called IObjectWithchangeTracker which is then used by the ObjectContext to work out what needs to be done in terms of persistence. There is an extension method on the ObjectContext called ApplyChanges which does the heavy lifting.

The Entity Framework team has released a T4 Template to generate these STEs from an EDMX file and the nice thing is that the generated entities themselves have no dependency on the Entity Framework. Only the generated context class has this dependency and, so the story goes, the client needs to know nothing about Entity Framework, only the service does. The client, and the entities, remain ignorant of the persistence model. For this reason STEs have been touted as a powerful tool in n-tier based architectures

All of this seems almost too good to be true … and unfortunately it is.

To understand what the issue is with STEs we have to remember what two of the main goals of Service based systems are:

Support heterogeneous systems – the service ecosystem is not bound to one technology
Decoupling – to ensure changes in a service do not cascade to consumers of the service for technical reasons (there may obviously be business reasons why we might want a change in a service to effect the consumers such as changes in law or legislation)

So to understand the problem with STEs we need to look at the generated code.Here’s the model I’m using:

Now lets look at the T4 Template generated code for, say, the OrderLine

[DataContract(IsReference = true)]

[KnownType(typeof(Order))]

public partial class OrderLine:
IObjectWithChangeTracker, INotifyPropertyChanged

    #region Primitive
Properties

    [DataMember]

    public int id

        get { return _id;
}

set

            if (_id
!= value)

                ChangeTracker.RecordOriginalValue("id",
_id);

                _id = value;

                OnPropertyChanged("id");

    private int _id;

    //
more details elided for clarity

A few things to notice: firstly this is a DataContract and therefore is designed to be used on WCF contracts – that is its intent; secondly a bit of work takes place inside the generated property setters. The property setters check to see if the data is actually changed, then it records the old value and raises calls OnPropertyChanged to raise the PropertyChanged event (defined on INotifyPropertyChanged). Lets have a look inside OnPropertyChanged:

protected virtual void OnPropertyChanged(String
propertyName)

     if (ChangeTracker.State
!= ObjectState.Added && ChangeTracker.State != ObjectState.Deleted)

         ChangeTracker.State = ObjectState.Modified;

     if (_propertyChanged
!= null)

         _propertyChanged(this, new PropertyChangedEventArgs(propertyName));

Ok so maybe a bit more than raising the event. It also marks the object as modified in the ChangeTracker. The ChangeTracker state is partly how the STE serializes its self tracked changes. It is this data that is used by the ApplyChanges extension method to work out what has changed. So the thing to remember here is that the change tracking is performed by code generated into the property setters.

Well the T4 Template has done its work so we create our service contract using these conveniently generated types and the client uses metadata and Add Service Reference to build its proxy code. It gets the OrderLine from the service, updates the quantity and sends it back. The service calls ApplyChanges on the context and then saves the changes and … nothing changes in the Database. What on earth went wrong?

At this point we have to step back and think about what those types we use in service contracts are actually doing. Those types are nothing more than serialization helpers – to help us bridge the object world to the XML one. The metadata generation uses the type definition and the attribute annotations to generate a schema (XSD) definition of the data in the class. Notice we’re only talking about data – there is no concept of behavior. And this is the problem When the Add Service Reference code generation takes place its based on the schema in the service metadata – so the objects *look* right, just the all important code in the property setters is missing. So you can change the state of entities in the client and the service will never be able to work out if the state has changed – so changes don’t get propagated to the database.

There is a workaround for this problem. You take the generated STEs and put them in a separate assembly which you give to the client. Now the client has all of the change tracking code available to it, changes get tracked and the service can work out what has changed and persist it.

But what have we just done? We have forced the client to be .NET. Not only that, we’ve probably compiled against .NET 4.0 and so we are requiring the client to be .NET 4.0 aware – we might as well have taken out a dependency on Entity Framework 4.0 in the client at this point. In addition, changes I make to the EDMX file are going to get reflected in the T4 generated code – I have coupled my client to my data access layer. Lets go back to the problems with using DataSets on service boundaries again. We’re back where we pretty much started – although the data being transmitted is more controlled.

So STEs at first glance look very attractive, but in service terms they are in fact similar to using DataSets in terms of the effect on the service consumer. So what is the solution? We’ll we’re back with our old friends DTOs and AutoMapper. To produce real decoupling and allow heterogeneous environments we have to explicitly model the *data* being passed at service boundaries. How this is patched this into our data access layer is up to the service. Entity Framework 4.0 certainly improves matters here over 1.0 as we can use POCOs which aid testability and flexibility of our service

Dr Rockman is IN!

I’ve just noticed that Andy has blogged about our drop in clinic we are running at DevWeek 2010. All of the Rock Solid Knowledge guys will be at the conference so come over and let us help solve your design and coding problems – whether it be WCF, Workflow, Multithreading, WPF, Silverlight, ASP.NET MVC, Design Patterns or whatever you are currently wrestling with. We’re also doing a bunch of talks (detailed on our Conferences page)

Ask the doctor ( Devweek 2010)

Dr Rockman is In!

At DevWeek 2010 Rock Solid Knowledge will be running a drop in clinic where our consultants will help you solve your design and development issues. The whole team will be there so whether its WPF, Silverlight, .NET 4.0, WCF , Design Patterns, Multithreading, Web Development or anything else, we’ll be on hand to lend a sympathetic ear and hopefully solve your problems. In addition the RSK crew will be delivering pre and post conference days and a whole bunch of sessions which you can see on our conference page.

Visual Studio Ctrl+Tab Sticking

I use Ctrl+Tab inside VS to move between different source files…one day I noticed that when I Ctrl+Tab to the file I wish to view and simply let go of the Ctrl and Tab keys it just sat there, I needed to hit enter to confirm the selection. This started to get annoying other people had mentioned similar problem. It seemed to happen when I was training, and finally the penny dropped…..On Windows 7 I use the magnifier via Windows Key and Plus, to highlight bits of code, and then use Windows Key and minus to revert back to normal resolution. The Magnifier app continues running, it appears that with the magnifier app enabled I have to use Enter to select my file without Ctrl+Tab just works fine…

So now I close the magnifier app so that Ctrl+Tab continues to work.

DevWeek on the Horizon

I’ve just realised that DevWeek 2010 is on the horizon. DevWeek is one of my favourite conferences - lots of varied talks, vendor independence and I get to hang out with lots of friends for the week.

This year I’m doing a preconference talk and two sessions:

A Day of .NET 4.0
Mon 15th March 2010
WORKSHOP REF: M1
.NET 4.0 is a major release of .NET, including the first big changes to the .NET runtime since 2.0. In this series of talks we will look at the big changes in this release in C#, multithreading, data access and workflow.
The best-known change in C# is the introduction of dynamic typing. However, there have been other changes that may affect your lives as developers more, such as support for generic variance, named and optional parameters. There is a whole library for multithreading, PFx, that not only assists you in parallelizing algorithms but in fact replaces the existing libraries for multithreading with a unified, powerful single API.
Entity Framework has grown up – the initial release, although gaining some popularity, missed features that made it truly usable in large-scale systems. The new release, version 4.0, introduces a number of features, such as self-tracking objects, that assist using Entity Framework in n-tier applications.
Finally, workflow gets a total rewrite to allow the engine to be used far more widely, having overcome limitations in the WF 3.5 API.
This workshop will take you through all of these major changes, and we’ll also talk about some of the other smaller but important ones along the way.

An Introduction to Windows Workflow Foundation 4.0
Tues 16th March 2010
.NET 4.0 introduces a new version of Windows Workflow Foundation. This new version is a total rewrite of the version introduced with .NET 3.0. In this talk we look at what Microsoft are trying to achieve with WF 4.0, why they felt it necessary to rewrite rather than modify the codebase, and what new features are available in the new library. Along the way we will be looking at the new designer, declarative workflows, asynchronous processing, sequential and flowchart workflows and how workflow’s automated persistence works.

Creating Workflow-based WCF Services
Tues 16th March 2010
There are very good reasons for using a workflow to implement a WCF service: workflows can provide a clear platform for service composition (using a number of building block services to generate a functionally richer service); workflow can manage long running stateful services without having to write your own plumbing to achieve this. The latest version of Workflow, 4.0, introduces a declarative model for authoring workflows and new activities for message based interaction. In addition we have a framework for flexible message correlation that allows the contents of a message to determine which workflow the message is destined for. In this session we will look at how you can consume services from workflow and expose the resulting workflow itself as a service.

As well as these you may well see me popping up as a guest code-monkey in the other Rock Solid Knowledge sessions. Hope to see you there

New Screencast – Introducing the Routing Service

The Routing Service is a new feature of WCF 4.0 (shipping with Visual Studio 2010). It is an out-of-the-box SOAP Intermediary able to perform protocol bridging, multicast, failover and data dependent routing. I’ve just uploaded a new screencast walking through setting up the Routing Service and showing a simple example of protocol bridging (the client sends messages over HTTP and the service receives them over NetTcp). This screencast is one of a series I will be recording about the Routing Service. You can find the screencast here.

Executing Workflows from XAML Files

Seeing as this has changed completely from WF 3.5 I thought I’d post a quick blog entry to describe how to run a workflow declared in a XAML file.

You may have heard that the WF 4.0 default authoring model is now XAML. However, the Visual Studio 2010 workflow projects store the XAML as a resource in the binary rather than as a text file. So if you want to deploy your workflows as XAML text files how do you run them? In .NET 3.5 you could pass the workflow runtime an XmlReader pointing at the XAML file but in WF 4.0 there is no WorkflowRuntime class. It turns out you need to load the XAML slightly indirectly by creating a special activity called a DynamicActivity

DynamicActivity has an Implementation member that points to a Func<Activity> delegate – in other words you wire up a method that returns an activity (the workflow). Here’s an example:

static void Main(string[]
args)

  DynamicActivity dyn = new DynamicActivity();

  //
this line wires up the workflow creator method

  dyn.Implementation = CreateWorkflow;

  WorkflowInvoker.Invoke(dyn);

static Activity
CreateWorkflow()

  //
we use the new XamlServices utility class to deserialize the XAML

  Activity act = (Activity)XamlServices.Load(@"..\..\workflow1.xaml");

  return act;

Devweek 2010

Rock Solid Knowledge are pleased to announce that we have had a host of talks accepted for Devweek 2010, including the latest advances in Silverlight, Designing for testing, Enterprise and OO Design Patterns, Workflow and a full day of whats new in .NET 4. Hope to see you there…

For a full list of talks click here

Demos from Last Week’s Guerrilla.NET

Thanks to everyone who attended Guerrilla.NET last week. As promised the demos are now online and you can find them here

http://rocksolidknowledge.blob.core.windows.net/demos/GNET261009.zip

VS2010 Beta 2 Download

VS2010 Beta 2 is now available for download for MSN subscribers.

Geometric Decomposition Screencast

I’ve posted a new screen cast on the Rock Solid Knowledge screen casts side that provides an example of how to partition a set of data for parallel processing.

The screen cast covers a simple way using Parallel.ForEach, and a more efficient version combining the use of Barrier.

You can checkout the screen cast and others here

Parallel utilities

Whilst working with .NET 4 parallel extensions I often find the need to extend the framework to assist me in various day to day tasks. I’ve finally got around to compiling a library of such extensions.

The extensions include the following

Set Process Affinity, so I can see how my algorithm scales on a different number of cores. Will select non hyperthreaded cores first.
Determine the number of Real cores, not including hyperthreading ones.
A Range type that supports the partitioning of a range so that I can farm sub ranges out to different tasks
A Sequence class for building non integer parallel loops or loops with steps other than 1
Finally a simplified way to handle aggregated exceptions.

You can download the library from here

Its a Visual Studio 2010 project, containing the library and a unit test project which should provide enough insight to how the library works.

Im very keen to know what people think of the aggregate exception handling.

Slides and Demos from Software Architect 2009 are now available

I just got back from speaking at Software Architect 2009. I had a great time at the conference and thanks to everyone who attended my sessions. As promised the slides and demos are now available on the Rock Solid Knowledge website and you can get them from the Conferences page.

WSCF Blue Goes RTM

I had a lucky coincidence while speaking at Software Architect 2009. Four hours before I gave a talk on Contract First Design with WCF the WSCF Blue guys released version 1.0 of their tool. Contract first design is the most robust way to build services that potentially have to exist in a heterogeneous environment – it essentially means you start from the WSDL which means everyone can consume the service as no implementation details leak on to the wire. The major stumbling block in the WCF world has been there is no tool that can take a WSDL document and generate the skeleton of a service that implements the defined contract. Finally we have a released tool that does this very thing in the shape of WSCF Blue. In fact it can go further than that because writing WSDL by hand is too much like heavy lifting for many people – so WSCF Blue can also take one or more schema and runs a wizard to build a WSDL document that creates a contract based on the messages in the schema documents.

WSCF Blue solves a problem that has been there since WCF 3.0 and the great thing is that its free – being release on codeplex

Enjoy!

Are Singletons Evil ?

Finally got around to delivering a conference talk on this subject this week at Software Architecture Week, its a topic myself and Kevin Jones are constantly being asked. Of course a quick google reveals the answer there are numerous rants about this evil pattern. But like most things in life its not as simple as yes or no.

Our goal for this talk was to expose the areas were this pattern causes a developer a whole load of pain. In fact one member of the audience was experiencing such pain in his attempt to take legacy code base heavily utilising singletons and start to write unit tests.

So whilst the majority of the time was spent examining the consequences of using the singleton pattern we also took time to highlight that one or two singletons correctly positioned in your application could in fact enable unit testing, and coding to interface without having to refactor large areas of a legacy code base.

This talk took the format of a short geeky play, featuring two developers trying to wrestle with getting the job done and unit testing. You can download the script and accompanying code

So like all good consultants our answer to this question is “It Depends”

MVP’d Once More

I used to be a C# MVP a couple of years ago. When I took on the role of CTO of DevelopMentor I found I had a far smaller amount of time to devote to community based activity and so I lost my MVP status. I stepped down as DevelopMentor’s CTO back in January and as a result suddenly found I had time again and so can often be found hanging out at the MSDN WCF forum, speaking at conferences, etc. Consequently I have just heard that I’ve been awarded MVP status for Connected Systems :-) - nice to be back in the fold

Slides and Demos from BASTA!

Thanks to everyone who came to my sessions at BASTA! My first time at that conference and I had a great time. Here are the slides and demos

What’s New in Workflow 4.0

Contract First Development with WCF

Generics, Extension Methods and Lambdas – Beyond List<T>

Microsoft Mouse Preventing Screen Saver Working

I've just installed Windows 2008 R2 and I could not get the screen saver or power management to work. Turns out I needed to install the correct drivers for my mouse. This is the Wireless Laser 5000, the drivers can be found here.

Fluent Parallel While

During devweek 2009 Oliver introduced me to Fluent Api's, I personally love programs that naturally read, after all programs are read far more often than written. This week a posting on the Parallel Extensions blog demonstrated how to achieve parallel while, since we only have Parallel.For and Parallel.ForEach

static void Main(string[] args)
        {
            ConcurrentQueue<int> queue = new ConcurrentQueue<int>();

            for (int i = 0; i < 10; i++)
            {
                queue.Enqueue(i);
            }

           
            Action<ParallelLoopState> processQueue = (lps) =>
            {
                int item;
                if (queue.TryDequeue(out item))
                {
                    Console.WriteLine(" Thread Id = {0} Task Id = {1} : {2}", Thread.CurrentThread.ManagedThreadId, Task.Current.Id, item);
                }
            };

            Func<bool> queueContainsItems = () => queue.IsEmpty == false;

            ParallelUtil.While(new ParallelOptions(), queueContainsItems, processQueue);
        }

I thought I’d combine both these ideas and produce what I would consider a more Fluent version

public static class ParallelUtil
    {
        private static IEnumerable<bool> Infinite()
        {
            while (true) yield return true;
        }

        private static ParallelOptions NoParallelOptions = new ParallelOptions();

        public static void InParallelWhile(this Action<ParallelLoopState> action, Func<bool> condition, ParallelOptions options = null)
        {
            if (options == null) options = NoParallelOptions;

            Parallel.ForEach(IterateForever(), options , 
                (ignored, loopState) =>
                {
                    if (!condition())
                    {
                        loopState.Stop();
                    }
                    else
                    {
                        action(loopState);
                    }
                });

        }

        private static IEnumerable<bool> IterateForever()
        {
            while (true)
            {
                yield return true;
            }
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            ConcurrentQueue<int> queue = new ConcurrentQueue<int>();

            for (int i = 0; i < 10; i++)
            {
                queue.Enqueue(i);
            }

           
            Action<ParallelLoopState> processQueue = (lps) =>
            {
                int item;
                if (queue.TryDequeue(out item))
                {
                    Console.WriteLine(" Thread Id = {0} Task Id = {1} : {2}", Thread.CurrentThread.ManagedThreadId, Task.Current.Id, item);
                }
            };

            Func<bool> queueContainsItems = () => queue.IsEmpty == false;

            processQueue.InParallelWhile(queueContainsItems);
        }
    }
}

The key difference is the first example you use the following line to process the queue in parallel

ParallelUtil.While(new ParallelOptions(), queueContainsItems, processQueue);

As opposed to the second version with a perhaps more fluent implementation

processQueue.InParallelWhile(queueContainsItems);

Linq for NHibernate

Its been a while coming, but there it is no possible to use LINQ against NHibernate..I think its a shame that MS didn’t get behind the Hibernate family when they first created LINQ as its a marriage made in heaven, combining a mature ORM with a language integrated query. Rather than spending all that time ( and still ) on trying to create their own ORM.

I’ve yet to try out the integration, but hopefully will be over the next few weeks…

Click Here for the announcement

WARNING..Cancellation support may makes things go slow….

.NET 4 Tasks offers much better support for task cancellation, unlike QueueUserWorkItem tasks can be cancelled before commencing, and the Task library offers a standard way for running tasks to detect and report cancellation. I recently recorded a screencast that demonstrated the new Task API including the cancellation support. This blog post isn’t so much about the cancellation mechanics but some guidance on how best to use it if you don’t want to change the throughput of your task.

Below is some code that calculates pi, it is expecting to be run inside a task and is supporting the notion of cancellation.

private static double AbortableCalculatePi()
        {
            double pi = 1;
            double multiplier = -1;

            const int N_ITERATIONS = 500000000;

            for (int nIter = 3; nIter < N_ITERATIONS; nIter += 2)
            {
                
                    if (Task.Current.IsCancellationRequested)
                    {
                        Task.Current.AcknowledgeCancellation();
                        return 0.0;
                    }
                

                pi += (1.0 / (double)nIter) * multiplier;
                multiplier *= -1;

            }
            return pi * 4.0;
        }

So all well and good until you benchmark it and compare it to the version with no cancellation support and it runs almost twice as slow. The reason being that the cost of detecting cancellation is high in relation to the work being done. The important aspect to cancellation is being able to respond in a meaningful time for the client, at present we are being way over aggressive in checking.

One option would be to only check every N iterations..

private static double BetterAbortableCalculatePi()
        {
            double pi = 1;
            double multiplier = -1;

            const int N_ITERATIONS = 500000000;

            for (int nIter = 3; nIter < N_ITERATIONS; nIter += 2)
            {

                if ((nIter - 3) % 100000 == 0)
                {
                    if (Task.Current.IsCancellationRequested)
                    {
                        Task.Current.AcknowledgeCancellation();
                        return 0.0;
                    }
                }


                pi += (1.0 / (double)nIter) * multiplier;
                multiplier *= -1;

            }
            return pi * 4.0;
        }

This took a third less time than the previous more aggressive version. However the if block’s effect on the pipeline and the additional maths is still an additional cost over the version that had no cancellation support.

So a third approach is called for this time refactoring the algorithm to use two loops instead of one, were the check for cancellation is done once per iteration of the outerloop, this results in little additional cost.

private static double OptimisedAbortableCalculatePi()
        {
            double pi = 1;
            double multiplier = -1;

            const int N_ITERATIONS = 500000000 / 2;

            const int OUTER_ITERATIONS = 10000;
            const int INNER_ITERATIONS = N_ITERATIONS / OUTER_ITERATIONS;

            int i = 3;
            for (int outerIndex = 0; outerIndex < OUTER_ITERATIONS; outerIndex++)
            {
                for (int nIter = 0; nIter < INNER_ITERATIONS; nIter++)
                {
                    pi += (1.0 / i) * multiplier;
                    multiplier *= -1;
                    i += 2;
                }

                if (Task.Current.IsCancellationRequested)
                {
                    Task.Current.AcknowledgeCancellation();
                    return 0.0;
                }
             
            }
            return pi * 4.0;
        }

Here are the timings are got from the various approaches

NoAbortableCalculatePi = 3.14159264958921 took 00:00:03.7357873

AbortableCalculatePi = 3.14159264958921 took 00:00:09.6137173

BetterAbortableCalculatePi = 3.14159264958921 took 00:00:06.3826212

OptimisedAbortableCalculatePi = 3.14159265758921 took 00:00:03.6883268

As the figures show there is virtually no difference between the first and last run, but a considerable difference when cancellation is inserted into the core of the computation.

So to sum up whilst cancellation support is good the frequency you check for could have an impact on the overall performance of your algorithm. Cancellation is something we want to support but in general users probably don’t need it so we need to strike the right balance between throughput and responding to cancellation in an appropriate timeframe.

.NET 4 Tasks and UI Programming

Just upload a new screencast covering how to marshal results from .NET 4 Tasks back on to the UI thread. One method is to continue to utilise the same API’s from previous versions of .NET thus utilising SynchronizationContext.Post, the Task based API offers an alternative and in some cases more elegant solution using the ContinueWith method.

Throttling changes in WCF 4.0

Wenlong Dong has just posted about changes to the WCF thottling defaults in WCF 4.0. The new throttle defaults are going to be based on the number of processors/cores in the machine – this means the more powerful the machine the higher the throttle will be - which is a good thing. The throttle that always hit people first were either session, if they had a session as a result of contract/binding settings or, no session, concurrent calls. Now the changes (100 * processor count for session and 16 * processor count for calls) will mean that either one would bite first.

As Wenlong says, the original values were always too low for enterprise applications. What they did do, however, is force people to address throttling if they were writing enterprise apps. And Wenlong is right that that sometimes meant people putting the throttles up to int.MaxValue which is really the same as no throttle at all. But although, in general, I think the change is the right move (it mostly works out of the box), it will lead to people facing performance problems with absolutely no idea why they might be taking place.

What I mean by this is problems caused by the current throttles are really easy to spot “as soon as I put more than 10 calls though it breaks”. You can google that and find the problem and the solution. The new values make it hugely non-obvious why an application suddenly has problems with more than 400 clients (NetTcpBinding on machine with 4 cores for example). Good time to be a consultant in the UK and Europe I guess ;-)

My First Silverlight 3 App

Had a brief rest from patterns and parallel stuff to have a quick play with Silverlight 3. I mainly wanted to see the out of browser aspect, as I think the idea of being able to build RIA that also run on the desktop is very compelling….

So what to build, I really like the iPhone weather app so I thought I’d have a go at reproducing it in Silverlight, below is a screen shot showing it running out of the browser.

I’m using isolated storage to store the list of weather centre’s of interest, a more typical line of business app would store app config on the web server/cloud and potentially locally to support true client roaming, but I’ll leave that for another day.

One thing to note is that the method for enabling Out Of Browser mode for you application is now different from pre-release versions of Silverlight 3, so there are many old blog posts that are unfortunately wrong now. The good news is now it is trivial, view the project properties, and under the Silverlight tab there is an option to enable the app to support out of browser. This then creates the OutOfBrowserSettings.xml file.

You can download the source via here or to just see the app in action click here. I’ll let you decide if its as cool as the iPhone….

Testing on varying number of cores

I’ve written many blog articles in the past that show that the performance of a piece of parallel code can vary dramatically based on the number of available cores. With that it mind, its obviously desirable even when given a machine with 8 cores that you test your code against a machine that could have substantially less. You can resort to task manager and set Process Affinity and reduce the number of cores available for the process, but this is tedious. There is a .NET API that allows access to controlling which cores to make available for a process. The API requires the use of a bitmask to identity which cores to use, that's a bit ( no pun intended) overkill for what I'm trying to do, so I created a facade that allows me to simply say use N cores.

public static class Cores
    {
        public static int Max
        {
            get
            {
                return Environment.ProcessorCount;
            }
        }
        public static int CoresInUse 
        {
            get
            {
                IntPtr cores = 
                Process.
                    GetCurrentProcess()
                    .ProcessorAffinity;


                int nCores = 0;
                while( cores != IntPtr.Zero )
                {
                    if ( ((int)cores & 1) == 1 )
                    {
                        nCores++;
                    }
                    cores = (IntPtr)((int)cores >> 1);
                }
                return nCores;
            }

            set
            {
                if ((value < 1) || (value > Environment.ProcessorCount))
                {
                    throw new ArgumentException("Illegal number of cores");
                }

                int cores = 1;
                for (int nShift = 0; nShift < value-1; nShift++)
                {
                    cores = 1 | (cores << 1);
                }

                Process.GetCurrentProcess().ProcessorAffinity = (IntPtr)cores;
            }
        }
    }

The following code prints out the number of active cores and then reduces the number of cores to 4

Console.WriteLine("Using {0} out of {1}" , Cores.CoresInUse , Cores.Max);
Cores.CoresInUse = 4;
Console.WriteLine("Using {0} out of {1}", Cores.CoresInUse, Cores.Max);

Azure platform pricing announced

It has been one of the bug bears for me as I have given talks on the Azure platform that I have not been able to answer any question that involved commercial details with anything other than “we’ll have to see the prices when they announce them. Finally, today, the team have announced the pricing model and availability

http://blogs.msdn.com/windowsazure/archive/2009/07/14/confirming-commercial-availability-and-announcing-business-model.aspx

Guerilla .NET Demos from 6th July 2009

Had loads of fun as normal teaching Guerilla .NET with Rich and Marcus , All the demos from class here

WSCF Blue goes into Beta

One of the frustrations with the current WCF tooling is that, although I can generate the client proxy code from a WSDL document I cannot generate the server side skeleton that matches the WSDL. In situations where two parties agree a contract based on WSDL this makes implementing the service side error prone. Back in the ASMX days WSDL.EXE had a /s switch that would create the service side skeleton, but this feature was not carried through into SVCUTIL.EXE.

Fortunately the WSCF (Web Service Contract First) guys have finally released a beta of a WCF compatible version of their tool that allows you to build up a model of the service and then generate the client and/or service

Here’s Santosh’s announcement

New Screencast: Streamed Messages in WCF

In my last post I linked to the screencast I made on processing large messages in WCF using buffering. I also said that I would be putting up another one on streaming messages shortly. That second screencast has now gone live on the Rock Solid Knowledge website. In part 2 of the large message handling screencast I talk about enabling streaming, designing contracts for streaming and how this affects the way the receiver has to process the data. You can find the new screencast here

http://rocksolidknowledge.com/ScreenCasts.mvc

Parallel.For and Parallel.ForEach…moving past Thread.Sleep

Just released a screen cast demoing Parallel.For and Parallel.ForEach where we are not demoing the virtues of Parallel Sleep….

Click here to see this and many other Rock Solid Knowledge Screen casts

Short and Long running tasks in .NET 4

Just added a screen cast on how to create short and long running tasks in .NET 4. You can get to all the Rock Solid Knowledge screen casts via www.rocksolidknowledge.com/screencasts

New Screencast: Working with Large Messages in WCF (Part 1)

I’ve just uploaded a new screencast on to Rock Solid Knowledge. This one walks though configuring WCF to be able to pass large messages between client and service. Its the of two parts, this one talks about the default mode WCF uses for transferring data – buffering. I’ll be doing another one soon that looks at WCF in streaming mode.

You can find the screencast here

Rock Solid Knowledge at Software Architect 2009

Just to say that we will be delivering talks at Software Architect 2009, here is a full list of our sessions.

Long or Short running tasks

Been playing around with the new version of Pfx for .NET. I must say Ive been very impressed with the improvements since the last CTP for .NET 3.5. So here goes a series of blogs and screen casts on some on various bits of Pfx for .NET 4 BETA 1.

The one thing that really shouts is that the original Pfx types are no longer something for just fine grained parallelism its is a unification of the various threading API’s. Unifying Api’s is something not new to the .NET framework its been happening since 1.1. As developers its great that whilst the framework is evolving a constant effort is being made to refactor and simplify previous complexity.

So previously If I wanted to create a short running piece of background work I would favour the thread pool, if I was to write a long running piece of background activity I would have to create my own custom thread. Creating a short running thread using the thread pool meant either QueueUserWorkItem or Delegate.BeginInvoke, and a long running via new Thread(), and calling Start.

Now for either types of situation you simply create a new Task using the new Task type, either via the Task Factory ( not a real GOF Factory, but don’t get me started on that ), or via new Task()

Task bgTask = Task.Factory.StartNew( MyShortRunningTask);

For a long running task we use the same API but this time giving it a hint that this is a long running task and shouldn’t therefore use a thread pool thread, but create a new thread outside the thread pool

Task bgTask = Task.Factory.StartNew( MyLongRunningTask, TaskCreationOptions.LongRunning);

So too very similar calls but leaving it up to the framework to decide how best to schedule the work.

VS2010 Edit window outside the IDE

Just noticed that I can drag source windows outside the IDE in VS2010, this is something Ive wanted for ages…Now I can really use multiple monitors

Pfx team examples moving into the real world

I’ve written many articles on my blog about how Im sick of trade show demos of Pfx ( Parallel framework extensions ). You know the ones using simple Parallel.For with Thread.Sleep or Thread.SpinWait as the piece of work. These examples scale wonderfully but the moment people take those simple examples and apply them to their own for loops terrible performance often results. Thankfully the Pfx team have written a blog article offering some suggestions about what to do when the piece of work inside the for loop is too small. ( Blog article ). Interesting this is the first time I’ve seen them utilise the number of processors in the machine to determine the number of tasks, something I’ve advocated many times in the past for tasks of equal cost.

WCF Duplex Messaging

I am one of the moderators of the MSDN WCF Forum. One of the main areas of questions on the forum is duplex messaging – particularly using the WSDualHttpBinding. So instead of typing long messages repeating the same thing in answer to these questions I’ve decided to write this blog post to give a bit of background about duplex messaging and then discuss the options for bindings and common problems people have.

What is Duplex Messaging?

There are many ways that messages can be exchanged between two parties in a service based system: the client can send messages to the server and never get any back; the client can send a message and wait for a response; the client and service can send eachother messages without any pre-defined pattern; the client can send the service a message but not wait synchronously for a response and then then service can send a message back asynchronously; and there are many others. However, the first three of these are supported natively in WCF and are known as One-way, request/response and duplex.

So Duplex messaging is where, unsolicited, the client and service can send eachother messages. Most commonly this is characterized by the service sending the client “events” or notifications or progress of “interesting things”.

Duplex Contracts in WCF

To send messages to eachother the client and service must have an idea of what operations are available and what messages are sent and received during the communication. In WCF this idea is modelled by the contract. Now normally a contract just determines what functionality is available at the service. However, now the service is going to be sending messages to the client that the client isn’t specifically waiting for so it needs an idea of what messages the client can deal with. So we need a contract that models both directions of the conversation.

A bi-directional contract is modelled using two interfaces bound together with a ServiceContract – like this:

[ServiceContract(CallbackContract=typeof(IPizzaProgress))]

interface IOrderPizza

    [OperationContract]

    void PlaceOrder(string PizzaType);

interface IPizzaProgress

    [OperationContract]

    void TimeRemaining(int minutes);

    [OperationContract]

    void PizzaReady();

The import bit here is the CallbackContract that establishes the relationship between the service’s and client’s contracts.

Writing the Service

The service is implemented normally apart from two issues: firstly it needs to access the callback contract to be able to send messages back to the client; secondly the communication infrastructure (modelled by the binding) needs to be able to cope with duplex messaging. Firstly lets look at accessing the callback contract:

class PingService
: IOrderPizza

    IPizzaProgress callback;

    public void PlaceOrder(string PizzaType)

        callback
= OperationContext.Current.GetCallbackChannel
();

        Action preparePizza = PreparePizza;

        preparePizza.BeginInvoke(ar => preparePizza.EndInvoke(ar), null);

    void PreparePizza()

        for (int i
= 10 - 1; i >= 0; i--)

            callback.TimeRemaining(i);

            Thread.Sleep(1000);

        callback.PizzaReady();

The critical line here is calling GetCallbackContract on the OperationContext. This gives the service access to a proxy to call back to the client.

Now the service also needs to use a contract that is compatible with duplex messaging. WSHttpBinding is the default for the built in WCF projects but it does not support duplex messaging. People generally then move to the WSDualHttpBinding which is similar to the WSHttpBinding but does support duplex. I will go into more depth about bindings for duplex shortly but for now lets stick to this for now - it will work in our test rig on a single machine without issue.

Writing the Client

If the client is going to receive these messages it needs to provide an implementation of the callback contract. It can gets its definition from either a shared contract assembly or from metadata. If using metadata the callback contract will be named the same as the service’s contract but with the work Callback appended. It will also need to supply this implementation to the WCF infrastructure and it does this by wrapping an instance in an InstanceContext object and passing it to the proxy constructor. So here is the client:

class Program

    static void Main(string[]
args)

 InstanceContext
ctx = new InstanceContext(new Callback());

        OrderPizzaClient proxy = new OrderPizzaClient(ctx);

        proxy.PlaceOrder("Pepperoni");

        Console.WriteLine("press
enter to exit");

        Console.ReadLine();

class Callback
: IOrderPizzaCallback

    public void TimeRemaining(int minutes)

        Console.WriteLine("{0}
seconds remaining", minutes);

    public void PizzaReady()

        Console.WriteLine("Pizza
is ready");

Running the service and the client will have this working quite happily – so it would seem that duplex messaging and WCF works very well … so why on earth do people keep asking questions about it on the WCF forums?

It Worked on My Machine but Broke when we Deployed It!

Ahh well you probably did the thing that is obvious but almost always a bad idea. You went and chose WSDualHttpBinding as your duplex binding. To understand why this is a bad idea we need to dig a little deeper into how the WSDualHttpBinding works. HTTP is a unidirectional protocol: the client makes a request and the server sends a response. There is no way for a server to initiate an exchange with the client. So how on earth is duplex messaging going to work because it requires exactly this facility? Well the “Dual” in the name is significant, the WSDualHttpBinding actually consists of two connections: one outbound from client to server and one inbound from server to client – this second connection may already be ringing alarm bells with you. The are a two big problems with inbound connections to a client: firewalls very often block inbound connections to clients; the client may not be reachable from the server, it may be using NAT translation behind a router and so cannot be contacted without port forwarding being set up on the router. Both of these issues are showstoppers in real network topologies. You can take some small steps to help – you can specify what port the client should listen on for example by using the clientBaseAddress property of the WSDualHttpBinding. This means the network admin will only have to punch one hole in their firewall (but lets face it, network admins don’t allow any holes to be punched in the firewall).

So if you really shouldn’t use WSDualHttpBinding for duplex, what should you use instead? Well NetTcpBinding supports duplex out of the box and the nice thing about this is that the outbound connection that it establishes can also be used be used for inbound traffic – suddenly we don;t have the inbound connection firewall/NAT issues. “But hold on, isn’t NetTcpBinding for intranet? I’ve read books that tell me that in their ‘which binding should I use?’ flowcharts!” Well it turns out those flowcharts are talking rubbish – NetTcpBinding works very happily over the internet, its just not interoperable by design. “Aha! but I need interop so WSDualHttpBinding is for me!” Well unfortunately not, NetTcpBinding is non-interoperable by design, WSDualHttpBinding is non-interoperable despite its design. From the name it would suggest interoperability but Arun Gupta from Sun wrote this excellent post describing why it wasn’t.

So now seeing that we really are not talking about interop anyway, NetTcpBinding is far more useful than WSDualHttpBinding. Its not bullet proof, if the firewall only allows outbound port 80 but also allows inbound port 80, then WSDualHttpBinding would work where NetTcpBinding wouldn’t – but in this situation we’re really talking server to server and so I’d argue its probably better to roll your own bidirectional communication with two standard HTTP based connections.

The final option you have for duplex communication is to add a piece of infrastructure into the mix. The .NET Services Service Bus (part of the Azure platform) allows two parties to exchange messages both making outbound connections – potentially even using HTTP port 80. The two outbound connections rendezvous in the Service Bus which mediates their message exchanges. If the receiver has had to use outbound port 80 then it polls to receive message bound for it.

It Worked for the First 10 Clients and then the Rest Timed Out!

Irrespective if which of the standard bindings you are using, duplex assumes a constant relationship between proxy and service. In WCF this idea is modelled by the concept of session. All duplex bindings require session. A while back I wrote in some detail about sessions. You will have to either put up with increasing the session throttle (see the linked article for details) or roll your own custom binding that can do duplex without session – you can find an example of this here.

I Use the Callback While the Client is calling the Service and it Deadlocks!

This is because your client is probably a Rich Client GUI based application (Windows Forms or WPF). To understand why this is a problem we need to step back briefly and look at UI clients, threading and WCF threading. UI applications have a rule: you must only update the UI from the thread that created those UI components. In general a GUI application has one UI thread so anything that changes the UI needs to be done from that thread. .NET 2.0 introduced a new construct to simplify the process of a background thread updating the UI: SynchronizationContext. The idea is that a UI framework creates an implementation of a SynchronizationContext derived class that handles the mechanics of marshalling a call on to the UI thread. An instance of this implementation is then made available on the UI and accessible via the SynchronizationContext.Current.

WCF adds more complexity into the mix by enforcing a rule that says “unless you tell me otherwise I will only allow one thread at a time into an object that I control”. You see this with singleton services that will only allow one call at a time by default. The same is also true of the callback implementation object – so WCF will only allow one active thread in the client at a time. So while WCF is performing an outbound call it will not allow an inbound call into the object. This causes the initial problem with the deadlock that the service’s callback cannot be dispatched while the client’s outbound call is in progress. To solve this we use the “unless you tell me otherwise” part of the above rule. You do this by annotating the callback implementation class with a [CallbackBehavior] attribute like this:

[CallbackBehavior(ConcurrencyMode=ConcurrencyMode.Reentrant)]

class Callback
: IOrderPizzaCallback

    public void TimeRemaining(int minutes)

        Console.WriteLine("{0}
seconds remaining", minutes);

    public void PizzaReady()

        Console.WriteLine("Pizza
is ready");

But now there is another problem: by default WCF will attempt to dispatch using an available SynchronizationContext. The problem with this callback is the UI thread is already blocked in an outbound call. SO for the call to dispatch we need to tell WCF not to use the SynchronizationContext – again using the CallbackBehavior attribute:

[CallbackBehavior(ConcurrencyMode=ConcurrencyMode.Reentrant, UseSynchronizationContext=false)]

class Callback
: IOrderPizzaCallback

...

Now the issue is of course that the call is going to be processed on a non UI thread so you would have to manually marshal any UI interaction using the SynchronizationContext.Post method.

Duplex messaging can be a useful message exchange pattern but in WCF there can be some unexpected issues. Hopefully this blog post clarifies those issues and demonstrates workarounds for them.

News of our death has been greatly exaggerated

it seems that the ever increasing immediacy of social networking and blogging has some downsides. Ted Neward has posted a eulogy for Developmentor (who I regularly teach for). Unfortunately Ted didn’t bother checking his facts. DM are very much still in business and delivering courses (I’m teaching one the week after next and the week after that in fact! Plus several in July and September!)

New Screencast – Using WCF Tracing for Debugging

We’ve just posted a new screencast at Rock Solid Knowledge. In this one I walk you through enabling WCF tracing to assist in diagnosing bugs in your services using the example of a serialization failure. You can find the screen casts here

http://rocksolidknowledge.com/ScreenCasts.mvc

DevWeek Interview Online

Every year I speak at the excellent DevWeek conference in London. Eric Nelson, a Microsoft Developer Evangelist in the UK is also a regular attendee. This year Eric, Mike and Mike were recording interviews with people at the conference. Eric interviewed me about Workflow 4.0 (I was delivering a post conference day on WF 4.0, Dublin and Oslo). He’s just got round to published it online

http://geekswithblogs.net/iupdateable/archive/2009/05/20/devweek-2009-interview-with-richard-blewett-on-workflow-4.0.aspx

Visual Studio 2010 Beta 1 Ships

Soma has blogged that beta 1 has finally shipped. Lots of new stuff in here since PDC. His blog post is here

http://blogs.msdn.com/somasegar/archive/2009/05/18/visual-studio-2010-and-net-fx-4-beta-1-ships.aspx

New Screencasts at Rocksolidknowledge.com

We’ve started a library of screencasts at rock solid knowledge. I’ve created one on WCF Serialization and one on using SSL with Self hosted WCF services. Andy Clymer has recorded one on Visual Studio Tricks and Tips and Dave Wheeler has one on character animation in Silverlight 2.0. You can find the screen casts at

http://rocksolidknowledge.com/ScreenCasts.mvc

We’ll be adding to the library as time goes on so subscribe to the library RSS feed

What’s new in WF 4.0 Beta 1

Cliff Simpkins has just posted a blog entry detailing some of the changes between the PDC preview of WF 4.0 and what is coming in beta 1, due shortly.

Important information here not just about beta 1 but also about things you can expect and also things that won’t make it into RTM

Problem When Upgrading From Rails 2.2.2 to 2.3.2

I've just installed the latest Active* gems to move my Rails install to 2.3.2. When I ran a console I got the following error

Loading development environment (Rails 2.3.2)
/Library/Ruby/Gems/1.8/gems/activesupport-2.3.2/lib/active_support/dependencies.rb:443:in `load_missing_constant':NameError: uninitialized constant ApplicationController

I googled this and found a couple of posts on the issue but nothing obvious that I was doing. After generating a 2.3.3 app and comparing files the solution was obvious and easy. I 2.2.2 the ApplicationController class is in a file called Application.rb, in 2.3.2 this has changed to application_controller.rb. Changing the file name has fixed my problem.

Extension Methods and Good Practice – or OI! Get Out of my Namespace!

I’ve been doing some work with the WCF REST Starter Kit for our website http://rocksolidknowledge.com. Preview 2 of the start kit has a bunch of client side plumbing (the original release concentrated on the service side)

The client side code looks something like this:

HttpClient client = new HttpClient("http://twitter.com");

HttpResponseMessage response = client.Get("statuses/user_timeline/richardblewett.xml");

Console.WriteLine(response.Content.ReadAsString());

As compact as this is I was a bit disappointed to see that I only had a few options for processing the content: ReadAsString, ReadAsStream and ReadAsByteArray. Now seeing as they had a free hand to give you all sorts of processing options I was surprised there weren’t more. However, one of the assemblies with the start kit is called Microsoft.Http.Extensions. So I opened it up in Reflector and lo and behold there are a whole bunch of extension methods in there – so why wasn’t I seeing them?

Extension methods become available to your code when their namespace is in scope (e.g. when you have a using statement for the namespace in your code). It turns out that the team put the extension methods in the namespaces appropriate to the technology they were exposing. So for example the ReadAsXElement extension method is in the System.Xml.Linq namespace and the ReadAsXmlSerializable<T> method is in the System.Xml.Serialization namespace.

Although I really like the functionality of the WCF Starter Kit, this particular practice, to me, seems bizarre. Firstly, it makes the API counter intuitive – you use the HttpClient class and then there is no hint in the library that there are a bunch of hidden extensions. Secondly, injecting your extensions into someone else’s namespace increases the likelihood of extension method collision (where two libraries define the same extension method in the same namespace). The same named extension method in difference namespaces can be disambiguated, the same named extension in the same namespace gives you no chance.

I think if you want to define extension methods then you should keep them in your own namespace – it makes everyone’s life simpler in the long run.

DevWeek 2009 Demos

Are now available on the Rock Solid Knowledge site. I've upload the 'So you think you now JavaScript', 'Design for Testing' and Day of 'Ruby and Rails' talks. Andy's already put up the 'Day of Patterns' and 'Patterns Dartboard' talks

Ruby idioms in ASP.Net MVC

In Rails there is a mechanism by which you can mimic variadic methods (Ruby also supports true variadic methods) by treating the last parameter as a hash. I can write a function definition like this

def pass_a_hash(s, h) 
  puts s
  h.each { |key, value| puts "#{key} => #{value}"} if h.class == Hash  
end

and call it either like

pass_a_hash "kevin", {:a => "b", :c => "d"}

pass_a_hash "kevin", :a => "b", :c => "d"

either way this prints

kevin
a => b
c => d

The second style is much neater, it hides the use of the hash and instead makes it seem like we are using named parameters. This is used all over Rails, especially on web pages where you need to specify things such as controllers and actions. You will often see code like:

<%= link_to "Add", :action => :add, :controller => :students %>

Here we are calling the 'link_to' method passing a string and a hash of options, just like above

Microsoft (bless 'em) have tried to mimic this in ASP.Net MVC by letting you can write code similar to the 'link_to' Rails method. On an ASP.Net view you can do something like:

<%= Html.RouteLink("Add", new {action = "add", controller = "students"}) %>

And this adds a link to the page with the text "Add" and a url something like http://server.com/students/add. This is similar to ActionLink and they both eventually call into a method called GenerateRouteLink. In the ASP.Net case the second parameter is not a hash (oh for first class hashes in C#) but an instance of an anonymous class. Using Reflector we can see what this method does.

Internally RouteLink creates a RoutedDictionary passing the anonymous instance as a parameter to its constructor

    return htmlHelper.RouteLink(linkText, new RouteValueDictionary(routeValues));

The RouteValueDictionary constructor looks like this

public RouteValueDictionary(object values)
{
    this._dictionary = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
    this.AddValues(values);
}

and AddValues does this:

private void AddValues(object values)
{
    if (values != null)
    {
        foreach (PropertyDescriptor descriptor in TypeDescriptor.GetProperties(values))
        {
            object obj2 = descriptor.GetValue(values);
            this.Add(descriptor.Name, obj2);
        }
    }
}

public void Add(string key, object value)
{
    this._dictionary.Add(key, value);
}

So AddValues uses reflection to build a dictionary of name/value pairs

Just like in Rails, when the element is rendered this dictionary is interrogated and the values used to build the URL.

Neat, but still more ceremony than in Ruby!

Ruby Essence vs Ceremony

Last week at DevWeek Tim Ewald and I tried to show some of the elegance of Ruby and I'd like to try and repeat that example here.

We started with a Lion class in honour of the news story that week about "Christian the Lion" (hey, look it up yourselves!). The class is very simple

class Lion

  attr_accessor :message, :name

  def speak
    @message
  end

  def to_s
    "#{self.name} says #{self.message}"
  end

  @@lions = {}

  def self.create message, name
    if @@lions[name] == nil
      @@lions[name] = Lion.new(message, name)
    end
    return @@Lions[name]
  end

  def initialize(message, name)
    @message = message
    @name = name
  end

end

The bit we care about is the self.create method. The idea here is that we provide a function to only allow the creation of one lion with any given name (this was a demo so it didn't need to make sense). To do this there is a class level dictionary (a static) in which to store new lions. We only add lions to this dictionary if they are unique, otherwise we return an existing lion. The code as it is written is not very Ruby-ish, it reads more like C++, C# or Java code than Ruby and that's what I'd like to change.

The first step is to remove the 'return' keyword. In Ruby the last statement in a method is the return value so we can change the code to look like this:

def self.create message, name
  if @@lions[name] == nil
    @@lions[name] = Lion.new(message, name)
  end
  @@Lions[name]
end

The 'if' statement isn't very idiomatic either and in Ruby this can be reduced to

def self.create message, name
  @@lions[name] = Lion.new(message, name) if @@lions[name] == nil 
  @@lions[name]
end

We're still not quite there though. Ruby (like C#) has a 'null co-alescing' operator, which lets me say "if 'x' is not null, use it, else do 'y'", and I can rewrite the above 'if' using this operator (|| in Ruby). It also means I can do away with the final return statement

def self.create message, name
  @@lions[name] || @@lions[name] = Lion.new(message, name)
end

Which says, if @@lions[name] is not null return the value, else assign Lion.new to @@lions[name] and return that value

One line to do what it would take four lines to do in other languages and no keywords. As my friend Stu Halloway would put it, essence over ceremony!

Dev Week 2009

Just finished DevWeek 2009

It's been another great week. Spent time with people I haven't seen for a while. I've enjoyed giving the talks and hope you have enjoyed listening to them. I always love spending time hanging out the speakers, there are so many really smart people there. Just spent a day with Tim Ewald - it always blows me away how good a presenter Tim is and how much he knows, this time on Ruby and Rails.

Hopefully I'll be back for Software Architect in Sept/Oct and at DevWeek next year.

Slides and demos from my Windows Workflow Session at Devweek

Thanks to all who attended my Devweek session: A Beginners Guide to Windows Workflow. The slides and demos can be downloaded here

A Tale of Two Reader/Writer Locks

If you look in the System.Threading namespace you will notice something that looks slightly odd: there are a pair of classes ReaderWriterLock and ReaderWriterLockSlim. What are these for and why are there two of them?

Whenever you have multiple threads there is a need to protect state shared between them from corruption. The simplest tool in the .NET Framework is the Monitor class (encapsulated by the lock statement in C#) that provides mutual exclusion. In other words, only one thread at a time can acquire it and anyone else trying to acquire it blocks until the first thread releases it. It situations of high update this provides a reasonable approach. However, if we had no writers we could allow everyone to access a resource without acquiring a lock. So if we had many readers and only an occasional writer, ideally we’d like all the readers to be able to access a resource at the same time and only be blocked if someone needed to write. Unfortunately a Monitor would only allow one reader in at a time so this is the role of a Reader/Writer lock – to allow many concurrent readers but only a single writer, blocking all readers.

So we come to the next question: why are there two of them? ReaderWriterLock was introduced in version 2.0 of .NET and provided the above functionality. However, there was a problem. Imagine this scenario: we have 10 readers currently reading when a writer wants access. Obviously the writer has to let the readers finish and so waits patiently for the readers to release their read locks. However, as the readers drop to one, suddenly a brand new reader arrives – there i still a read lock being held but thats ok as it can also acquire a read lock in that situation. Now the writer is blocked on a new reader and more can continue to arrive so that the writer never gets in – this is called writer starvation. ReaderWriterLock suffers from the possibility of writer starvation.

For version 3.5 SP1 the .NET framework team decided to address this. They introduced a new class called ReaderWriterLockSlim that provides the reader/writer lock functionality but does not suffer from writer starvation (new readers are blocked when there is a writer waiting). However, why didn’t the team just fix the original one? They say that some people depend on the feature that new readers can get a lock if a reader is already there. They didn’t want to break existing code.

Keeping things safe wth AsyncCallback

The .NET Async pattern is a very neat way of running functionality asynchronously. The async pattern is where for a synchronous method DoWork be have a pair of methods BeginDoWork and EndDoWork to handle running the DoWork functionality on the threadpool. Now it is well documented that if I call the Begin method I must also call the End method to allow the async infrastructure to clean up resources it may have acquired. However, where do I call the End version?

Consider async delegate invocation. Quite often I’d like to just fire off the async method and forget about it but I have to call EndInvoke. Fortunately lambdas make this really easy

Action a = DoWork;
a.BeginInvoke( ar => a.EndInvoke(ar) );

Now there is a nasty problem. What happens if DoWork throws an exception? The async delegate infrastructure will conveniently cache the exception and re-throw it when I call EndInvoke. However, the issue is that this is happening in an AsyncCallback delegate on a threadpool thread and so I cannot catch it easily in this construct. Why is that a problem? well since .NET 2.0 an unhandled exception on a background thread will terminate the process. This means to reliably call EndInvoke in an AsyncCallback we must put it in a try … catch. This is annoying code to reliably put in place and is easily forgotten. So I have written an extension method to wrap this functionality for you

public static class Extensions
{
public static AsyncCallback Try(this AsyncCallback cb, Action<Exception> exceptionAction)
{
    AsyncCallback wrapper = delegate(IAsyncResult iar)
    {
      try
      {
        cb(iar);
      }
      catch (Exception e)
      {
        exceptionAction(e);
      }
    };
    return wrapper;
}
}>

So this code extends AsyncCallback and takes a delegate to call if an exception takes place it then wraps its own AsyncCallback around the one passed in this time putting it in a try … catch block. The usage looks like this:

Action a = DoStuff;
AsyncCallback cb = ia => a.EndInvoke(ia);
a.BeginInvoke(cb.Try(e => Console.WriteLine(e)), null);>

The only awkward thing here is having to take the lambda out of the call to BeginInvoke because the C# compiler won’t allow the dot operator on a lambda (without casting it to an AsyncCallback) but at least this wraps up some of the issues

VSTS Load/Web Testing and Browser Definitions

When you add a VSTS load test or when you configure a web test you can specify the browser(s) to use for the test. The data for each type of browser is held in files with a .browser extension in the C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\Templates\LoadTest\Browsers directory.

You can add your own browsers to this list by copying and renaming one of these files and changing the details within the file. The files are XML so this is easy to do, they look something like this

<Browser Name="Netscape 6.0">
  <Headers>
    <Header Name="User-Agent" Value="Mozilla/5.0 (Windows; U; Windows NT 5.0; en; rv:1.0) Netscape/6.0" />
    <Header Name="Accept" Value="image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, */*" />
    <Header Name="Accept-Language" Value="{{$IEAcceptLanguage}}" />
    <Header Name="Accept-Encoding" Value="GZIP" />
  </Headers>
</Browser>

Remember to change the Name attribute on the Browser element otherwise you'll see the same browser listed twice inside visual studio.

After making the changes you will need to re-start Visual Studio to see your new browser listed.

WF4: Why do I have to pass the context to get data from an argument?

I talked about the new WF4 Runtime model a while back. One of the things I discussed was the new data flow model of arguments and variables. However, if you are used to WF 3.5 something looks a bit odd here. Lets look at a simple activity example:

public class WriteLineActivity : WorkflowElement
{
    public InArgument<string> Text { get; set; }
    protected override void Execute(ActivityExecutionContext context)
    {
        Console.WriteLine(Text.Get(context));
    }
}

Why do I need to pass the ActivityExecutionContext when I want to get the data from the argument? This highlights a subtlety to the change in the runtime model. The activity is really just a template. A class called ActivityInstance is the thing that is actually executed, it just has a reference to the actual activity to be able to hand off to the activty’s methods (e.g. Execute). The actual argument state is stored in a construct called the LocalEnvironment. The ActivityExecutionContext gives access to the current ActivityInstance and that in turn holds a reference to the current LocalEnvironment. Therefore, to get from an activity’s Execute method to its state we have to go via the ActivityExecutionContext.

BlobExplorer Released on to CodePlex

I’ve finally got round to pushing the code for BlobExplorer to CodePlex. You can find the CodePlex site here. If you want to contribute to the project, let me know at richard at nospam dotnetconsult dot co dot uk and I’ll add you to the contributors list. The releases will continue being pushed to blob storage http://dotnetconsult.blob.core.windows.net/tools/BlobExplorer.zip

Mapping from Business Objects to DTOs – Enter AutoMapper

A while back I did this post talking about how WCF contract definitions should model the messages being passed and not use business objects. This inevitably means that you have to translate from the Data Transfer Object (DTO) in the contract to business object and back again. This can feel like a lot of overhead but it really does protect you from a lot of heartache further down the line.

However Dom just pointed out the AutoMapper to me. This is in its early stages but looks like the kind of library that will really take away a lot of the grunt work associated with using DTOs – kudos!

BlobExplorer Now Supports Blob Metadata

I've just dropped a new release of Blob Explorer for managing Windows Azure Blob Storage

Two new features:

Blob metadata can now be added and viewed
There is a status bar to show that long running uploads and downloads are in progress

As always you can get it from blob storage here

http://dotnetconsult.blob.core.windows.net/tools/BlobExplorer.zip

WCF, Messages and DataSets … Oh My!

Sometimes you have to wonder if this subject will ever go away …

A few weeks ago I posted on using OO constructs in your DataContracts. It’s one of those things that is understandable when .NET developers first start building message based systems. Another issue that raises its head over and over again goes along the lines of “I’m trying to send a DataSet back to my client and it just isn’t working properly”. This reminds me of the old joke:

Patient: Doctor, doctor it hurts when I do this (patient raises his arm into a strange position over his head)
Doctor: Well don’t do it then

So what is the issue with using DataSets as parameters or return types in your service operations?

Lets start off with interoperability – or the total lack thereof. If we are talking about interoperability we have to think about what goes into the WSDL for the DataSet – after all it is a .NET type. In fact DataSets, by default serialize as XML so surely it must be ok! Here’s what a DataSet looks like in terms of XML Schema in the WSDL

<xs:sequence>
<xs:element ref="xs:schema" />
<xs:any />
</xs:sequence>

In other words I’m going to send you some … XML – you work out what do with it. But hold on – if I use Add Service Reference, it *knows* its a DataSet so maybe it is ok. Well WCF cheats; just above that sequence is another piece of XML

<xs:annotation>
    <xs:appinfo>
       <ActualType Name="DataSet" Namespace="http://schemas.datacontract.org/2004/07/System.Data"
                          xmlns="http://schemas.microsoft.com/2003/10/Serialization/" />
</xs:appinfo>
</xs:annotation>

So WCF cheats by putting an annotation only it understands into the schema so it knows to use a DataSet. If you really do want to pass back arbitrary XML as part of a message then use an XElement.

So how about if I have WCF on both ends of the wire? Well then you’ve picked a really inefficient way to transfer around the data. You have to remember how highly functional a DataSet actually is. Its not just the data in the tables that support that functionality, there is also : change tracking data to keep track of what rows have been added, updated and removed since the DataSet was filled; relationship data between tables; a schema describing itself. DataSets are there to support disconnected processing of tabular data, not as a general purpose data transfer mechanism.

Then you may say – “hey we’re running on an intranet – the extra data is unimportant”. So the final issue you get with a DataSet is tight coupling of the service and the consumer. Changes to the structure of the data on one side of the wire cascade to the other side to someone who may not be expecting the changes. Admittedly not all changes will be breaking ones but are you sure you know which ones will be and which ones won’t. As long as the data you actually want to pass isn’t changing why are you inflicting this instability on the other party in the message exchange. The likelihood that you will have to make unnecessary changes to, say, the client when the service changes is increased with DataSets

So what am I suggesting to do instead? Instead model the data that you do want to pass around using DataContract (or XElement if you truly want to be able to pass untyped XML). Does this mean you have to translate the data from a DataSet to this DataContract when you want to send it? Yes it does, but that code can be isolated in a single place. When you receive the data as a DataContract and want to process it as a DataSet, does this mean you have to recreate a DataSet programmatically? Yes it does, but again you can isolate this code in a single place.

So what does doing this actually buy you if you do that work? You get something which is potentially interoperable, that only passes the required data across the wire and that decouples the service and the consumer.

Workflow 4.0 Services and “InvalidOperationException: DispatchOperation requires Invoker”

I’ve been writing a lab on Workflow Services in 4.0 recently. Part of what I was showing was the new data orientated correlation (the same kind of mechanism that BizTalk uses for correlation). So I wanted to have two operations that were correlated to the same workflow instance based on data in the message (rather than a smuggled context id as 3.5 does it). As I was writing this lab I suddenly started getting an InvalidOperationException stating DispatchOperation requires Invoker every time I brought the .xamlx file up in a browser. It appeared that others had seen this as well but not really solved it. So I dug around looking at the XAML (workflow services can be written fully declaratively now) and the config file and could see no issues there. I asked around but no one I asked knew the reason.

So I created a simple default Declarative Workflow Service project and that worked ok. I compared my lab workflow and the default one and it suddenly dawned on me what was wrong. The default project has just one operation on the contract and has a ServiceOperationActivity to implement it. My contract had my two operations but I had, so far, only bound one ServiceOperationActivity. So in other words I had not implemented the contract. This is obviously an issue and looking back I’m annoyed I didn’t see it sooner.

However, the problem is that this is a change in behavior between 3.5 and 4.0. In 3.5 if I didn’t bind a ReceiveActivity to every operation I got a validation warning but I could still retrieve metadata; in 4.0 you get a fatal error. Its not hugely surprising that the behavior has changed – after all the whole infrastructure has been rewritten.

On the whole its a good thing that implementation of the contract is enforced – although it would be nice if the validation infrastructure caught this at compile time rather than it being a runtime failure.

Dynamic hosting of WCF Services

A forum question was asking how to create a host that dynamically loaded up services deployed in DLLs. I told the poster to use reflection but he wasn't familiar with it so I thought I would quickly knock up a sample

The host looks in a folder under the directory in which it is executing. The service must be annotated with a [ServiceClass] attribute (defined in a library that accompanies the host). Then you set up the config file for the service ( [ServiceBehavior(ConfigurationName="<some name>")] helps decouple the config from the actual implementing type nicely

The sample is here

DynamicHost.zip (77.07 KB)

Fix to BlobExplorer

Christian found a bug in BlobExplorer when the blob name has pseudo directory structure in it (common prefixes)

Fixed version is available here

WCF Sessions

Hanging out on the WCF Forums, it appears one in five answers I give seem to be to do with sessions in WCF. As a result, rather than write the same thing over and over again I decided to distil my forum posts into a blog post that I can link to.

WCF has the concept of a session. A session is simply an identifier for the proxy making the call. Where does this ID come from? Well it depends on the binding: with NetTcpBinding, the session is inherent in the transport – TCP is a connected session based transport; with WSHttpBinding session is an artifice piggybacking either WS-SecureConversation or WS-ReliableMessaging. So different bindings go via different mechanisms to achieve the concept of session. However, not all bindings support session – BasicHttpBinding, for example, has no mechanism for maintaining a session. Be aware that every mechanism for maintaining a session in WCF has issues with load balancing. The relationship between proxy and service is a machine-bound one. If you want to use load balancing you will have to use sticky sessions.

So what does having a session do for me? Well some parts of the infrastructure rely on sessions – callbacks for example. WCF also supports the ability to associate a specific instance of the service implementation class with a session (called PerSession instancing). Having a specific instance for the session can seem very attractive in that it allows you to make multiple calls to a service from a specific proxy instance and the service can maintain state in member variables in that service instance in behalf of the client. In fact, if the binding supports session, this is the default model for mapping service instances to requests. WCF also supports two other instancing models (controlled by the service behavior InstanceContextmode): PerCall – each request gets its own instance; Single – all calls use a single instance.

Session has an impact beyond the service – client proxy behavior is affected by the idea of session. Say the client crashes, what happens to the session? Again this depends on the binding. NetTcpBinding is connection orientated so the service side gets torn down if the client crashes. WSHttpBinding on the othe hand rides on top of a connectionless protocol (HTTP) and so if the client crashes the service has no idea. In this situation the session will eventually time out depending on the configuration of WS-SecureConverstion or WS-ReliableMessaging – the default is 10 minutes. To tear down the session the proxy has to call back to the service to say that it is done. This means that closing the proxy in the client is crucial to efficient session management and that Close with WSHttpBinding will actually roundtrip to the service. If the service has died, Close, in this situation will throw an exception and you must call Abort to clean up the proxy correctly.

Session also has effects that are often hidden during development. WCF has an inbuilt throttle to control concurrent operations. There are three throttles: concurrent requests (self explanatory); concurrent objects (remember that there are options as to how many service instances service requests – in reality this one is very unlikely to affect you); and most importantly for the discussion here, concurrent sessions – this defaults to 10. So if you do not clean up your proxy by default your service will support up to 10 concurrent proxies which is generally way too low for many systems.

Sometimes your service will require the ability to maintain per client state. However, due to the complexity of dealing with sessions it is often best to avoid them (unfortunately impossible with the NetTcpBinding) and use another, applkication defined, session identifier and put the session state in a database. However, for example with callbacks, sometimes you require session in your service. In this case you should annotate your contract with the modified ServiceContract

[ ServiceContract(SessionMode=SessionMode.Required)]>

If you do not need session and you do not need to use a session orientated protocol like named pipes or tcp then I would turn off session explicitly by using the following on the contract

[ ServiceContract(SessionMode=SessionMode.NotAllowed)]>

In my experience it is rarely useful to use sessions and they introduce overhead, load balancing restrictions and complexity for the client.

WCF Contracts, Object Orientation and ServiceKnownType

I’ve recently started hanging out on the MSDN WCF forum. Its interesting seeing the questions that are coming up there. One fairly common one is along the lines of:

I have a service that I want to return a list of Person objects but it doesn’t seem to be working when I pass Employees and Managers in the list.

At some point someone will reply

You should annotate the contract with the ServiceKnownType attribute for each type that the Person could be.

Now in a strict sense this is true – however, I think there is a much deeper question that needs discussion.

To understand where the basic problem is we need to take a quick detour into the architecture of WCF. WCF has two layers: the channel layer and the service model layer.

The channel layer deals with Message objects passing them through a composable stack of channels which add or process message headers, handle mapping the Message object to and from a stream of bytes and moving those bytes from one place to another. Notice here we have no notion of ServiceContracts, etc. All messages are untyped in .NET terms are are expressed in terms of an XML Infoset.

The service model layer sits on top of the channel layer and deals with endpoints, behaviors, dispatchers and other bits of plumbing – but the phrase “sits on top of the channel layer” is hugely important. An endpoint is made up of three elements: an address (where), a binding (how) and a contract (what). It is the contract that often causes confusion. In WCF code it takes the form of an annotated interface (can be a class but an interface is more flexible)

[ServiceContract]
interface ICalc
{
[OperationContract]
int Add( int x, int y);
}

But what do the parameters and return types really mean? What you are in fact doing here is specifying the request and response message bodies. This information will be translated into XML by the time the Message hits the channel layer. Now here we have only used simple types. The data that we generally want to move around is more complex and so we need another way to describe it – for that we use a .NET type and a serializer that translates an object into XML and back again. There are two main serializers that can be used: the long standing XmlSerializer and the DataContractSerializer that was introduced with WCF; the DataContractSerializer is the default one. You normally take a .NET class and annotate is with attributes (although .NET 3.5 SP1 removed the need to do this its generally a good idea anyway as you retain control over XML namespaces, etc)

[DataContract(Namespace=”urn:person”)]
class Person
{
public string Name{ get; set; }
public int Age{ get; set; }
}

[ServiceContract]
interface IMakeFriends
{
[OperationContract]
void AddFriend( Person p );
}

So far so good. So where is the problem? Well now we’re in .NET type system world so it starts to become tempting to pass types that derive from person to the AddFriend method – after all the C# compiler doesn’t doesn’t complain. And at this point when you call the AddFriend method it doesn’t work and so you post the above question to the WCF forum. Unfortunately the way that contracts are expressed in WCF makes is very easy to forget what their purpose is: to define the messages send to the operation and being sent back from the operation. In reality you have to think “how would I express this data in XML?”. XML doesn’t support inheritance so whatever you put in the contract is going to have to have some way of mapping to XML. The data contracts used to define the messages are simply a .NET typed convenience for generating the XML for the data you want to pass – if you view them any other way you are destined for a world of pain. So think about the data you want to pass, not how it may happen to be represented in your business layer and design your DataContracts accordingly.

“But wait!” you may say “I may want to pass and Employee or a Manager here and I need the data to get to the receiver”. Again it comes back to “how would I express that in XML?” as that is what will be happening at the end of the day. If you have a discrete set of types that could be passed then you have something similar to a XML Schema Choice Group. In this case ServiceKnownType is a reasonable approach (although it doesn’t use a Choice Group under the covers). Remember you will need to change the contract if new types need to be passed – as with Choice Groups. However, if you require looser semantics where an extensible number of things may be passed without wanting to change the contract then you require a different way of expressing this in XML and therefore a different way of expressing this in .NET code. Something like:

[DataContract]
public class KeyValuePair
{
[DataMember]
public string Key { get; set; }
[DataMember]
public string Value { get; set; }
}>

[DataContract]
public class FlexibleData
{
[DataMember]
public string Discriminator { get; set; }
[DataMember]
public List<KeyValuePair> Properties { get; set; }
}

In this case the receiver will be responsible for unpicking the Properties based on the Discriminator. The other thing you could do is to pass the data as an XElement and work explicitly at the XML level, with LINQ to XML this is not very onerous. Is this all really convenient to use in .NET? Well not as easy as inheritance, but then we’re actually talking about XML here not .NET. Again, the .NET typed contract is simply a convenience for creating the XML message.

Turning off #region and red squiggly lines

With any development environment I go through a series of stages:

Love - this thing is awesome I never realised how great life would be with these new features
Hate - Man why does it do these stupid things, it really detracts from the new cool features
Acceptance - well it has foibles but generally I get my job done faster

I've been in 3 with VS 2008 for some time now but two things have always irked me:

When I type a method I get error red lines appear due to syntax errors like this:

Well obviously I get an error - I haven't finished typing yet! I find these sorts of errors very distracting.

The other issue is with implementing interfaces - I love the feature where I can specify a class implements an interface and then press Ctrl+. [Enter] and it puts a skeleton implementation in for me. What I have always found annoying though is the #region if surrounds the implementation with:

So I was looking around the C# editor options today and found I could turn both of these off.

I think I may be heading back to phase 1 of my relationship with VS2008 now :-)

Ruby 1.9 and Active Record

I'm trying to use ActiveRecord outside of Rails and with Ruby 1.9. I kept getting an error

/opt/local/lib/ruby1.9/gems/1.9.1/gems
        /activerecord-2.2.2/lib/active_record/base.rb:394:in `<class:Base>': 
        undefined method `cattr_accessor' for ActiveRecord::Base:Class 
        (NoMethodError)
	from /opt/local/lib/ruby1.9/gems/1.9.1/gems/activerecord-
        2.2.2/lib/active_record/base.rb:391:in 
        `<module:ActiveRecord>'
	from /opt/local/lib/ruby1.9/gems/1.9.1/gems/activerecord-           
        2.2.2/lib/active_record/base.rb:4:
        in `<top (required)>'
	from /opt/local/lib/ruby1.9/gems/1.9.1/gems/activerecord-
        2.2.2/lib/active_record.rb:34:
        in `require'
	from /opt/local/lib/ruby1.9/gems/1.9.1/gems/activerecord-
        2.2.2/lib/active_record.rb:34:
        in `<top (required)>'
	from /opt/local/lib/ruby1.9/gems/1.9.1/gems/activerecord-
        2.2.2/lib/activerecord.rb:1
        :in `require'
	from /opt/local/lib/ruby1.9/gems/1.9.1/gems/activerecord-
        2.2.2/lib/activerecord.rb:1:
        in `<top (required)>'
	from SimpleTest.rb:2:in `require'
	from SimpleTest.rb:2:in `'

so and undefined method cattr_accessor in ActiveRecord::Base.

Trying the same code in 1.8 worked fine. After much searching I discovered that ActiveSupport had to be installed. This looked like it was installed when I installed ActiveRecord, but it possibly wasn't a complete install.

so after a

sudo gem install ActiveSupprt

I'm good to go

Ruby

Running the latest version of Rails

By this I mean running the latest Gem version not Edge. In config/environment.rb is a line that says something like

RAILS_GEM_VERSION = '2.1.0' unless defined? RAILS_GEM_VERSION

You can either set this to a specific version or if you want to run off the latest installed (Gem) version then simply comment out the line

Rails