LiveMike

Using DynaCache with Unity

Sat, 18 May 2013 11:35:38 GMT

I’ve had a couple of people ask for concrete examples of using DynaCache with frameworks other than Ninject. The first one that I’ve put together is for Unity.

You’ll find the Unity example in the DynaCache documentation here.

StoryboardCompletedTrigger and SetPropertyAction

Thu, 21 Mar 2013 20:31:59 GMT

I’ve spent a couple of hours on WinRTTriggers tonight and added a couple of features that have been requested recently, StoryboardCompletedTrigger and SetPropertyAction.

StoryboardCompletedTrigger

This trigger allows to to fire an action when a storyboard completes – you can use it like this:

<Triggers:StoryboardCompletedTrigger Storyboard="{StaticResource FlashNameChanged}">
    <!-- insert your action(s) here -->
</Triggers:StoryboardCompletedTrigger>

SetPropertyAction

This allows you to react to a trigger by setting a property on an object – most likely your view model:

<Triggers:Interactions.Triggers>
    <Triggers:PropertyChangedTrigger Binding="{Binding Person.Name}">
        <Triggers:SetPropertyAction Target="{Binding}" 
                                    PropertyName="HasChangedName" Value="true" />
    </Triggers:PropertyChangedTrigger>
</Triggers:Interactions.Triggers>

There’s nothing stopping you binding the new value to something another property on your view model, either:

<Triggers:Interactions.Triggers>
    <Triggers:PropertyChangedTrigger Binding="{Binding Person.Name}">
        <Triggers:SetPropertyAction Target="{Binding}" 
                          PropertyName="ChangeCount" 
                          Value="{Binding NextChangeCount}" />
    </Triggers:PropertyChangedTrigger>
</Triggers:Interactions.Triggers>

Of course you can combine these with all the other triggers and actions in the WinRTTriggers library in a variety of ways – hopefully these plug a couple of gaps that people have needed filled!

Hope this helps - I’m always interested in hearing how you get on with using WinRTTriggers in your Windows 8 applications!

Async and await in constructors

Thu, 07 Mar 2013 22:32:00 GMT

I was working on LIFTI last night, trying to create a Windows Store compatible version of it and encountered 2 main problems:

No support for IEnlistmentNotification, so no transactional support is possible, at least in the same way – I need to do a bit more digging to rule it out completely.
The file management class needed to initialise the backing file during construction. This proved to be a little challenging because all of the WinRT APIs for file management are asynchronous, and don’t mix particularly well with constructors.

The rest of this post will cover how I got around this without re-architecting the code extensively.

Moving to the WinRT world

The long and short of what the constructor does is create a read/write stream to the backing file – in the classic .NET world this is really simple:

var fileInfo = new FileInfo(filePath);
this.DataStream = fileInfo.Open(FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);

My initial “cheeky” attempt at getting this working with the WinRT APIs was something along the lines of:

var localFolder = ApplicationData.Current.LocalFolder;
var file =  localFolder.CreateFileAsync(
    filePath, 
    CreationCollisionOption.OpenIfExists).GetResults();
this.DataStream = file.OpenStreamForWriteAsync().Result;

Which attempted to bypass the asynchronous nature of the APIs by reading the results inline and forcing the calls to execute synchronously. I didn’t really expect it to work, and sure enough it blew up at runtime – the CreateFileAsync line threw:

A method was called at an unexpected time. (Exception from HRESULT: 0x8000000E)

So the methods really do need to be awaited. But constructors can’t be async, so I ended up kicking off a new Task that ran an async delegate:

protected FileManagerBase(string fileName)
{
    Task.Run(
        async () =>
        {
            var localFolder = ApplicationData.Current.LocalFolder;
            var file = await localFolder.CreateFileAsync(
                fileName, 
                CreationCollisionOption.OpenIfExists);
            this.DataStream = await file.OpenStreamForWriteAsync();
        }).Wait();
}

Which seems to work, but I’d be really interested in hearing if this is frowned upon (other than the obvious “you’re blocking the calling thread”) and if there’s a better way of solving the problem.

Aliens vs Finger

Mon, 25 Feb 2013 19:09:00 GMT

I've been working on another game for Windows Phone (7.5+) and the result is Aliens vs Finger!

Aliens vs Finger is a (hopefully!) fun tap-'em-up game where you have to squish the aliens and stop the meteors crossing the screen, all the while being careful to not hit the friendly spacemen. Although it's in the market place as a paid app (the lowest price possible!) - the entire game is available as an ad-supported trial, so you've got nothing to lose by giving it a go - only purchase if you enjoy it!

For those interested, some of the technical details are:

Developed in XNA - I used this for two reasons:
- Silverlight probably wasn't going to cut it what I was aiming to achieve and I've experimented with XNA before - nothing fancy but I had an appreciation for what I was letting myself in for.
- I wanted to reach the broadest market possible - focusing solely on Windows Phone 8 would have limited that - XNA was the best match for Windows Phone 7.5+.
The high score tables are stored in Azure Mobile Services. As I mentioned previously, I used the azure-mobile-csharp-sdkto access the API. There are some interesting points about how I managed the data there, and I'll probably write more about that in a separate post.
All of the animations from the way that the main menu slides around to the way individual aliens move are based around easing functions. I used a heavily customised version of XNATweenerto manage this.
The graphics are all drawn by me; I'm no designer, but I'm fairly happy with the results!
In total I think I spent about one and a half weeks working on it, but as it was one of many "free time" projects it was more like 4 months elapsed time.

If you do play it, let me know what you think!

Using Azure Mobile Services from Windows Phone 7 apps

Sat, 10 Nov 2012 16:04:00 GMT

Azure Mobile Services is an pretty cool platform that I’ve only just started trying out. Microsoft provide quick jumpstart projects for Windows Store, Windows Phone 8 and iOS apps – but that’s it. If you’re like me and are stuck working on a “legacy” app such as the Windows Phone 7 game that I’ve been working on for a couple of weeks now, then you’re largely on your own.

If you’re in the same situation, I would recommend that you check out the azure-mobile-csharp-sdk project by Ken Egozi. It seems to do everything I need – at the moment just querying and inserting - right off the bat, and it looks like the Mono guys have even taken to using this code in the Mono framework, so that’s a good sign as well!

Great job, Ken!

UPDATE - 14 March 2013

As good as Ken's library is, check this out: http://www.johanlaanstra.nl/?p=217. I've not used it yet myself, but if I was starting from scratch I probably would. I'd be interested to hear people's experiences with it.

Using WinRTTriggers within data templates

Sat, 03 Nov 2012 13:14:12 GMT

Kaki104 recently commented that they were having a problem using triggers in a certain situation. Helpfully a simple repro was provided – a simple grid view, with an attempt to start a storyboard when an item is clicked:

The trigger had been placed within the data template of the item:

<DataTemplate x:Key="DataTemplate1">
    <Grid HorizontalAlignment="Left" Width="250" Height="250">
        <Grid.Resources>
            <Storyboard x:Key="storyboard1">
                <ColorAnimationUsingKeyFrames Storyboard.TargetProperty="(Border.Background).(SolidColorBrush.Color)" Storyboard.TargetName="border">
                    <EasingColorKeyFrame KeyTime="0" Value="#FFB8B5B5"/>
                    <EasingColorKeyFrame KeyTime="0:0:1" Value="#FF3C3B3B"/>
                </ColorAnimationUsingKeyFrames>
                <ColorAnimationUsingKeyFrames Storyboard.TargetProperty="(Panel.Background).(SolidColorBrush.Color)" Storyboard.TargetName="stackPanel">
                    <EasingColorKeyFrame KeyTime="0" Value="#A69C5151"/>
                    <EasingColorKeyFrame KeyTime="0:0:1" Value="#A6F9F3F3"/>
                </ColorAnimationUsingKeyFrames>
            </Storyboard>
        </Grid.Resources>

        <t:Interactions.Triggers>
            <t:PropertyChangedTrigger Binding="{Binding Title}">
                <t:ControlStoryboardAction Action="Start" Storyboard="{StaticResource storyboard1}"/>
            </t:PropertyChangedTrigger>
        </t:Interactions.Triggers>

        <Border x:Name="border" Background="#FF3D3D3D"/>
        <StackPanel x:Name="stackPanel" VerticalAlignment="Bottom" Background="#A6000000">
            <TextBlock Text="{Binding Title}" Foreground="{StaticResource ListViewItemOverlayForegroundThemeBrush}" Style="{StaticResource TitleTextStyle}" Height="60" Margin="15,0,15,0" LayoutUpdated="TextBlock_LayoutUpdated_1" SelectionChanged="TextBlock_SelectionChanged_1"/>
            <TextBlock Text="{Binding Subtitle}" Foreground="{StaticResource ListViewItemOverlaySecondaryForegroundThemeBrush}" Style="{StaticResource CaptionTextStyle}" TextWrapping="NoWrap" Margin="15,0,15,10"/>
        </StackPanel>
    </Grid>
</DataTemplate>

Interestingly the designer complains that there is an “illegal qualified name character” in the XAML, but when you run the code, everything works as expected.

Now, I’ve dug around a little and haven’t been able to work out why this is – debugging the host Visual Studio instance doesn’t reveal any exceptions being thrown, so I can only assume the parser is misreporting a problem, though in my experience it’s usually something I’m doing that’s wrong. If anyone can reveal what that is, I’d be very grateful!

A simple workaround for this is to just move the contents of the grid into a separate UserControl and reference that from within the DataTemplate instead:

<DataTemplate x:Key="DataTemplate1">
    <local:ItemUserControl />
</DataTemplate>

This way you don’t get designer errors and everything works at run time.

I’ve uploaded the sample code for this here, if you’re interested.

Using LiveDataScript

Sat, 13 Oct 2012 12:50:47 GMT

LiveDataScript is a little utility to generate SQL insert scripts from SQL Server databases. I wrote it quite a few years ago, but since it’s still fairly useful and the last place it was hosted has now gone the way of the Dodo, I’ve re-hosted it here.

This post will cover the high-level basics of using the application.

Getting started

After starting LiveDataScript you’ll be prompted to select the server to connect to:

As you can see, you can use Windows authentication or SQL Server authentication to connect, depending on which is most appropriate for your server.

Once you’re connected you’ll be able to drill into the databases available on the server in the Server Explorer pane:

Double clicking on a table will open it up in a new window:

Scripting data from a table

Scripting all the data

You have a couple of options here:

Select a table in the Server Explorer and press the Script Tables button ()
Open a table by double-clicking on it and press the Script Window Results button ()

Note that each of the buttons has a little dropdown associated to it, giving you a choice of where you want to script to, either to a new window, a file or to the clipboard:

Scripting a subset of data

Again, a couple of options:

Open a table and change the SELECT statement to include a “TOP x” statement, e.g. SELECT TOP 100. Click Refresh Results (or press F5) and then Script Window Results.
Open a table and highlight the rows that you want to script out, then press Script Selected Rows ()

Selecting the columns to script

You can always change the columns that should be scripted out by altering the SELECT statement, but there is an easier way using the “Script Column Filters” panel:

By simply unselecting columns in this list and scripting the results, you will remove those columns from the resulting output.

Summary

That pretty much covers the basics – I’ll write another post soon covering some of the more advanced ways that you can generate scripts.

Conditional trigger actions with WinRTTriggers

Sun, 07 Oct 2012 20:23:43 GMT

WinRTTriggers is a available from the codeplex project site or from nuget.

Sample code for this post can be downloaded here.

The latest update to WinRTTriggers (v1.1.0) includes 2 big changes:

Multiple actions can be specified against a trigger
An action can have conditions associated to it

The first point is fairly self explanatory, but the second deserves a bit more elaboration.

Take the situation where on the first use of your application you want to introduce the user to certain features using a storyboard animation. In the view model you might have some flag to indicate “first use”:

public class SampleViewModel : ViewModelBase
{
    private bool isFirstUse;

    public bool IsFirstUse
    {
        get { return this.isFirstUse; }
        set
        {
            if (this.isFirstUse != value)
            {
                this.isFirstUse = value;
                this.OnPropertyChanged();
            }
        }
    }
}

In your page, you include the view model as a resource and databind it to the page:

<Page
    x:Class="ConditionalActionSample.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:ConditionalActionSample"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    xmlns:Triggers="using:WinRT.Triggers">
    
    <Page.Resources>
        <local:SampleViewModel x:Name="ViewModel">
            <local:SampleViewModel.IsFirstUse>True</local:SampleViewModel.IsFirstUse>
        </local:SampleViewModel>
    </Page.Resources>
    
    <Page.DataContext>
        <Binding Source="{StaticResource ViewModel}" />
    </Page.DataContext>

The content of the page is really simple – just a “magic” button and some introductory text that is initially hidden by setting the opacity to 0:

    <Grid Background="{StaticResource ApplicationPageBackgroundThemeBrush}">
        <Button x:Name="magicButton" Content="Click for magic..." />
        <Border x:Name="border" Opacity="0" CornerRadius="500" BorderThickness="3" Background="#FF9FB292" BorderBrush="#FF162314" Margin="152,239,-510,239" Padding="20,0,478,0" RenderTransformOrigin="0.5,0.5">
            <TextBlock FontSize="34.667" TextWrapping="Wrap" Foreground="#FF266C05" TextAlignment="Center" VerticalAlignment="Center" Text="This button is magic. Clicking it performs all sorts of wonderous actions." />
        </Border>
    </Grid>
</Page>

Next up, there’s a storyboard that just flashes the introductory text:

    <Page.Resources>
        <local:SampleViewModel x:Name="ViewModel">
            <local:SampleViewModel.IsFirstUse>True</local:SampleViewModel.IsFirstUse>
        </local:SampleViewModel>
        <Storyboard x:Name="FirstLoadStoryboard">
            <DoubleAnimationUsingKeyFrames Storyboard.TargetProperty="(UIElement.Opacity)" Storyboard.TargetName="border">
                <EasingDoubleKeyFrame KeyTime="0:0:1" Value="0"/>
                <EasingDoubleKeyFrame KeyTime="0:0:2" Value="1" >
                	<EasingDoubleKeyFrame.EasingFunction>
                		<BounceEase Bounces="1"/>
                	</EasingDoubleKeyFrame.EasingFunction>
                </EasingDoubleKeyFrame>
            </DoubleAnimationUsingKeyFrames>
        </Storyboard>
    </Page.Resources>

And finally, the bit that ties it all together, the triggers on the page:

    <Triggers:Interactions.Triggers>
        <Triggers:EventTrigger EventName="Loaded">
            <Triggers:ControlStoryboardAction Storyboard="{StaticResource FirstLoadStoryboard}" Action="Start">
                <Triggers:Condition LeftOperand="{Binding IsFirstUse}" Operator="Equals" RightOperand="True" />
            </Triggers:ControlStoryboardAction>
        </Triggers:EventTrigger>
    </Triggers:Interactions.Triggers>

Notice that the Condition element within the ControlStoryboardAction element instructs that it should only fire when the IsFirstUse property equals “True”.

Running the code in its current state will cause the storyboard to start – if the view model’s IsFirstUse value is changed to False, the storyboard will not be started when the application loads.

This is just one example of how you might use a condition on an action – hopefully you’ll find them useful in many other situations.

Triggers in WinRT XAML

Fri, 28 Sep 2012 16:04:00 GMT

All the code for WinRTTriggers is available from the CodePlex project site, and is available in binary form in a nuget package.

A few months ago I attended one of Microsoft's "Windows Phone to Windows 8 App" events. The intent was to take Equazorand migrate it to a Windows Store application as much as possible over the space of two days.

On the whole, the event was really useful to just hang out with a bunch of other developers (along with some Microsofties like Mike Taulty and Martin Beeby) and I managed to port all the "business logic" of the app pretty successfully - you would expect so given that I had used the MVVM pattern with MvvmLight, which is now available for WinRT XAML applications.

Where I became unstuck, however, was my reliance on Expression Blend's triggers to manipulate the UI in response to the changing view model and handle the player's interactions; as it turns out these are not currently supported by in the WinRT XAML world.

So what's a was I to do, but write my own implementation?

Introducing WinRTTriggers

The best way to explain the sort of things you can do with WinRTTriggers is to show a quick snippet of XAML from the test app that’s available in the solution:

<Grid Background="{StaticResource ApplicationPageBackgroundThemeBrush}" 
        DataContext="{StaticResource ViewModel}">
    <Triggers:Interactions.Triggers>
        <Triggers:PropertyChangedTrigger Binding="{Binding Person.Name}">
            <Triggers:ControlStoryboardAction Action="Start" 
                Storyboard="{StaticResource FlashNameChanged}" />
        </Triggers:PropertyChangedTrigger>
        ...
        <Triggers:PropertySetTrigger Binding="{Binding Person.IsHappy}" 
                RequiredValue="false">
            <Triggers:GotoStateAction StateName="Sad" />
        </Triggers:PropertySetTrigger>
    </Triggers:Interactions.Triggers>

    <VisualStateManager.VisualStateGroups>
        <VisualStateGroup x:Name="HappySad">
            <VisualStateGroup.Transitions>

There are 2 triggers demonstrated above:

The first watches the Person.Name property – when it is modified, it reacts by starting the FlashNameChangedstoryboard.
The second watches the Person.IsHappy property – when it gets set to false, it reacts by changing the visual state to Sad.

From this it should be relatively obvious that there’s a very simple trigger/action relationship going on here – you configure a trigger and specify the action that should happen as a result of it firing.

Triggers

Currently implemented are:

PropertyChangedTrigger - fires when a property changes to any value
PropertySetTrigger - like PropertyChangedTrigger, except it will only get fire when a property changes to a specified value.
EventTrigger - fires when an event associated to the control is fired, e.g. the Tapped event on a control.

Actions

The current actions are:

GotoStateAction - Instructs the VisualStateManager to change to a named state
InvokeCommandAction - Invokes some ICommand implementation, probably located on your view model.
ControlStoryboardAction - Starts/Stops/Pauses a storyboard.

Todo…

There are some things that I know are missing, I definitely haven't covered all the triggers and that Expression did - I imagine these will be added over time.

Another big omission is the inability to apply conditions to triggers, i.e. only fire this trigger is some arbitrary value is true. I may (or may not) tackle these soon, depending on how much I need them!

Summary

I still haven’t got the Equazor port done yet, but I’ve had fun getting this framework up and running over some (very) limited free time. I think that even with just these few triggers I think you'll be able to replicate a reasonable amount of the old Blend interaction logic.

Let me know if you encounter any problems or have any requests.

Equazor

Thu, 20 Sep 2012 21:08:00 GMT

A couple of months ago I released my first Windows Phone game into the wild. It’s a “maths-based puzzle game” that will challenge, infuriate (hopefully not too much!) and with a bit of practice, genuinely develop your mental arithmetic.

The premise is simple – you have to highlight a sequence of tiles forming an equation that results in a target number. It’s easy to start with, with just add and subtract and a limited number of tiles to play with, but it soon gets harder when the multiplication is introduced and the playing area and target numbers get larger. Oh, and you’re up against the clock, so there is some pressure!

You can get Equazor from the Windows Phone Marketplace or by searching for it on your Windows Phone – it’s free, so what have you got to lose? Let me know what you think!

Tech talk

Just in case you’re interested, I developed it in Silverlight with all the logic being held together with MvvmLight. The main chunk of development took place over three days, with a following day or two needed to polish and test it.

New host, new look

Wed, 19 Sep 2012 19:09:00 GMT

There hasn’t been much activity here for a while for several reasons, including a new job and the small matter of a total server failure for a few months…

…but now I’m back. I’m on a new host, a new platform (Orchard) and have a new look that I threw together – ok, I’m no professional graphic designer, but hey, it adapts to small screens nicer than the last one did!

Please bear with me as I work out any kinks in the new site, and stay tuned - I’ve got a few plans for this blog.

Export all tables in an Access database to CSV

Tue, 29 May 2012 00:00:00 GMT

I don't usually mess around with Access much, but when I do it's usually to have it act as an intermediary data source while I'm getting data from one format to another.

I had just such a problem to solve today, and the usually excellent out-of-the-box import/export processes let me down a little. Essentially I needed to get the data from each of the tables into separate CSV files - unfortunately I had quite a few tables to do and the UI only allows you to do one at a time.

Here's the little VBA routine I put together to solve the problem:

Public Sub ExportAllTablesToCSV()

    Dim i As Integer
    Dim name As String
    
    For i = 0 To CurrentDb.TableDefs.Count
        name = CurrentDb.TableDefs(i).name
        
        If Not Left(name, 4) = "msys" And Not Left(name, 1) = "~" Then
            DoCmd.TransferText acExportDelim, , name, _
                "c:\exports\" & name & ".csv", _
                True
        End If
    
    Next i

End Sub

Why have my visual state changes stopped working?

Tue, 22 May 2012 00:00:00 GMT

This took me a little while to work out, and searching for an answer didn't help me out, so I thought it might be helpful to post this as a pointer to anyone else who encounters the same problem.

My scenario:

A Silverlight Windows Phone 7.1 App
a control with a number of visual states applied to it
Interaction triggers that switch between the various states

Everything was working fine until I wrapped the root element of my control in another container element - all of a sudden the visual states stopped working at runtime. As far as the designer was concerned, everything was fine though.

After a bit of digging around I found that the VisualStateManager.VisualStateGroups element had been moved to the new parent element, but the VisualStateManager.CustomVisualStateManager element that Expression Blend had added in to provide smooth animation and layout had not. Moving the CustomVisualStateManager element to be contained in the root element fixed the problem.

Hope that helps someone.

Hooking into session start events in an HTTP module

Wed, 25 Jan 2012 00:00:00 GMT

According to the MSDN documentation you can't handle Session Start events in an HTTP module. The reason for this is because when you are initialising an HTTP module you hook into events associated to the HttpApplication class, and HttpApplication doesn't expose any events relating to the starting of sessions.

As a refresher, the Init method will typically look like something like this:

public void Init(HttpApplication context)
{
    // Hook into the HttpApplication events you want to respond to
    context.BeginRequest += this.BeginRequest;
}

So it's not possible… right? Wrong, but only if you don't mind a slightly dirty hack.

I should probably make the standard disclaimer for this sort of thing - it works on my machine! - There are no guarantees if it will work in your environment, and would strongly recommend testing it fully!

The trick is getting access to the SessionStateModule in the Init method, and hooking into the Start event from there, like this:

public void Init(HttpApplication context)
{
    var module = context.Modules["Session"] as SessionStateModule;
    if (module != null)
    {
        module.Start += this.Session_Start;
    }
}

private void Session_Start(object sender, EventArgs e)
{
    // Respond to the session start event however you need
}

This works by relying on the fact that there's a module in the application's HttpModuleCollection called Session - a fairly safe bet unless you're really messing with the httpModules definition in the .NET Framework's web.config file. Note, however, it could break if a new version of the framework comes along and names the module differently, but it hasn't changed in any of the framework versions that have been released to date.

Article on using SqlBulkCopy with POCOs

Fri, 20 Jan 2012 00:00:00 GMT

I realised that I never pushed this on my blog at all, so belatedly I will.

Last year I wrote an article for Developer Fusion that discussed how you could make use of SqlBulkCopy to do high performance inserts when you were working with POCOs, rather than inserting them entity by entity using an ORM.

The bottom line was that inserting 10,000 records took only 57ms using the generic SqlBulkCopy approach I describe, rather than 2159ms to insert them on a record-by-record basis.

You can check the article out here: Using SqlBulkCopy for high performance inserts

DynaCache- just like page output caching, but for classes

Sun, 15 Jan 2012 00:00:00 GMT

Anyone who has done any serious work with any ASP.NET based framework will know that page output caching is a great feature. For those not familiar with it, the basic premise is that it makes sure that the generation of content is done only once for a set of parameters, and that all subsequent requests with the same parameters are served up from the cache for a specified period of time.

Wouldn't it be nice if you could do a similar thing for methods on classes, just by applying an attribute like this?

[CacheableMethod(30)]
public virtual string GetData(int id)

Thanks to a little library called DynaCache, you can!

How does it work?

Say you have a class called TestClass:

The LoadData method is marked as virtual, and has an attribute called CacheableMethod applied to it, indicating the number of seconds the results should be cached for.

The CachableMethod attribute is the first interaction with the DynaCache framework - the second is with a class called Cacheable:

Calling Cacheable.CreateType<TestClass>() at runtime creates a new class called CacheableTestClass, deriving from TestClass and overriding any methods with the CachableMethod attribute, resulting in a class hierarchy like this:

This new class is created using Reflection.Emit and only exists in memory, so you can't use a reflector-like program to see what's generated, but if you could it would look something like this:

public class CacheableTestClass : TestClass
{
    private IDynaCacheService cacheService;
    
    public TestClass(IDynaCacheService cacheService)
    {
        this.cacheService = cacheService;
    }

    public override string LoadData(int id)
    {
        string cacheKey = String.Format(CultureInfo.InvariantCulture, "TestClass_LoadData(Int32).{0}", id);
        object result;
        if (!this.cacheService.TryGetCachedObject(cacheKey, out result))
        {
            result = base.LoadData(id);
            this.cacheService.SetCachedObject(cacheKey, result, 200);
        }
        
        return (string)result;
    }
}

Notice the IDynaCacheService parameter in the constructor? That's the third piece of the DynaCache framework - an instance of a class capable of interacting with whatever backing cache is being used. Out of the box DynaCache includes a concrete implementation of this called MemoryCacheService - it's just a wrapper around a .NET 4 MemoryCache instance. There's no reason why you shouldn't create your own though, e.g. for the ASP.NET or Windows Azure cache.

Making it simple with dependency injection

What this all means is that at runtime you need to be using CacheableTestClass rather than TestClass, otherwise all the generated caching code will never be used. Although it's possible to construct and use these types yourself, the simplest and best way to do that is to use a dependency injection framework, such as Ninject, StructureMap, etc.

For the sake of illustration, I'm going to use Ninject. The original configuration would have simply mapped ITestClass to TestClass, like this:

kernel.Bind<ITestClass>().To<TestClass>();

Using DynaCache is only marginally more complicated, you just configure your kernel like this:

kernel.Bind<IDynaCacheService>().To<MemoryCacheService>();
kernel.Bind<ITestClass>().To(Cacheable.CreateType<TestClass>());

The first line configures the cache service to pass to instances of CacheableTestClass, whilst the second binds ITestClass to the cacheable version of TestClass.

That's all there is to it! Now every time an instance of ITestClass is required, Ninject will construct and return an instance of CacheableTestClass - the rest of your code that consumes ITestClass will automatically make use of the dynamically constructed caching code.

Where to get DynaCache

You can get it from the CodePlex project site, or you can install it into your project using the Nuget command:

Install-Package DynaCache

Summary

Hopefully all the detail hasn't put you off - this whole article essentially boils down to just these three steps:

Make the methods overridable and apply the CacheableMethod attribute to them.
Configure your DI framework to return an instance of IDynaCacheService, either MemoryCacheService or one you have implemented yourself.
Configure your DI framework to return the result of Cacheable.CreateType for your type.

I'd be really interested in feedback for DynaCache - let me know your thoughts in comments below, or on the project discussion board.

Tutorial: Using LIFTI in an MVC 3 web application

Fri, 01 Jul 2011 00:00:00 GMT

Updated 25/02/2012 - it was highlighted that some of the seach phrases used towards the end of this article were not returning the expected results - that was down to me making assumptions about which words would be stemmed - these examples have been updated.

This tutorial will take you through an end-to-end implementation of a simple web site to manage a list of employees. LIFTI will be used to perform full text searching of plain text information associated to the employees.

Whilst the site will be built upon MVC 3, Entity Framework Code First and Ninject, the use of these technologies is largely arbitrary - you should be able to switch them out for any other appropriate frameworks.

Important: This tutorial relies on you having nuget installed - trust me, it makes the process of setting up your project dependencies so much easier.

Getting started

To get started, create a new empty MVC 3 application so you have a basic structure for the web application to be built from.

Now use nuget to add LIFTI - open the Package Manager Console (View/Other Windows/Package Manager Console) and type:

Install-Package LIFTI

The LIFTI assembly will be downloaded and added as a reference to your project.

Install the EntityFramework.SqlServerCompact and Ninject.MVC3 packages using the package manager:

Install-Package EntityFramework.SqlServerCompact
Install-Package Ninject.MVC3

Adding these packages will automatically pull through all these packages (some of them are the dependencies of the two you added):

EntityFramework
WebActivator
SqlServerCompact
EntityFramework.SqlServerCompact
Ninject
Ninject.MVC3

Both Ninject.MVC3 and EntityFramework.SqlServerCompact packages add code files into a folder called App_Start. The SqlServerCompact class configures the default connection factory for the entity framework library to use the SQL Server Compact connection factory; the NinjectMVC3 class allows you to configure your dependency injection - you'll come onto that later.

Create a model and data context

Add Employee.cs to the Models folder of the project containing:

public class Employee
{
    [Key]
    public int EmployeeId { get; set; }

    [StringLength(100), Required]
    public string Name { get; set; }

    [Required]
    public DateTime DateOfEmployment { get; set; }

    public string Notes { get; set; } 
}

Add EmployeeDataContext.cs to the Models folder:

public class EmployeeDataContext : DbContext
{
    public DbSet<Employee> Employees
    {
        get;
        set;
    }
}

Scaffold out the site

Make sure that you have built the project and right-click on the Controllers folder, selecting Add Controller…:

Name the controller EmployeesController
Make sure the template "Controller with read/write actions and views…" is selected
Select Employee as the model
Select EmployeeDataContext as the data context
Press Add

The scaffolded actions and views will be created for you (very handy in tutorials like this!).

Before you run the project, make sure you have added the App_Data ASP.NET folder to the project by right clicking on the project and selecting Add > Add ASP.NET Folder > App_Data.

At this point you should be able to run the project to make sure that everything you've done so far is correct. You should be able to fire up the project and navigate to http://localhost:xxxx/Employees where xxxx is the port number for your project:

Ok, so it doesn't look very sexy, but it's a website with a SQL Server Compact database sitting behind it, all up and running in just a few steps.

Introducing LIFTI

The full text index that you will be using is an updatable full text index that will contain the IDs of employees indexed against the text in their notes. More specifically, this will be an instance of PersistedFullTextIndex<int> - this type of index is backed by a file store, which means that if the web application is stopped and started, the index will not lose all its data and will be able to pick up where it left off. Significantly this means that you will be able to keep the index and database in sync, assuming that whenever the database is updated you also update the index.

Under most circumstances there should only ever be one instance of your index in memory. This means that all of your code, whatever thread it is on, should interact with the same index (don't worry, LIFTI's implementation of the full text index is thread safe.). You could implement this is any number of ways:

Using the singleton pattern
Storing the index in a static variable somewhere that can be access by the depending code
Storing the index in Application state
Using dependency injection to provide one common index to any depending code

Like all good developers these days, I'm sure you'll want to take the dependency injection route! The first step to this is to add your index into the dependency injection framework.

Open App_Start\NinjectMVC3.cs and change the RegisterServices method so it looks like this:

private static void RegisterServices(IKernel kernel)
{
    string filePath = Path.Combine(
        (string)AppDomain.CurrentDomain.GetData("DataDirectory"), 
        "Index.dat");

    kernel.Bind<IUpdatableFullTextIndex<int>>()
        .To<PersistedFullTextIndex<int>>()
        .InSingletonScope()
        .WithConstructorArgument("backingFilePath", filePath)
        .OnActivation((IUpdatableFullTextIndex<int> i) =>
        {
            i.WordSplitter = new StemmingWordSplitter();
            i.QueryParser = new LiftiQueryParser();
        });
}

The filePath variable is configured so that the index data file (index.dat) will be stored in the App_Data folder for the application. (that's where "DataDirectory" points by default in a web application.)

Then the Ninject kernel is instructed that:

Whenever an instance of IUpdatableFullTextIndex<int> is requested (Bind)
Map it to an instance of PersistedFullTextIndex<int> (To)
And re-use it globally, i.e. only ever create one instance (InSingletonScope)
When it is constructed, pass the path to the index data to the "backingFilePath" parameter (WithConstructorArgument)
And finally, when it is activated, set the WordSplitter and QueryParser properties to instances of StemmingWordSplitter and LiftiQueryParser, respectively. (OnActivation)

Now you just have to consume the index and use it in the controller.

Updating the index

Open the EmployeesController class and add a constructor:

private IUpdatableFullTextIndex<int> index;
public EmployeesController(IUpdatableFullTextIndex<int> index)
{
    this.index = index;
}

Ninject (in conjunction with the nice dependency resolution in MVC 3) will take care of providing your controller with the relevant instance of the index whenever it is constructed.

There are 3 places in the controller that you need to interact with the index to keep it in sync with the database:

Creating an employee - the index should be updated if notes are provided for the employee
Updating an employee - the index should be updated if the employee has notes, or have any indexed text removed if the employee no longer has any notes
Deleting an employee - any previously indexed notes for the employee should be removed

Update the HttpPost Create method so it looks like this:

[HttpPost]
public ActionResult Create(Employee employee)
{
    if (ModelState.IsValid)
    {
        db.Employees.Add(employee);
        db.SaveChanges();

     if (!String.IsNullOrEmpty(employee.Notes))
        {
            this.index.Index(employee.EmployeeId, employee.Notes);
        }

        return RedirectToAction("Index");  
    }

    return View(employee);
}

Then the HttpPost Edit method:

[HttpPost]
public ActionResult Edit(Employee employee)
{
    if (ModelState.IsValid)
    {
        db.Entry(employee).State = EntityState.Modified;
        db.SaveChanges();

     if (String.IsNullOrEmpty(employee.Notes))
        {
            this.index.Remove(employee.EmployeeId);
        }
        else
        {
            this.index.Index(employee.EmployeeId, employee.Notes);
        }

        return RedirectToAction("Index");
    }
    return View(employee);
}

And finally, the HttpPost Delete method:

[HttpPost, ActionName("Delete")]
public ActionResult DeleteConfirmed(int id)
{            
    Employee employee = db.Employees.Find(id);
    db.Employees.Remove(employee);
    db.SaveChanges();

 this.index.Remove(employee.EmployeeId);

    return RedirectToAction("Index");
}

Try the application out again, you should be able to create, update and delete employees without any problems - the full text index will be built up in the background.

Searching for employees

The last step is to allow users of your site to search for interesting text within the employee notes.

Update the Views\Employees\index.cshtml file with a search textbox just after the <h2> tag:

<h2>Index</h2>

@using (Html.BeginForm()) {
<p>
    @Html.Label("searchCriteria", "Search employee notes:")
    @Html.TextBox("searchCriteria") 
    <input type="submit" value="Search" />
</p>
}

Now add a new method to the EmployeesController to handle the posting of the search text:

[HttpPost]
public ViewResult Index(string searchCriteria)
{
    if (String.IsNullOrEmpty(searchCriteria))
    {
        return Index();
    }

    var matchingIds = this.index.Search(searchCriteria).ToArray();
    var employees = this.db.Employees
        .Where(e => matchingIds.Contains(e.EmployeeId))
        .ToList();

    return View(employees);
}

The astute amongst you will notice that the data context isn't injected in the same way that the index is - good spot. This tutorial is long enough, so I'll leave that as an exercise for you to fix up if it's bugging you that much!

Testing the application

Build and run the project create these employees:

Name	Date of employment	Notes
Ralph	12/08/2008	Often arriving late to work and frequently takes long lunch breaks
Tracy	02/02/2010	New employee, very diligent worker, and no-one is doubting their commitment, but sometimes acts suspicious when asked about the amount of sick leave taken
Bob	23/11/2003	Works long hours. Arrives early to work and generally stays later than others and works through lunch. Has a tendency to break the build with a high frequency though.
Andy	10/08/2007	Very clean desk - there are doubts that he doesn't actually do anything at work

Try some of these search criteria on the index page:

doubts

Andy is obviously matched - in his notes he has "doubts" specified exactly. However there's more going on here because Tracy is also matched. This is because you're using the stemming word splitter process words in the index, and that automatically removes some word suffixes, such as the "s" from "doubts" and "ing" in Tracy's "doubting" - this means that when you searched for "doubts" you were actually searching for anything that stemmed to "doubt".

emp

Nothing will come back - not even Tracy. This is because the default behaviour for the LIFTI query parser is to match words exactly.

emp*

Tracy will be returned - she is the only employee with notes containing a word that starts with "emp".

lunch & break (or lunch break)

Both Ralph and Bob will be returned - both of these contain derivatives of "lunch" and "break" in their notes.

"lunch break"

Only Ralph contains a phrase that contains "lunch" followed immediately by a derivative of "break".

… your search criteria here

The LIFTI search engine is quite powerful and there are loads of different search permutations you could try out, so try creating a few more employees and searching using some of the other operators, such as or (|) or near (~).

Entity Framework Code First: "The path is not valid. Check the directory for the database"

Mon, 27 Jun 2011 00:00:00 GMT

If you create a new MVC application and try to go down the Code First with SQL Server Compact route, you might encounter this error when you first start the application:

The path is not valid. Check the directory for the database. [ Path = …\WebSample\App_Data\YourDatabase.sdf ]

This error might be a surprise because by default the code first approach should create the database for you if it doesn't already exist.

Whilst this is true, what it apparently won't do is create any parent folders that the database will be stored under - in this case the App_Data folder. Adding this folder is easily accomplished by right-clicking on your project and selecting Add/ASP.NET Folder/App_Data. Once you've done this, everything should work as expected.

As an aside, the reason it's getting created in the App_Data folder is because that's the default location for "DataDirectory" in a web application. You might have seen this mentioned in sample connection strings like this:

<connectionStrings>
    <add name="MyDataContext" 
        providerName="System.Data.SqlServerCe.4.0" 
        connectionString="Data Source=|DataDirectory|MyDatabase.sdf" />
</connectionStrings>

You might get this error even if you're not explicitly specifying the connection string, as a very similar connection string will be used by convention if you don't provide one.

LIFTI XmlWordSplitter

Fri, 10 Jun 2011 00:00:00 GMT

The XmlWordSplitter is a new word splitter class in the latest release of LIFTI. I created it mainly because it was required for the persisted index sample, but it seemed too useful to keep out of the core framework.

At a very high level the XmlWordSplitter just enumerates words contained within elements in a piece of XML text. This means that element names, attributes and their associated values will not be indexed. For example, consider the following XML:

The xml splitter will return the following words:

Word	Word index
THE	0, 6
QUICK	1
BROWN	2
FOX	3
JUMPED	4
OVER	5
LAZY	7
DOG	8

Importantly, notice that the word "the" is reported at positions 0 and 6 - the word index is relative to first word in the document, regardless of whether there are XML elements that interrupt the flow of the text.

To stem or not to stem?

One question that sprung to mind when developing this was whether the splitter should stem the words it returned, like the StemmingWordSplitter, or just return them verbatim, like the basic WordSplitter does? (The above example would be representative of the latter; a stemming word splitter would have returned words like "jump" instead of "jumped".)

Taking this question a step further, what if someone has put together their own custom word splitter and they want the xml splitter to behave like that?

To cater for this I decided to defer the splitting of text contained within XML nodes to a child IWordSplitter implementation. So when you construct an XmlWordSplitter, you do so like this:

var wordSplitter = new StemmingWordSplitter();
var xmlSplitter = new XmlWordSplitter(wordSplitter);

So if you don't want the stemming word splitter behaviour for returned words, you just need to swap it out for a different implementation. Neat.

Splitting search words

Previously LIFTI would always use the same word splitter implementation when splitting words that were being indexed and words that were being searched upon. Introducing the XmlWordSplitter had an interesting side-effect - although you were wanting to index text contained in XML, you probably didn't want to search for words contained in an XML format.

To handle this I added the SearchWordSplitter property to the IFullTextIndex interface - this allows you to specify a different word splitting implementation that should be used when splitting words in a search string. As a small token of my respect to backwards compatibility, if this property isn't specified or is set to null, then the splitter specified in the WordSplitter property is used, meaning that behaviour is unaffected for existing code.

Changes to the LIFTI API

Wed, 08 Jun 2011 00:00:00 GMT

This post relates to the breaking changes between version 0.4 and 0.5 of LIFTI. LIFTI is a full-text indexing library for .NET - find out more on its CodePlex site.

The latest release of LIFTI has several breaking changes that will affect you, so I wanted to take some time to explain not only what they are, but why I made them. I'll start with the what, then move onto the why.

No more constructor delegates

Previously when you wanted to construct a full text index, updatable or otherwise, you would have had to provide a delegate that was capable of taking the type of item in the index and returning the text it should be indexed against, like this:

var index = new FullTextIndex<Customer>(c => c.Name);

This is no longer the case - constructing an index is now as simple as it can be:

var index = new FullTextIndex<Customer>();

If you have been using LIFTI you'll probably be aware that the reason the constructor used to take a delegate was to provide some of the Index methods with the text an item should be index against; this leads me nicely onto the next change.

A rationalised set of Index methods

There used to be 5 Index methods - these have been reduced to 4, which can be broken into two categories, indexing keys and indexing arbitrary classes.

Indexing "keys" rather than "items"

It's often useful (and when it comes to using a persisted index, just plain sensible) to store just a key to an item in the index. That is to say, rather than storing a "Movie" class in the index, just storing the customer ids, e.g. an integer. There are two Index methods that support this:

// Explicitly pass the key and text values
index.Index(movie.MovieId, movie.Description);
index.Index(movieId, description);

// Or you can index an enumerable of keys like this
var ids = new[] { 23, 44, 192 };
index.Index(ids, i => LoadDescriptionForMovie(i));

Indexing arbitrary classes in the index

There are two Index methods on the IFullTextIndex interface that you can use to index instances of Movie directly, should you so wish:

// Pass the movie instance and use delegates to extract the 
// relevant information
var movie = new Movie { MovieId = 1, Description = "Best movie ever!" };
index.Index(movie, m => m.MovieId, m => m.Description);

// The equivalent "index many":
var movies = new[] 
{
    new Movie { MovieId = 1, Description = "Best movie ever!" },
    new Movie { MovieId = 2, Description = "Worst movie ever!" }
};
index.Index(movies, m => m.MovieId, m => m.Description);

No more Reindex methods

I'm hoping you'll not miss them though. Instead, when you're using an updatable index, either UpdatableFullTextIndex or PersistedFullTextIndex, calls to any of the Index methods will automatically remove the item from the index prior to indexing, if it's already there.

Serialization namespace is gone

That's right, gone, along with all the serialization classes in it. If you were using it, I really am sorry, but there were good reasons to do so, and I think there are much better alternatives now.

Ok, so why?

First up, I'll deal with the changes to the constructor and the Index methods, because they are both closely related.

Constructors and Indexing

While I was writing the original serialization code (even before the persisted full text index work) it became apparent that under most circumstances it was going to be best to store a simple value type (e.g. int) in the index, rather than an arbitrary class (e.g. Customer). The reason for this was twofold:

Primitive types are just a lot easier to serialize - most of the time LIFTI can handle primitive types without any configuration.
If you're serializing the full text index somewhere, the chances are the classes are going to be persisted somewhere else, probably a database of some sort. Persisting the classes in the serialized index is a bad case of data duplication and things will definitely get out of sync sooner or later.

Although it's possible, storing a simple id in the index doesn't lend itself naturally to using a delegate to read out the related text. It would usually mean having to call out to another method, like this:

var index = new FullTextIndex<int>(i => GetTextForCustomerId(i));

Ok, you could write it like this, but it feels even more odd:

var index = new FullTextIndex<int>(GetTextForCustomerId);

Indeed, sometimes it may not even be possible to write a delegate ahead of time to return the text for an id - you might just have access to an id and a piece of text at the time it comes to perform the indexing.

Taking all this into account, hopefully it's fairly clear why I decided to remove the delegate from the constructor and, because some of the Index methods relied on there being a pre-defined way of getting hold of the text for a key value, why it was necessary to rationalise the Index methods.

But couldn't I just have added a separate overload for the constructor, or allow the delegate to be null? Well, yes, naturally I could, and I tried it for a while, but I felt that it made the API a bit more confusing. Some of the Index methods had to throw exceptions at runtime if no delegate was provided upon construction - not very nice at all. At least this way you know where you stand - each and every Index method must be given enough information to identify a key value and its associated text.

Getting rid of the Reindex methods

I did this primarily because I was a little uncomfortable just throwing an exception up if an Index method was called and the key already existed in the index - in some circumstances it felt like this was the wrong behaviour. Realistically all this does is save the use of API needing to check to see if item exists and adjust their behaviour depending on the result.

Getting rid of old Serialization classes

The decision to do this influenced by a couple of factors. The first was the fact that I had just implemented the persisted index, which covers exactly what the old serialization code did with the added benefit that you don't need to remember to serialize the index when your application exits and you don't have to manually deserialize it when the application starts. The deserialization point is particularly interesting; the old serialization process required that the entire index was loaded into memory before it could be used - the persisted index lazy loads parts of the index as it is accessed, which for large indexes can make it available for use in a much shorter space of time. I'll cover more on this lazy loading in a later post.

Another factor was that in order to support the old serialization process I had to expose elements of the full text index class that I wasn't really happy doing. For example in 0.4 the RootNode property of the IFullTextIndex interface had a setter - allowing the root node to be changed this way was a bit scary and had big implications for the persisted index implementation. There were probably other ways around this, but this combined with the first point made the decision fairly easy.

Wrap up

This is the first time I have had to make significant breaking changes to the API - I'm not going to promise it's the last, but I think it is approaching something that resembles a stable state.

Some of these changes may be controversial, and I'm sure that other people will have differing opinions on how it should have been done. I'd be really interested to hear if the changes have been significantly problematic for you - either leave me a comment here, or start a thread on the discussions board. I want to hear all feedback, positive or negative!