Sean Blakemore's Blog

Silencing a 3D Printer - Stepper Dampers

Thu, 26 Jun 2014 10:26:00 +1800

I recently built a new 3D printer, my second after the MendelMax I’ve been running for a few years now. I went with a Kossel Mini, it’s an amazing little machine and since it’s designed to print only in PLA it can sit right next to me on the desk without filling the room with nasty ABS fumes.

That’s all well and good but if you’ve ever sat next to a 3D printer you know that they can be pretty noisy. Especially one as fast as the Kossel Mini, it can be really distractingly loud. After searching around for solutions I came across some whispers of a product on a 3D printing forum about stepper dampers and just how much of an amazing difference they made. It seems there is still very little awareness of these little gems in the community but the few that have tried them are adamant that it’s the best upgrade they’ve ever done!

As you can see they are made from two metal elements joined by a rubber gasket between them. One side bolts to the motor and the other to your printer as normal, this leads to the motor to be fully isolated from the printer. The rubber is formulated to dampen the specific frequencies the motors produce and is very stiff, with the amount a printers belts are tightened there is no danger of problems caused by the rubber flexing and moving.

So… do they work? Well as with the few others than have tried them I can say with certainty that they are simply jaw-droppingly amazing! I can now sit right next to the printer and completely forget it is even running. Check out this video I made to show the difference.

I now couldn’t live without these!

As you can see the difference is around 17dB! Nothing more to be said, they really are that good!

What JavaScript taught me about C# – Understanding ‘Access to modified closure’

Wed, 09 May 2012 14:04:00 +1800

Background

If you’ve spent any time writing C# using a copy of ReSharper you will have come across the phrase ‘Access to modified closure’. It’s a well known warning and there are plenty of StackOverflow questions and blog posts about it.

I’ve personally run up against this many times, and although I know what to do when it bites me, I’ve never really understood why it was happening. It just never really clicked for me.

Not until recently that is, when I decided it was time for me to become a JavaScript programmer instead of a jQuery programmer and actually learn the language properly!

The Warning

Here is some code, as simple as I could make it, that produces the warning and illustrates the behaviour:

var actions = new Action[5];

for (int i = 0; i < actions.Length; i++)
    actions[i] = () => Console.WriteLine(i);

foreach (var action in actions)
    action();

The ‘Access to modified closure’ is referring to the use of ‘i’, the loop variable, inside the lambda and being passed to ‘Console.WriteLine’. If you haven’t run into this before you’ll be surprised to find that this code will produce the following output:

The way to produce the behaviour you would have been expecting is to make a copy of the loop variable inside the loop and use that instead:

var actions = new Action[5];

for (int i = 0; i < actions.Length; i++)
{
    var local = i;
    actions[i] = () => Console.WriteLine(local);
}

foreach (var action in actions)
    action();

This will now produce:

Ok, that’s all well and good, we can now easily enough fix this problem if we run into it. Doesn’t it just feel a bit weird though? Why would making a copy of the variable and then passing that to ‘Console.WriteLine’ actually change the output?

Epiphany

Everywhere else I’ve read about this talks about ‘capturing variables’ or ‘closing over variables’. Sometimes all it takes is a particular combination of words, just the right phrasing, to make you feel that you really understand something.

It wasn’t quite correct to say that JavaScript taught me anything about C#, it was actually Douglas Crockford, it was in his book “The Good Parts” that I found just the right way of explaining closures. Here is the magic sentence:

“It is important to understand that the inner function has access to the actual variables of the outer functions and not copies”

So the lambdas have access to the actual variable ‘i’ and not a copy with the value at the time the lambda was created. Because the loop has finished and ‘i’ has been incremented to 5 by the time we execute the lambdas, that is what we see. On The other hand if we create a variable which is local to the loop then the lambda has access to the value at the time because the local variable is created for each iteration!

Now consider this code:

var i = 1;

Action action = () => Console.WriteLine(i);

i++;

action();

Which will output:

And this code:

var i = 1;

var j = i;
Action action = () => Console.WriteLine(j);

i++;

action();

Which will output:

Brilliant! How did I not fully grasp this before?

Breaking change in C# 5

Using Visual Studio 2010 and .Net 4, if we change the problem code to use a ‘foreach’ loop instead we have the same problem because the loop variable is reassigned for each iteration instead of being recreated:

var values = new[] { 0, 1, 2, 3, 4 };
var actions = new List<Action>();

foreach (var v in values)
{
    actions.Add(() => Console.WriteLine(v));
}

foreach (var action in actions)
    action();

And this will output:

It’s ‘4’ and not ‘5’ this time because in the ‘for’ the loop variable will be incremented to the point that the test in the second statement of the declaration fails and the loop exits.

This is as we would expect given the explanation above, however there is a twist! If you take this code and compile it Visual Studio 2011 using .Net 4.5 then you will get this following output:

Well what do you know, they “fixed” it. Not that it was really broken in the first place, just unexpected unless you properly understand closures. This was achieved by making it such that the variable is now logically declared inside the loop. Be aware however, they didn’t change the ‘for’ loop and that still works as before.

Doing indecent things with Mono.Cecil - An alternative to ILMerge for WPF

Thu, 05 Apr 2012 16:20:00 +1800

Background

ILMerge is a great tool for merging .NET assemblies, when we want to deploy an application as a single executable file we can merge in the dependencies and we’re good to go.

Unfortunately ILMerge doesn’t work on WPF applications because according to the ILMerge page on Microsoft Research:

They contain resources with encoded assembly identities. ILMerge is unable to deserialize the resources, modify the assembly identities, and then re-serialize them.

The Fix

There has been an alternative floating around for some time which can be seen here, but in short you can add the DLLs your application depends upon as an embedded resource and then load them in the AssemblyResolve event for the AppDomain. Here is the code reproduced, it’s pretty short and to the point:

AppDomain.CurrentDomain.AssemblyResolve += (sender, args) => 
{
   String resourceName = "AssemblyLoadingAndReflection." +
      new AssemblyName(args.Name).Name + ".dll";

   using (var stream = Assembly.GetExecutingAssembly()
                          .GetManifestResourceStream(resourceName)) 
   {
      Byte[] assemblyData = new Byte[stream.Length];
      stream.Read(assemblyData, 0, assemblyData.Length);
      return Assembly.Load(assemblyData);
   }
};

The End?

Great, so why am I writing another blog post about this? Well there are a couple of problems with this solution on it’s own.

Adding these assemblies to your Visual Studio solution and setting them to Embedded Resource feels pretty messy and on a large project you can easily build up quite a few referenced DLLs. This is even worse when trying to embed libraries which are a project in the same solution.
You can’t easily add the AssemblyResolve hook in your WPF application early enough, before it tries to load your referenced libraries. You have to shim the WPF App class with another class that has a Main method, make this the program startup object, then from there you can add the hook and run the WPF App.Main method. Obviously not ideal.
If you’re distributing a library rather than an application, and have other libraries merged in as resources, there isn’t anywhere you can properly attach the hook and have everything work as expected.

The Redux

There is a little-known feature of the CLR called a Module Initializer which is simply a global function which runs when a managed module first loads and is guaranteed to run before any other code. This looks like the perfect place to hook the AssemblyResolve method, it would allow us to use this technique in libraries and it would also remove the need to shim the WPF App class.

Wait a second, that sounds really neat, how come I’ve never heard of this before? Simple, although they’re a feature of the CLR they are not exposed in C#. There is no way to create them! We can still use them though, by injecting the IL for the implementation using Mono.Cecli. There is a great post about how to do that here.

Things get slightly hairy when you start talking about rewriting assemblies and injecting IL but it really isn’t too bad and Mono.Cecil makes things easy.

But just hang on one second, if we’re doing this post-build and modifying the assembly, why can’t we also inject the implementation for the AssemblyResolve event, not just the hook, and for that matter why don’t we embed the assemblies at this point also. If we could do all this, surely we could take a pre-built application which has no special code to enable any of this, like when using ILMerge, and then inject the required code, embed the assemblies and everything should just work!

The Code

At this point I think I’m just going to dump the code on you, there isn’t too much of it but it does deal with some complex things so if you want to dig into it you can. All up there is about 150 lines of code in total, which is pretty nuts if you think about what it’s actually doing…

First up we have a console application with the following Main method:

static void Main(string[] args)
{
    var path = args[0];
    var dlls = Directory.GetFiles(Path.GetDirectoryName(path), "*.dll");
    var targetAssembly = AssemblyDefinition.ReadAssembly(path);

    var packer = new Packer(targetAssembly);
    packer.Embed(dlls);
    packer.Inject();

    targetAssembly.Write(path);
}

So we expect to be passed the path to an executable and we assume that we should merge all of the DLL files in the same directory as the executable. Then we use the nifty Packer class to embed the DLLs and inject the required IL.

Take a deep breath because here is the Packer class in full:

internal class Packer
{
    private readonly AssemblyDefinition assembly;

    public Packer(AssemblyDefinition assembly)
    {
        this.assembly = assembly;
    }

    public void Embed(IEnumerable<string> files)
    {
        foreach (var file in files)
        {
            var data = File.ReadAllBytes(file);
            var resourceName = string.Format("{0}.{1}", assembly.Name.Name, Path.GetFileName(file));
            var resource = new EmbeddedResource(resourceName, ManifestResourceAttributes.Private, data);
            assembly.MainModule.Resources.Add(resource);
        }
    }

    public void Inject()
    {
        var assemblyResolve = DefineOnAssemblyResolveMethod();
        var ctor = DefineModuleCtor(assemblyResolve);

        var moduleType = assembly.MainModule.Types.Single(x => x.Name == "<Module>");
        moduleType.Methods.Add(assemblyResolve);
        moduleType.Methods.Add(ctor);
    }

    private MethodDefinition DefineOnAssemblyResolveMethod()
    {
        var method = new MethodDefinition("OnAssemblyResolve",
            MethodAttributes.Private |
            MethodAttributes.HideBySig |
            MethodAttributes.Static,
            ImportType<Assembly>());
        method.Parameters.Add(new ParameterDefinition(ImportType<object>()));
        method.Parameters.Add(new ParameterDefinition(ImportType<ResolveEventArgs>()));

        method.Body.Variables.Add(new VariableDefinition(ImportType<Assembly>()));
        method.Body.Variables.Add(new VariableDefinition(ImportType<string>()));
        method.Body.Variables.Add(new VariableDefinition(ImportType<Stream>()));
        method.Body.Variables.Add(new VariableDefinition(ImportType<byte[]>()));
        method.Body.InitLocals = true;

        var il = method.Body.GetILProcessor();
        il.Emit(OpCodes.Call, ImportMethod<Assembly>("GetEntryAssembly"));
        il.Emit(OpCodes.Stloc_0);
        il.Emit(OpCodes.Ldstr, "{0}.{1}.dll");
        il.Emit(OpCodes.Ldloc_0);
        il.Emit(OpCodes.Callvirt, ImportMethod<Assembly>("GetName", new Type[0]));
        il.Emit(OpCodes.Callvirt, ImportMethod<AssemblyName>("get_Name"));
        il.Emit(OpCodes.Ldarg_1);
        il.Emit(OpCodes.Callvirt, ImportMethod<ResolveEventArgs>("get_Name"));
        il.Emit(OpCodes.Newobj, ImportCtor<AssemblyName>(typeof(string)));
        il.Emit(OpCodes.Call, ImportMethod<AssemblyName>("get_Name"));
        il.Emit(OpCodes.Call, ImportMethod<string>("Format", typeof(string), typeof(object), typeof(object)));
        il.Emit(OpCodes.Stloc_1);
        il.Emit(OpCodes.Ldloc_0);
        il.Emit(OpCodes.Ldloc_1);
        il.Emit(OpCodes.Callvirt, ImportMethod<Assembly>("GetManifestResourceStream", typeof(string)));
        il.Emit(OpCodes.Stloc_2);
        il.Emit(OpCodes.Ldloc_2);
        il.Emit(OpCodes.Brfalse_S, il.Create(OpCodes.Ldnull));
        il.Emit(OpCodes.Ldloc_2);
        il.Emit(OpCodes.Callvirt, ImportMethod<Stream>("get_Length"));
        il.Emit(OpCodes.Conv_Ovf_I);
        il.Emit(OpCodes.Newarr, ImportType<byte>());
        il.Emit(OpCodes.Stloc_3);
        il.Emit(OpCodes.Ldloc_2);
        il.Emit(OpCodes.Ldloc_3);
        il.Emit(OpCodes.Ldc_I4_0);
        il.Emit(OpCodes.Ldloc_3);
        il.Emit(OpCodes.Ldlen);
        il.Emit(OpCodes.Conv_I4);
        il.Emit(OpCodes.Callvirt, ImportMethod<Stream>("Read", typeof(byte[]), typeof(int), typeof(int)));
        il.Emit(OpCodes.Pop);
        il.Emit(OpCodes.Ldloc_2);
        il.Emit(OpCodes.Callvirt, ImportMethod<Stream>("Dispose"));
        il.Emit(OpCodes.Ldloc_3);
        il.Emit(OpCodes.Call, ImportMethod<Assembly>("Load", typeof(byte[])));
        il.Emit(OpCodes.Ret);
        il.Append(il.Create(OpCodes.Ldnull));
        il.Emit(OpCodes.Ret);

        return method;
    }

    private MethodDefinition DefineModuleCtor(MethodDefinition assemblyResolveMethod)
    {
        var ctor = new MethodDefinition(".cctor",
            MethodAttributes.Static |
            MethodAttributes.SpecialName |
            MethodAttributes.RTSpecialName,
            assembly.MainModule.Import(typeof (void)));

        var il = ctor.Body.GetILProcessor();
        il.Emit(OpCodes.Call, ImportMethod<AppDomain>("get_CurrentDomain"));
        il.Emit(OpCodes.Ldnull);
        il.Emit(OpCodes.Ldftn, assemblyResolveMethod);
        il.Emit(OpCodes.Newobj, ImportCtor<ResolveEventHandler>(typeof(object), typeof(IntPtr)));
        il.Emit(OpCodes.Callvirt, ImportMethod<AppDomain>("add_AssemblyResolve"));
        il.Emit(OpCodes.Ret);

        return ctor;
    }

    private TypeReference ImportType<T>()
    {
        return assembly.MainModule.Import(typeof(T));
    }
    private MethodReference ImportMethod<T>(string methodName)
    {
        return assembly.MainModule.Import(typeof(T).GetMethod(methodName));
    }
    private MethodReference ImportMethod<T>(string methodName, params Type[] types)
    {
        return assembly.MainModule.Import(typeof(T).GetMethod(methodName, types));
    }
    private MethodReference ImportCtor<T>(params Type[] types)
    {
        return assembly.MainModule.Import(typeof(T).GetConstructor(types));
    }
}

If you just let your eyes glaze over the il.Emit calls, this is pretty easy to follow. You can just assume that all the IL is the implementation of the AssemblyResolve event and the hook for it in the Module Initializer. We just add the definition of these methods and add the DLLs as resources and Mono.Cecil does the rest.

The proof is in the pudding

I was able to run the above code against a moderately large WPF application which has been under development for quite some time, and in production for over 6 months, without any thought of merging dependencies. The EXE file got considerably larger. I then deleted all the DLLs from the directory and somewhat to my surprise the application ran without any issues!

The ultimate test of something like this is whether it can merge itself. Obviously the Packer class makes heavy use of Mono.Cecil to get the job done so my console application has a reference to that DLL. Happily I can report that running this 150 lines of code application on itself successfully produces a single EXE file with Mono.Cecil packed inside and everything works as it should.

Conclusion

I was actually playing around with this almost exactly a year ago, when I ran across the code I thought it might be a bit of fun and I should write it up for a blog post. It has no real error handling and has not been thoroughly tested or used in production. As such please consider it a sample and proof of concept only. Don’t blame me if it kills your pet or anything.

Here is the sample:

Packager.zip

Multiple login pages with ASP.NET MVC

Tue, 20 Mar 2012 11:44:00 +1800

I’m working on a multi-tenant web application where I need to have several different login forms for different types of users. For example for Admins, Affiliates, Customers etc.

The problem

This causes a problem because the Forms Authentication bits assume there will be a single login page for the whole application and it’s only possible to set a single loginUrl in the web.config to redirect users requesting pages which require authentication.

The solution

There are a couple of solutions floating around but most of them feel really dirty. You also can’t get away with putting another authentication element in a web.config file in a subfolder of your site because:

It is an error to use a section registered as allowDefinition='MachineToApplication' beyond application level.

In my case things are slightly more complicated because I will be composing my application from modules which are loaded in at runtime. These modules can also add their own login pages so I need something extensible.

No, really - the solution

We can’t fight that ASP.NET will only support redirecting to a single location, so let us instead redirect to a location whose ‘single responsibility’ is to forward the user to the login page they actually need. Enter the LoginRedirectController!

public class LoginRedirectController : Controller
{
    public ActionResult Index(string returnUrl)
    {
        //TODO: Redirect!
    }
}

And then we need to register this in the web.config as our loginUrl.

<authentication mode="Forms">
  <forms loginUrl="~/LoginRedirect" requireSSL="true" cookieless="UseCookies" />
</authentication>

We’re going to be looking at the returnUrl parameter which ASP.NET populates for us to figure out where to send people from here. I’m breaking up these different sections of the application into MVC Areas and the default behaviour is to have a prefix to the URL for every page in a given area. For example the Admin area has a route which looks like this: Admin/{controller}/{action}/{id}. Fleshing out our LoginRedirectController we arrive at:

private readonly IReturnUrlHandler returnUrlHandler;

public LoginRedirectController(IReturnUrlHandler returnUrlHandler)
{
    this.returnUrlHandler = returnUrlHandler;
}

public ActionResult Index(string returnUrl)
{
    var route = returnUrlHandler.GetRoute(returnUrl);
    return RedirectToRoute(route, new { returnUrl });
}

Nice and simple! We have a (badly named) interface called IReturnUrlHandler and a GetRoute method to which we can pass the returnUrl. The job of the IReturnUrlHandler is simply to map between a returnUrl and a named route. We make sure to pass the returnUrl on to whatever route we’re forwarding to so the user will eventually arrive at whatever page they originally requested after being logged in.

public interface IReturnUrlHandler
{
    void Register(string returnUrlPrefix, string loginRoute);
    string GetRoute(string returnUrl);
}

public class ReturnUrlHandler : IReturnUrlHandler
{
    private const string DefaultRoute = "Home";
    private readonly Dictionary<string, string> redirectRules = new Dictionary<string, string>();

    public void Register(string returnUrlPrefix, string loginRoute)
    {
        redirectRules.Add(returnUrlPrefix, loginRoute);
    }

    public string GetRoute(string returnUrl)
    {
        var key = redirectRules.Keys.FirstOrDefault(x =>
            returnUrl.StartsWith(x, StringComparison.OrdinalIgnoreCase));
        return !string.IsNullOrEmpty(key) ? redirectRules[key] : DefaultRoute;
    }
}

No magic in here at all. We have a register method which allows us to add prefix and route combinations to a dictionary which is then used to resolve the name of a suitable route in our LoginRedirectController. Note that if we don’t find a matching route we send them to one named “Home” which just dumps them back on the root of the site. To use this final piece we just need to add named routes to our different login pages and register them.

context.MapRoute("Admin_Login", "Admin/Login", 
                new { controller = "Auth", action = "Login" });

returnUrlHandler.Register("/Admin", "Admin_Login");

And finally just to complete the picture we have our AuthController in the Admin area.

[HttpGet]
public ActionResult Login()
{
    if (Request.IsAuthenticated)
        return RedirectToAction("Index", "Dashboard");

    return View(new AdminLoginModel());
}

[HttpPost]
[ValidateAntiForgeryToken]
public ActionResult Login(AdminLoginModel input, string returnUrl)
{
    //TODO: Validate username and password against something

    if (ModelState.IsValid)
    {
        formsAuth.SetAuthCookie(input.Username, false);

        //Important! Check IsLocalUrl to prevent open redirection attack!
        if (Url.IsLocalUrl(returnUrl))
            return Redirect(returnUrl);
        return RedirectToAction("Index", "Dashboard");
    }

    return View(new AdminLoginModel { Username = input.Username });
}

Summary

It certainly does the job and is very clean. Perfect for me because my modules can be loaded in at runtime and register their own login pages, it’s up to you whether your situation is something where the benefits of this outweigh the ceremony involved.

DIY PCB Drill Press for $15 (sort of)

Mon, 20 Feb 2012 16:43:52 +1800

I’ve recently been working on producing my own PCBs at home and ran into the problem of how to reliably and accurately drill the holes I needed.

I had a quick search to see how other people were attacking the problem and managed to find a design for a home made drill press on Instructables which was genius in it’s simplicity. Four hinges and some lengths of timber combine to make an almost perfect plunge action with great accuracy. Here is my take on the idea with photos of the mechanism and a quick video showing it in action.

300 x 300mm working area for about $15 in timber and hardware (no, that’s not including the rotary tool!).

Because PCBs are woven fibreglass and epoxy they're tough as anything and we're making tiny holes, usually a millimeter or less. The drill must spin at high RPM to make the outside edge of the tiny diameter bit travel fast enough. This rotary tool will do 35,000 RPM which drives through PCBs like butter.

Hinged rectangle fixed to the back piece means the drill will move vertically with very little arc.

Brackets on either side of the gantry to minimise lateral movement due to slop in the hinges.

Two springs held down by a screw and washer to provide an automatic return. They kept popping out to the sides under load, crossing them over each other seems to keep them in line.

I used to brackets on the solid frame to make sure it wasn't going anywhere.

Small hole drilled all the way through the platform, we don't want the bit hitting the wood.

U-bolts holding the drill in position. I'm using the flexible shaft attachment on a cheapo dremel knock-off.

Tiny 1.05mm tungsten carbide drill bit, these things break very easily.

Power Management in C# – Stop the system or display from sleeping

Sat, 18 Feb 2012 13:23:00 +1800

In a desktop application I’m working on there are a number of long running batch processes that can be run by the user. This caused problems when the user kicked off a batch process and then walked away from the computer, returning a few hours later to find that the system had gone to sleep and the batch had failed!

SetThreadExecutionState

A little searching led me to the unmanaged SetThreadExecutionState function which can be used to tell Windows that the calling thread is doing something important which requires the system to be awake. The function can be used in two ways, it can be called repeatedly to reset the system’s idle timer or it can be used in “continuous” mode where the system should not enter sleep mode until told otherwise. Check the MSDN link above for full details.

How to use it?

I took a trip to pinvoke.net and wrapped the function into a C# class. I implemented IDisposable on the class so that it can be used to scope the work being performed if required.

using (new PowerManager(ExecutionState.SystemRequired, isContinuous: true))
{
    //Do some long running work here
    DoSomeWork();
}

Alternatively, passing isContinuous as false will let you reset the system idle timer as you process work items.

using (var powerManager = new PowerManager(ExecutionState.SystemRequired, isContinuous: false))
{
    for (int i = 0; i < 1000; i++)
    {
        //Do work here
        DoSomeWork();
        //Reset the system idle timer to prevent sleep
        //before processing the next bit of work
        powerManager.ResetTimer();
    }
}

How does it work?

For your copy and pasting pleasure, here is the entire class. Please do thoroughly read the MSDN docs to understand the implications of using these different modes!

[Flags]
public enum ExecutionState : uint
{
    DisplayRequired = 0x00000002,
    SystemRequired = 0x00000001,
    AwaymodeRequired = 0x00000040
}

public class PowerManager : IDisposable
{
    [DllImport("kernel32.dll", CharSet = CharSet.Auto)]
    static extern ExecutionState SetThreadExecutionState(ExecutionState flags);

    private const uint ContinuousFlag = 0x80000000;

    public bool IsContinuous { get; private set; }
    public ExecutionState State { get; private set; }

    public PowerManager(ExecutionState state, bool isContinuous)
    {
        State = state;
        IsContinuous = isContinuous;

        if ((state & ExecutionState.AwaymodeRequired) != 0 && !isContinuous)
            throw new InvalidOperationException("Awaymode is only valid when the state is continuous");

        SetThreadExecutionState(isContinuous ? state | (ExecutionState)ContinuousFlag : state);
    }

    public void ResetTimer()
    {
        if (IsContinuous)
            throw new InvalidOperationException("The execution state is continuous");

        SetThreadExecutionState(State);
    }

    ~PowerManager()
    {
        ClearContinuousState();
    }

    public void Dispose()
    {
        ClearContinuousState();
        GC.SuppressFinalize(this);
    }

    private bool disposed;
    private void ClearContinuousState()
    {
        if (!disposed)
        {
            if (IsContinuous)
                SetThreadExecutionState((ExecutionState)ContinuousFlag);

            disposed = true;
        }
    }
}

Dirty Checking your Silverlight and WPF data entry forms

Sun, 11 Jul 2010 19:36:00 +1800

Let’s just dive right in and have a demo to see what we’re trying to accomplish. Below is a Silverlight application with some interesting behaviour, if you start changing any data the application will notice and the save button becomes enabled, the state of the form is ‘dirty’. That isn’t very interesting on it’s own, what is interesting is that if you then put the data back to the way it was when you started, the save button becomes disabled again and the form returns to the ‘clean’ state. Here, have a play…

How is it done

Ok, pretty cool. Let’s have a look at the code behind file and you will see that there is nothing much going on.

namespace SBlakemore.DirtyChecking
{
    public partial class MainPage
    {
        public MainPage()
        {
            InitializeComponent();
        }
    }
}

And here is the XAML markup for the data entry form, now we’re starting to get some clues about how this is implemented. Note: I’ve removed the UserControl declaration and the styles which are in it’s resource dictionary for clarity, however the StackPanel below is the root of the UserControl.

    <StackPanel>
        <local:Tracker x:Name="tracker" HorizontalContentAlignment="Stretch">
            <Grid Margin="20 20 20 0">
                <Grid.ColumnDefinitions>
                    <ColumnDefinition Width="3*" />
                    <ColumnDefinition Width="7*" />
                </Grid.ColumnDefinitions>
                <Grid.RowDefinitions>
                    <RowDefinition Height="35" />
                    <RowDefinition Height="35" />
                    <RowDefinition Height="35" />
                    <RowDefinition Height="35" />
                </Grid.RowDefinitions>
                
                <TextBlock Text="Artist:" />
                <TextBox local:Tracker.Property="Text" Text="Michael Jackson" />

                <TextBlock Grid.Row="1" Text="Title:" />
                <TextBox Grid.Row="1" local:Tracker.Property="Text" Text="Thriller" />

                <TextBlock Grid.Row="2" Text="Explicit Lyrics:" />
                <CheckBox Grid.Row="2" local:Tracker.Property="IsChecked"/>

                <TextBlock Grid.Row="3" Text="Genre:" />
                <ComboBox Grid.Row="3" local:Tracker.Property="SelectedItem" SelectedIndex="3">
                    <sys:String>Blues</sys:String>
                    <sys:String>Country</sys:String>
                    <sys:String>Jazz</sys:String>
                    <sys:String>Pop</sys:String>
                    <sys:String>Soul</sys:String>
                    <sys:String>Hip Hop</sys:String>
                </ComboBox>
            </Grid>
        </local:Tracker>
        
        <Button Content="Save" Width="80" Height="30" Margin="10"
                IsEnabled="{Binding IsChanged, ElementName=tracker}" />
    </StackPanel>

Looking Closer

There are three things to note here.

I’ve wrapped the data entry controls in something called Tracker.
All of the data entry controls have a value set for an attached property which is defined by Tracker, and that value is the name of the property which holds the data for that particular data entry control. For example for a TextBox the attached property is set to “Text”, and for a Checkbox the attached property is set to “IsChecked”.
The save button is being enabled and disabled by being bound to the IsChanged property on our tracker.

You will probably by now have figured out in principle how this works. When the Tracker control is loaded it recurses through all of it’s children looking for anything which declares a value for Tracker.Property. When it finds one it looks at the value set for Tracker.Property and then finds the DependencyProperty of that name on the declaring control, it will then take a snapshot of the value and subscribe to change notifications from the DependencyProperty. Whenever a change notification is received it will read the new value and compare it to the snapshot to see if the value is ‘dirty’ and has been changed. The IsChanged property on Tracker returns true if one of more of it’s children have changed.

This is pretty cool because implementing this feature in the model quickly becomes a nasty mess of INotifyPropertyChanged madness and as soon as the model and data entry form become anything more than trivial you will run up against complications and edge cases. In addition you end up with event subscriptions everywhere trying to track your properties and because of this could easily cause memory leaks.

Much better to pull this complexity out of your ViewModels and implement it instead as a cross cutting concern which is applied to your data entry forms declaratively.

Show me the Code!

Here is the code for the Tracker class.

public class Tracker : ContentControl
{
    public bool IsChanged
    {
        get { return (bool)GetValue(IsChangedProperty); }
        set { SetValue(IsChangedProperty, value); }
    }
    public static readonly DependencyProperty IsChangedProperty =
        DependencyProperty.Register("IsChanged", typeof(bool), typeof(Tracker), new PropertyMetadata(false));

    public static string GetProperty(DependencyObject obj)
    {
        return (string)obj.GetValue(PropertyProperty);
    }
    public static void SetProperty(DependencyObject obj, string value)
    {
        obj.SetValue(PropertyProperty, value);
    }
    public static readonly DependencyProperty PropertyProperty =
        DependencyProperty.RegisterAttached("Property", typeof(string), typeof(Tracker), new PropertyMetadata(null));

    private readonly Dictionary<PropertyWatcher, object> trackedPropertySnapshot = new Dictionary<PropertyWatcher, object>();
    private readonly List<PropertyWatcher> changedProperties = new List<PropertyWatcher>();
    private readonly object nullProperty = new object();

    public Tracker()
    {
        Loaded += (s, e) =>
        {
            var content = Content as DependencyObject;
            if (content != null)
                WalkDownVisualTree(content);
        };
    }

    public void AcceptChanges()
    {
        changedProperties.Clear();

        IsChanged = false;
    }

    private void WalkDownVisualTree(DependencyObject current)
    {
        var property = current.ReadLocalValue(PropertyProperty);
        if (property != DependencyProperty.UnsetValue)
            RegisterTrackedProperty(current, (string)property);

        var count = VisualTreeHelper.GetChildrenCount(current);
        for (int i = 0; i < count; i++)
        {
            WalkDownVisualTree(VisualTreeHelper.GetChild(current, i));
        }
    }

    private void RegisterTrackedProperty(DependencyObject item, string propertyName)
    {
        var notifier = new PropertyWatcher(item, propertyName);
        notifier.ValueChanged += TrackedPropertyChanged;

        trackedPropertySnapshot.Add(notifier, notifier.Value);
    }

    private void TrackedPropertyChanged(object sender, EventArgs e)
    {
        var notifier = ((PropertyWatcher)sender);
        var original = trackedPropertySnapshot[notifier] jQuery15209391723657026887_1327589005650 nullProperty;
        var current = notifier.Value ?? nullProperty;

        if (!original.Equals(current))
        {
            if (!changedProperties.Contains(notifier))
                changedProperties.Add(notifier);
        }
        else
            changedProperties.Remove(notifier);

        IsChanged = changedProperties.Count != 0;
    }
}

It took me a bit of playing around to figure out how to subscribe to change notifications for the relevant property, something which is not too big of a deal in WPF, and in the end I came up with a very handy little class I called PropertyWatcher. The constructor takes a source object and a string with the name of a property on the source object.

public class PropertyWatcher : DependencyObject
{
    public DependencyObject Source { get; protected set; }

    public PropertyWatcher(DependencyObject source, string propertyName)
    {
        Source = source;

        var path = new PropertyPath(propertyName);
        var binding = new Binding { Path = path, Mode = BindingMode.OneWay, Source = source };
        BindingOperations.SetBinding(this, ValueProperty, binding);
    }

    public static readonly DependencyProperty ValueProperty =
        DependencyProperty.Register("Value", typeof(object), typeof(PropertyWatcher), new PropertyMetadata(null, OnPropertyChanged));

    private static void OnPropertyChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
    {
        var notifier = (PropertyWatcher)sender;
        notifier.ValueChanged(notifier, EventArgs.Empty);
    }

    public object Value
    {
        get { return GetValue(ValueProperty); }
        set { SetValue(ValueProperty, value); }
    }

    public event EventHandler ValueChanged = delegate { };
}

Final Thoughts

It’s a pretty nice feature to be able to not have to prompt a user to save an entity which, in their mind, they haven’t actually changed. I’ve used a specialised and enhanced version of the code above in a pretty complex WPF data entry form and am pleased with how it’s working.

One possible nice enhancement would be to try to encapsulate this into a Behaviour to make the whole thing Blendable.

How do you feel about tracking changes in this way? Code download below.

SBlakemore.DirtyChecking.zip

Bidirectional Integrity: IEnumerable and read only Entity properties

Fri, 12 Mar 2010 13:18:00 +1800

Jimmy Bogard over at LosTechies has a great little series of posts going ahead at the moment on “strengthening your domain”. For the time constrained amongst us, I’ll quickly summarise his points so you can understand what I say here without going back to the source, however please do go ahead and check them out if your haven’t, there is some great advice there:

It’s his most recent post in the series on encapsulated collections which I’d like to talk more about.

Entity relationships and invariants

To quickly summarise Jimmy’s post so we can continue the discussion where he left off, let’s look at some poor code…

public class Customer
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Province { get; set; }
    public List<Order> Orders { get; set; }

    public string GetFullName()
    {
        return LastName + ", " + FirstName;
    }
}

public class Order
{
    public Order(Customer customer)
    {
        Customer = customer;
        customer.Orders.Add(this);
    }

    public Customer Customer { get; set; }
}

What’s wrong with this?

First of all we’re exposing a setter on the Orders property of Customer, exposing a setter on a collection property is bad because it allows calling code to completely replace our collection from under our nose without us knowing.
We’re exposing our concrete List directly, this should be at the very least an IList so we can change our implementation without changing our interface.
It’s clear from the Order constructor that we have a bidirectional relationship here, the invariant is then that when the Customer property of the Order class is set, that Order should be in the Orders collection on the Customer class. Exposing the setter on the Customer property of the Order class and exposing in the Orders property of the Customer class a collection which can be modified allows people to mess with our invariant.

How can we fix it? Here’s Jimmy’s code…

public class Customer
{
    private readonly IList<Order> _orders = new List<Order>();

    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Province { get; set; }
    public IEnumerable<Order> Orders { get { return _orders; } }

    public string GetFullName()
    {
        return LastName + ", " + FirstName;
    }

    internal void AddOrder(Order order)
    {
        _orders.Add(order);
    }
}

public class Order
{
    public Customer Customer { get; protected set; }

    public Order(Customer customer)
    {
        Customer = customer;
        customer.AddOrder(this);
    }
}

Great, so we’ve removed the setters and now we’re only exposing an IEnumerable collection, no one can mess with our invariant and break our behaviour by not understanding our intention!

Looking a little closer

There is another interesting invariant at play in Jimmy’s code above, one of the invariants of the Order class is that it does not make sense to have an Order that is not associated with a Customer. To force the point, Jimmy has made it such that the only way to create an Order is by passing it a Customer as required by the constructor. The Order constructor then in turn calls an internal method on the Customer class to enforce the integrity of our bidirectional relationship. The method is left internal because we don’t want it to be seen everywhere, Orders and Customers should only become related in any way through the Order constructor.

Let’s make things slightly more complex. We’ve had a chat with our domain experts and they’ve told us that our Order which cannot exist without a Customer should also not exist without OrderLines. Ok that’s no problem, we know how to handle that, just more constructor parameters and internal methods!

This is where I start to have a problem, because although our external API is nice and clean, internally our code starts getting harder to understand and bigger in size as we add internal methods here and there.

Extension methods, generics, lambdas and reflection, what else is there in life?

Wouldn’t it be nice if we could add an item to an IEnumerable from another related entity without needing internal methods? Wouldn’t it be nice to be able to set protected properties? Well let’s be gratuitous and slightly immature and find a way to answer these questions using all the cool language features of the day!

Because we don’t want to expose dangerous functionality like this all throughout our application, really its just to help us make a clean API which is implemented cleanly on the inside too, we’re going to stuff everything in our Layer Supertype, you very likely have one for your domain anyway…

protected void SetInaccessibleProperty<TObj, TValue>(TObj target, TValue value,
    Expression<Func<TObj, TValue>> propertyExpression)
{
    propertyExpression.ToPropertyInfo().SetValue(target, value, null);
}

protected TValue GetInaccessibleProperty<TObj, TValue>(TObj target,
    Expression<Func<TObj, TValue>> propertyExpression)
{
    return (TValue)propertyExpression.ToPropertyInfo().GetValue(target, null);
}

protected void AddToIEnumerable<TEntity, TValue>(TEntity target, TValue value,
    Expression<Func<TEntity, IEnumerable<TValue>>> propertyExpression)
{
    IEnumerable<TValue> enumerable = GetInaccessibleProperty(target, propertyExpression);

    if (enumerable is ICollection<TValue>)
        ((ICollection<TValue>)enumerable).Add(value);
    else
        throw new ArgumentException(
            string.Format("Property must be assignable to ICollection<{0}>", typeof(TValue).Name));
}

protected void RemoveFromIEnumerable<TEntity, TValue>(TEntity target, TValue value,
    Expression<Func<TEntity, IEnumerable<TValue>>> propertyExpression)
{
    IEnumerable<TValue> enumerable = GetInaccessibleProperty(target, propertyExpression);

    if (enumerable is ICollection<TValue>)
        ((ICollection<TValue>)enumerable).Remove(value);
    else
        throw new ArgumentException(string.Format("Property must be assignable to ICollection<{0}>",
            typeof(TValue).Name));
}

Yikes, try saying that piece of generic soup five times really quickly after a few beers! But lets go a little further now and use these four methods to create something even more useful…

protected void AddManyToOne<TOne, TMany>(
    TOne one, Expression<Func<TOne, IEnumerable<TMany>>> collectionExpression,
    TMany many, Expression<Func<TMany, TOne>> propertyExpression)
{
    AddToIEnumerable(one, many, collectionExpression);
    SetInaccessibleProperty(many, one, propertyExpression);
}

protected void RemoveManyToOne<TOne, TMany>(
    TOne one, Expression<Func<TOne, IEnumerable<TMany>>> collectionExpression,
    TMany many, Expression<Func<TMany, TOne>> propertyExpression)
    where TOne : class
{
    RemoveFromIEnumerable(one, many, collectionExpression);
    SetInaccessibleProperty(many, null, propertyExpression);
}

protected void RemoveManyToMany<T1, T2>(
    T1 entity1, Expression<Func<T1, IEnumerable<T2>>> expression1,
    T2 entity2, Expression<Func<T2, IEnumerable<T1>>> expression2)
{
    RemoveFromIEnumerable(entity1, entity2, expression1);
    RemoveFromIEnumerable(entity2, entity1, expression2);
}

protected void AddManyToMany<T1, T2>(
    T1 entity1, Expression<Func<T1, IEnumerable<T2>>> expression1,
    T2 entity2, Expression<Func<T2, IEnumerable<T1>>> expression2)
{
    AddToIEnumerable(entity1, entity2, expression1);
    AddToIEnumerable(entity2, entity1, expression2);
}

Note that these are all protected so that they can only be accessed by derived types. The obvious exception being other idiots reflecting on your code! There is one other piece that’s missing, you may have spotted it already, I pulled it out into an extension method because I find it so useful elsewhere…

public static class ExpressionExtensions
{
    public static PropertyInfo ToPropertyInfo(this LambdaExpression expression)
    {
        var prop = expression.Body as MemberExpression;

        if (prop != null)
        {
            var info = prop.Member as PropertyInfo;
            if (info != null)
                return info;
        }

        throw new ArgumentException("The expression target is not a Property");
    }
}

Now we can take a look at how this would leave our Order and Customer class looking…

public class Customer : DomainBase
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Province { get; set; }
    public IEnumerable<Order> Orders { get; protected set; }

    public string GetFullName()
    {
        return LastName + ", " + FirstName;
    }
}

public class Order : DomainBase
{
    public Customer Customer { get; protected set; }

    public Order(Customer customer)
    {
        AddManyToOne(customer, x => x.Orders, this, x => x.Customer);
    }
}

This looks much cleaner and easier to read, and the effect on a larger domain would be dramatic. Comments or criticisms please?

Performance considerations

Yes it’s slower and your application may associate Orders and Customers several orders of magnitude more slowly. What you need to figure out is whether that matters in any way. If associating an Order with a Customer truly is a bottleneck in your application then the only thing I can do is offer my congratulations on how amazing the rest of your code must be and also how many orders per second you must be processing!

Hope this helps!

Silverlight 4 COM Automation – Taking photos with a DSLR using Windows Image Acquisition

Tue, 22 Dec 2009 22:01:00 +1800

Note: This code was written using the PDC09 Beta and may not work without modification on future builds!

Silverlight 4 brings a lot to the table and in my opinion is the most exciting looking release so far. There is a whole slew of new possibilities which have opened up because of a number of important new features, the feature I’m going to be looking at is COM automation.

Huge amounts of functionality built into Windows and installed by third party software is now at your fingertips. So how do we get access to it?

ComAutomationFactory and the ‘dynamic’ keyword

ComAutomationFactory is a new static class in the System.Windows.Interop namespace which exposes three methods and a single property. ‘dynamic’ is a new language keyword available in C# 4.

ComAutomationFactory methods and property

ComAutomationFactory.CreateObject("ProgId");
ComAutomationFactory.GetObject("ProgId");

CreateObject and GetObject allow us to either activate and spin up a new instance, or get a reference to a currently activated and running instance of a given COM server. So for example, you are able to spawn a new copy of Outlook to add a calendar entry or alternatively you can attach to the copy the user is already running.

These methods require the ProgId for the COM server you want to talk to. Each COM object on a computer is uniquely identified by a CLSID (essentially a Guid) which is stored in the registry. A ProgId is a string which maps to a CLSID in the registry, making COM servers much easier to work with, this is much the same as how a domain name maps to an IP address. For example, Outlook can be addressed as “Outlook.Application” instead of {D5CDD1EA-BB6A-4AAF-A3B0-98E5A3B120F4}!

ComAutomationFactory.GetEvent(comObject, "eventName");

GetEvent returns an instance of ComAutomationEvent and is interesting in that it allows us to subscribe to events raised by the COM server, we will be using this later!

ComAutomationFactory.IsAvailable;

The IsAvailable property returns a boolean as you might expect which lets us know if it is possible to use COM automation in the current context. COM automation in Silverlight requires that the application is running Out-Of-Browser and has been given elevated permissions, it is also available only on Windows systems!

The ‘dynamic’ keyword

dynamic is a new type which bypasses static type checking. Sounds confusing but it comes in really handy for working with objects the compiler doesn’t know the exact shape of at design time, so for example objects retrieved via reflection, from a dynamic language like IronPython or IronRuby or indeed COM objects we’ve grabbed by ProgId!

What all this means is that we can declare a variable to be of type dynamic and the compiler will let us call any method or property without complaining about it not being there. These calls are then resolved at run time.

dynamic dyn = "This is actually a string";
//This code builds without complaint from the compiler.
dyn.ThisMethodObviouslyDoesntExistOnAString();
dyn.NorDoesThisProperty = true;

And as you can see below, Visual Studio allows me to do this.

Windows Image Acquisition

Windows Image Acquisition is an API provided by Windows and has been around in the OS since Windows ME in one form or another. WIA allows us to program in a uniform way against any scanner or camera device which has a compatible driver. Windows ME introduced WIA 1.0 which was replaced with WIA 2.0 in Windows Vista, this application was written and tested on Windows 7 and WIA 2.0 so this comes under a “works on my machine” disclaimer!

It is possible to download the WIA 2.0 binaries from Microsoft and register them under Windows XP SP1+, I’ve had this working in the past and is fairly painless so I won’t go into it here.

The reference documentation on MSDN is comprehensive and also handily gives the ProgId for all the different objects making use from Silverlight really easy.

The sample code

To have a little play around with these new features in Silverlight and C# I put together a little application which allows my to take pictures with my WIA enabled Nikon DSLR. Taking photos from a Nikon using a browser plug-in, crazy!?!

First of all we need to let the user choose a device to take pictures with:

using (dynamic dialog = ComAutomationFactory.CreateObject("WIA.CommonDialog"))
{
    var device = dialog.ShowSelectDevice(
        (int)WiaDeviceType.CameraDeviceType, true, false);
}

Notice that CreateObject returns IDisposable, so we try to make sure we call Dispose for any reference obtained this way to ensure we release all resources cleanly.

This will pop open a modal dialog which allows us to pick our device.

Now since we’re able to subscribe to events raised by the COM object, lets see if we can get a notification when a picture is taken. This will allow us to respond to both our application requesting a picture be taken but also let us know when someone presses the shutter release on the camera itself!

ComAutomationEvent evt = ComAutomationFactory.GetEvent(manager, "OnEvent");
evt.EventRaised += OnEvent;

private void OnEvent(object sender, ComAutomationEventArgs e)
{
    if (e.Arguments[0].ToString() != EventId.ItemCreated)
        return;

    //Grab the raw image bytes
    var item = device.Items[device.Items.Count];
    var imagefile = item.Transfer(FormatId.Jpeg);
    var imageData = (byte[]) imagefile.FileData.BinaryData;

    PictureTaken(this, new PictureTakenEventArgs(imageData));
}

public event EventHandler<PictureTakenEventArgs> PictureTaken = delegate { };

Here we get a ComAutomationEvent from the ComAutomationFactory.GetEvent method and subscribe to it’s EventRaised event. In the handler we extract the raw image bytes using the WIA API and then notify any interested parties a picture was taken.

Taking a picture programmatically is even more trivial.

device.ExecuteCommand(CommandId.TakePicture);

The sample application in the download below has a simple UI which allows you, when running Out-Of-Browser on Windows, to take pictures and displays them on screen.

Conclusion

All in all I’m very excited about Silverlight 4 and Silverlight in general, a lot of missing pieces are falling into place with this new release and we should be able to create some really compelling stuff.

My concern is that since none of this COM business will work on OSX, nor is there any alternative scheme on that platform, we are heading down the wrong track. Yes, we can now create applications that “Light Up” on Windows, but really I’d like to offer the same powerful functionality to all my users. Some are of the opinion that the real exciting thing with Silverlight and Moonlight is the future of a true cross platform development model based on C#, XAML and web based deployment, and for me not having feature parity across even officially supported operating systems is a worry.

Never the less, I’m loving it!

Code Download

SBlakemore.SilverlightWia.zip

A Frosty First Post

Sat, 19 Dec 2009 02:23:48 +1800

So to christen my new home I though I would post a few photos of what I woke up to this morning in deepest Buckinghamshire in the south of England!