Simon Brown's Blog

Using Castle Windsor to manage NHibernate sessions

simon.brown — Mon, 14 Dec 2009 13:36:00 GMT

This post follows on from my previous blog post about a custom Castle Windsor lifestyle for WCF.

I was developing an application which consumed a WCF service which handled all database interactions using NHibernate. The WCF service consumed some business services, mapped the resulting domain entities to data contracts and returned them to the consuming application. The architecture is summarised in the following diagram:

There were two main technical requirements I needed to address around connecting to the database:

Re-use the same NHibernate session (and therefore database connection) within the same WCF service method call.
Ensure that the NHibernate session (and therefore database connection) was closed when the WCF service method call was completed (after all lazy loading had taken place)

The domain entities in the application implemented lazy loading, so I couldn’t close the database connection in the NHibernate repository or business service, it needed to be closed later after the WCF Service had mapped the domain entities to data contracts.

To solve this problem I decided to extend the Castle Windsor custom lifestyle I had created previously. I created a new custom lifestyle PerNHibernateWcfRequestLifestyleManager which inherited from my WCF lifestyle. This would ensure that I would always retrieve the same NHibernate session from the container within the context of a WCF operation call. It would also allow me to close the NHibernate session when the WCF operation was complete by hooking into the OperationCompleted event of System.ServiceModel.OperationContext.Current.

The code for the lifestyle is:

/// <summary>
/// A custom Castle Windsor IoC lifestyle manager which stores the resolved object in the 
/// current OperationContext, therefore giving you a new instance of the requested 
/// component for each WCF request. It also closes the NHibernate session when the 
/// request is completed.
/// </summary>
public class PerNHibernateWcfRequestLifestyleManager : PerWcfRequestLifestyleManager
{
    #region AbstractLifestyleManager Members

    /// <summary>
    /// Resolves the specified context.
    /// </summary>
    /// <param name="context">The context.</param>
    /// <returns>The resolved object.</returns>
    public override object Resolve(CreationContext context)
    {
        object resolvedObject = base.Resolve(context);
 
        if (OperationContext.Current != null)
        {
            OperationContext.Current.OperationCompleted += OperationContextCompleted;
        }
 
        return resolvedObject;
    }

    /// <summary>
    /// Releases unmanaged and - optionally - managed resources
    /// </summary>
    public override void Dispose()
    {
    }

    #endregion

    #region Event Handlers

    /// <summary>
    /// Closes the NHibernate session for this OperationContext when the operation has completed.
    /// Closing the session also disconnects the database connection.
    /// </summary>
    /// <param name="sender">The sender.</param>
    /// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
    private void OperationContextCompleted(object sender, EventArgs e)
    {
        var sessionStore = ServiceLocator.Resolve<INHibernateSessionStore>();

        if(sessionStore != null)
        {
            var sessionFactory = ServiceLocator.Resolve<INHibernateSessionFactory>();
            sessionFactory.Close(sessionStore.CurrentSession);
        }
    }

    #endregion
}

The Castle Windsor configuration entries looked like this:

<!-- NHibernate Session Store -->
<component id="NHibernateSessionStore"
           service="Data.INHibernateSessionStore, Data"
           type="Data.NHibernateSessionStore, Data"
           lifestyle="custom"
           customLifestyleType="Container.Lifestyles.PerNHibernateWcfRequestLifestyleManager, Container.Lifestyles">
</component>

<!-- NHibernate Session Factory -->
<component id="NHibernateSessionFactory"
           service="Data.INHibernateSessionFactory, Data"
           type="Data.NHibernateSessionFactory, Data"
           lifestyle="singleton">
</component>

<!-- Repositories -->
<component id="NHibernateRepository"
           service="Data.IRepository, Data"
           type="Data.NHibernate.NHibernateRepository, Data">
  <parameters>
    <sessionFactory>${NHibernateSessionFactory}</sessionFactory>
  </parameters>
</component>

The NHibernateRepository asks the NHibernateSessionFactory to give it a session which it then consumes. The NHibernateSessionFactory uses the NHibernateSessionStore to store its sessions. An example piece of code from the NHibernateRepository is included below:

var session = sessionFactory.Get();
var entity = session.Get<T>(id);

For completeness, I’ve included the relevant source code from the NHibernateSessionFactory and NHibernateSessionStore classes below:

/// <summary>
/// Manages the creation and closure of NHibernate sessions.
/// </summary>
public class NHibernateSessionFactory : INHibernateSessionFactory
{
    #region Implementation of INHibernateSessionFactory

    /// <summary>
    /// Gets a new NHibernate session.
    /// </summary>
    /// <returns>A new NHibernate session.</returns>
    public ISession Get()
    {
        var sessionStore = ServiceLocator.Resolve<INHibernateSessionStore>();
        ISession session = sessionStore.CurrentSession;

        if(session == null)
        {
            session = this.CreateNewSession();
            sessionStore.CurrentSession = session;
        }

        return session;
    }

    /// <summary>
    /// Closes the specified session.
    /// </summary>
    /// <param name="session">The session.</param>
    public void Close(ISession session)
    {
        if (session != null &&
            session.IsOpen)
        {
            session.Close();
        }
    }

    #endregion

    private ISession CreateNewSession()
    {
        // Implementation goes here
    }
}

/// <summary>
/// Container for storing an NHibernate session.
/// </summary>
public class NHibernateSessionStore : INHibernateSessionStore
{
    #region Implementation of INHibernateSessionStore

    /// <summary>
    /// Gets or sets the current session.
    /// </summary>
    /// <value>The current session.</value>
    public ISession CurrentSession { get; set; }

    #endregion
}

Castle Windsor Custom WCF Lifestyle

simon.brown — Tue, 27 Oct 2009 14:43:13 GMT

It’s been a while since my last post and I’ve been meaning to blog about this for ages now.

Recently, I’ve been creating a lot of WCF services and using Castle Windsor for managing dependencies, and I came across a scenario which required the same object instance to be returned from the container at any point it was requested during the same WCF method call.

Seeing as I was already using Castle Windsor to manage my dependencies it seemed appropriate to create a custom Windsor lifestyle for this purpose.

First I had to work out how to hook into the WCF context. Luckily in the System.ServiceModel namespace there is a class provided just for this purpose, OperationContext. OperationContext has a Current property which gives you access to the execution context for the current thread. The OperationContext also contains an Extensions collection which allows you to add custom data to the current context. To create your own extension you need to create a class which implements the IExtension<OperationContext> interface. I created an extension called WcfContext which contained a dictionary of objects to store in the context:

/// <summary>
/// ServiceModel.OperationContext extension for managing items.
/// </summary>
public class WcfContext : IExtension<OperationContext>
{
    #region Properties

    /// <summary>
    /// Gets or sets the items.
    /// </summary>
    /// <value>The items.</value>
    public IDictionary<string, object> Items { get; set; }

    #endregion

    #region Implementation of IExtension<OperationContext>

    /// <summary>
    /// Enables an extension object to find out when it has been aggregated. Called when the extension is added to the <see cref="P:System.ServiceModel.IExtensibleObject`1.Extensions" /> property.
    /// </summary>
    /// <param name="owner">The extensible object that aggregates this extension.</param>
    public void Attach(OperationContext owner)
    {
        Items = new Dictionary<string, object>();
    }

    /// <summary>
    /// Enables an object to find out when it is no longer aggregated. Called when an extension is removed from the <see cref="P:System.ServiceModel.IExtensibleObject`1.Extensions" /> property.
    /// </summary>
    /// <param name="owner">The extensible object that aggregates this extension.</param>
    public void Detach(OperationContext owner)
    {
    }

    #endregion
}

Next I had to create the custom Windsor lifestyle. This is achieved by creating a class which inherits from Castle.MicroKernel.Lifestyle.AbstractLifestyleManager (for more information on this check out the Castle Windsor site here). Then it was just a case of checking the current OperationContext, adding my WcfContext extension if it wasn’t already present, resolving the component, then adding the component to the WcfContext.Items dictionary. The next time the lifestyle is used within the same OperationContext the component is retrieved from the OperationContext instead of being resolved again by Windsor. Here’s the code:

/// <summary>
/// A custom Castle Windsor IoC lifestyle manager which stores the resolved object in the 
/// current OperationContext, therefore giving you a new instance of the requested 
/// component for each WCF request. 
/// </summary>
public class PerWcfRequestLifestyleManager : AbstractLifestyleManager
{
    #region AbstractLifestyleManager Members

    /// <summary>
    /// Resolves the specified context.
    /// </summary>
    /// <param name="context">The context.</param>
    /// <returns>The resolved object.</returns>
    public override object Resolve(CreationContext context)
    {
        object resolvedObject;

        // Get the type of the IoC component being resolved to use as the key for the OperationContext item. 
        var contextKey = GetContextKeyForComponent(context);

        if (OperationContext.Current != null)
        {
            var itemStorage = this.GetWcfContext();

            if(itemStorage == null)
            {
                OperationContext.Current.Extensions.Add(new WcfContext());
                itemStorage = this.GetWcfContext();
            }

            if (!itemStorage.Items.ContainsKey(contextKey))
            {
                resolvedObject = base.Resolve(context);
                itemStorage.Items[contextKey] = resolvedObject;
            }
            else
            {
                resolvedObject = itemStorage.Items[contextKey];
            }
        }
        else
        {
            resolvedObject = base.Resolve(context);
        }
 
        return resolvedObject;
    }

    /// <summary>
    /// Releases unmanaged and - optionally - managed resources
    /// </summary>
    public override void Dispose()
    {
    }

    #endregion

    #region Protected Methods

    /// <summary>
    /// Gets the context key for the component being resolved.
    /// </summary>
    /// <param name="context">The context.</param>
    /// <returns>The context key for the component being resolved.</returns>
    protected string GetContextKeyForComponent(CreationContext context)
    {
        // Default the key to be the full type name of the component being resolved.
        // NB: This will be the same for each dependency (e.g. constructor parameter) 
        //     being resolved for the component.
        //     The context.Handler is null when resolving a constructor parameter which is a <list>.
        string componentKey = context.Handler != null 
                                  ? context.Handler.ComponentModel.Implementation.FullName
                                  : Guid.NewGuid().ToString();

        if (context.Dependencies.Count > 0)
        {
            // This is actually a component dependency which is being resolved.
            // The key of the last dependency is the one which is being resolved.
            IEnumerator enumerator = context.Dependencies.GetEnumerator();
            int i = 0;
            while (enumerator.MoveNext())
            {
                i++;
                if (i == context.Dependencies.Count)
                {
                    componentKey = ((DependencyModel)enumerator.Current).DependencyKey;
                }
            }
        }

        return componentKey;
    }

    /// <summary>
    /// Gets the WCF context from the OperationContext.
    /// </summary>
    /// <returns>The WCF context.</returns>
    protected WcfContext GetWcfContext()
    {
        return OperationContext.Current.Extensions.FirstOrDefault(x => x.GetType() == typeof(WcfContext)) as WcfContext;
    }

    #endregion
}

I had a few issues generating a unique context key to use as the index to the WcfContext.Items collection but the solution I came up with seems to work for all of the scenarios I have encountered (see method GetContextKeyForComponent in the code snippet above). Essentially it uses the component name unless a component dependency (constructor parameter or property) is being resolved in which case the dependency name is used. You may need to amend this to account for other edge cases I have not encountered.

The custom lifestyle is attached to the relevant component via the Castle Windsor configuration file as follows:

<component id="MyClass"
           service="Data.IMyInterface, Data"
           type="Data.MyClass, Data"
           lifestyle="custom"
           customLifestyleType="Container.Lifestyles.PerWcfRequestLifestyleManager, Container.Lifestyles">
</component>

I hope somebody else finds this useful. I’ve used it on a few different projects now and it’s working well for me.

VMWare AddIn Crashes Visual Studio

simon.brown — Wed, 03 Dec 2008 10:39:00 GMT

Just a note of caution to anybody out there who is installing VMWare Workstation on a PC with Visual Studio installed.

Part of the VMWare install is to add the VMDebugger add-in to Visual Studio.

On my machine I was able to open Visual Studio but as soon as I tried to open or create a new project Visual Studio would crash.

I narrowed the issue down to the VMDebugger add-in.

To rectify the issue, go to Tools | Add-in Manager in Visual Studio and uncheck the VMDebugger add-in and Startup checkboxes.

It should look like this:

I found this to be an issue in both Visual Studio 2005 and 2008.

MSDN Roadshow Re-Run

simon.brown — Sat, 08 Nov 2008 23:41:00 GMT

I recently attended a re-run of the MSDN Roadshow at Microsoft's office in Victoria, London.

It was an overview of the latest offerings from Microsoft in the development space.

The agenda was as follows:

ADO.Next - Entity Framework and ADO.NET Data Services - Eric Nelson
ASP.Next - ASP.NET 3.5 SP1 and MVC - Mike Ormond
Silverlight V2 - Mike Taulty
Visual Studio Team Suite - Neil Kidd

The most interesting bit for me was the first session on the Entity Framework and ADO.NET Data Services. Entity Framework is an Object Relational Mapper (ORM) and Microsoft's answer to the hugely popular nHibernate. The Entity Framework still has a few quirks and is lacking in certain areas, and Microsoft seem to acknowledge this fact to their credit. It definitely seemed like a move in the right direction though with some pretty neat features.

As you would expect, Microsoft have included a wizard in Visual Studio (Entity Data Model Wizard) which you can point to a database, select the tables you're interested in, and it will generate your Entity Data Model for you. The data model consists of three different layers, each having it's own XML file and generated classes as follows:

Conceptual layer - The business entity model which is defined in an XML file using the Conceptual Schema Definition Language (CSDL)
Storage layer - A representation of the database schema which is defined in an XML file using the Store Schema Definition Language (SSDL)
Mapping layer - The mapping between the Conceptual and Storage layers which is defined in an XML file using the Mapping Schema Language (MSL)

An entity class is generated for each table in the database and also handles relationships by for example adding an Orders property (collection of Order objects) on the Customer class. Once the Entity Data Model has been generated it can then be manipulated by changing the XML files or the entity classes.

The Conceptual layer of the data model is queried by the developer using either Entity SQL (T-SQL like syntax for querying entities) or Linq (Linq for Entities). I can't imagine that anybody is going to be using Entity SQL when they can use Linq with it's expressive fluent interface. Eric recommended a tool to assist with writing Linq queries called LinqPad.

The Entity Framework also handles updates to the database including features such as Unit of Work and Identity Tracking (handling dirty data - updates which have occurred since the last database read) and Lazy Loading (this is possible, but not out-of-the-box, Eager Loading is the default mode).

I'm not sure whether Microsoft have done enough to convince nHibernate users to convert to using Entity Framework.

When Eric then went on to talk about ADO.NET Data Services that's when I started to see some real benefit to using the Entity Framework instead of nHibernate. Eric demonstrated the creation of a fully RESTful service with only a couple of lines of code. You can essentially just create a service which inherits from your Entity Data Model and "Hey Presto!" you have a RESTful service covering all CRUD operations throughout your entire data model! No need to create services anymore with methods like GetProductsById() or GetProductsByUserIdSortedByDate() or AddProduct() for each entity. This is all handled by ADO.NET Data Services. Very impressive stuff indeed!

I was even more impressed when Mike Ormond went on to talk about ASP.NET Dynamic Data. You can register your Entity Framework Data Model with Dynamic Data and a fully functional CRUD website with friendly urls is created for you using data driven page templates. RequiredFieldValidators are added for non-nullable fields, entry is limited to the number of characters the field can hold in the database, different controls are rendered based on the type of the field (e.g. check boxes for boolean values). This would be great for getting a fully functional site up and running really quickly, maybe for a prototype, or for a back end administration or simple Call Centre application.

To me this is where Microsoft really starts to excel. Their development teams seem to be working towards a common goal, with each product being built on a common framework. They develop functionality which can be utilised across their range of products. They make it easy for developers to get up and running really quickly and concentrate on delivering real business value, rather than writing boilerplate code. My only worry with this approach is that it's fine for simple applications but when things become more complex you start to hit problems. I'll have to give Microsoft the benefit of the doubt on that one as I haven't started to use any of this in anger yet!

There were some other interesting features demonstrated by Mike Ormond such as the AJAX history control, a preview of ASP.NET MVC and it's routing engine (which is also used for DynamicData), and the Silverlight ASP.NET controls <asp:Silverlight> and <asp:MediaPlayer>.

Mike Taulty discussed Silverlight 2 and Deep Zoom, and developed some Media Player Silverlight applications. He also showed us some good examples of Silverlight/Deep Zoom applications (Hard Rock Cafe, Media Toaster and Microsoft Downloads). He talked about the use of the HTMLPage and HTMLElement classes which can be used to manipulate the web page DOM from within a Silverlight application, retrieving data using limited SOAP or JSON services, and the storage of data on the client's machine using Isolated Storage.

IsolatedStorageFile.GetUserStoreForApplication();
IsolatedStorageSettings.ApplicationSettings["SettingName"];
IsolatedStorageSettings.ApplicationSettings.Save();

Neil Kidd then went on to give a demonstration of the Visual Studio Team Suite. This was mainly a demonstration of the test tools which have been around for a while now but also Database Professional (previously Data Dude) which was hugely impressive. Database Professional creates a separate file for each artifact (table, index, constraint, stored procedure etc) and contains impressive refactoring capabilities. You can change the name of a field in a table and it will automatically change the name in each of the places this is used (stored procedures, constraints etc). You can use the tool to compare the database project to an existing instance of the database and it will create update scripts for you to deploy changes. Neil also demonstrated writing database unit tests for testing stored procedures. DBA's have no excuses now! Database Professional also has an impressive tool for generating large amounts of varied test data based on rules you can specify. Very useful for performance testing. All-in-all a very nice looking product.

So, to conclude it was a very good event, with some very impressive new technology demonstrated, especially around Entity Framework, ADO.NET Data Services and ASP.NET Dynamic Data. Lots more for me to look at in my quest for continuous improvement!

Castle Windsor - Fluent Interface

simon.brown — Tue, 28 Oct 2008 11:47:00 GMT

I attended a Skills Matter event recently on Castle Windsor. The presenters of the session were Mike Hadlow and Gojko Adzic. Slides, code samples and screencasts of the event can be found on their blogs. Mike's session was a very good introduction to dependency injection with IoC and Gojko tackled some of the more advanced features of Windsor such as facilities.

I've been using Castle Windsor for a while now on my current project favouring the use of a configuration file rather than registering components using code.

However, those of you who prefer registering your components in code will be pleased to find out that Castle have added a fluent interface to their API for Windsor. I've included an example below:

var container = new WindsorContainer();
container.Register(Component.For<ICatalogService>().ImplementedBy<MyCatalogService>().Lifestyle.Singleton);

The fluent interface is only available in the trunk version, so you'll need to download the source and compile it yourself.

I've been injecting all of my dependencies using the constructor but Mike also pointed out that Windsor also supports injecting dependencies using a property setter. This is useful if the dependency is optional. The configuration required to achieve this is the same as for constructor injection. In the following example catalogRepository is a constructor parameter and Logger is a property on the MyCatalogService class.

<container  id="MyCatalogService" 
            service="MyNamespace.ICatalogService, MyAssembly" 
            type="MyNamespace.MyCatalogService, MyAssembly">
    <parameters>
        <catalogRepository>${MyCatalogRepository}</catalogRepository>
        <Logger>${MyLogger}</Logger>
    </parameters>
</container>

Something else mentioned was Windsor's support for generics. This is something I've had to tackle recently on my own project and is especially useful for mapping classes. The following is an example of how register a class (MyProductTypeMapper) which inherits from interface IMapper<Input, Output>.

public interface IMapper<Input, Output>
{
    Output Map(Input input);
}

public class MyProductTypeMapper : IMapper<DBProductType, EntityProductType>
{
    public EntityProductType Map(DBProductType input)
    {
        ...
    }
}

<container  id="MyProductTypeMapper" 
            service="MyNamespace.IMapper`2[[MyNamespace.DBProductType, MyAssembly],[MyNamespace.EntityProductType, MyAssembly]], MyAssembly" 
            type="MyNamespace.MyProductTypeMapper, MyAssembly">
</container>

Mike also mentioned the new Common Service Locator library which is available on Codeplex. It is an abstraction around your IoC container of choice (Castle Windsor, Spring, Unity, StructureMap etc).

Also covered at the event was the use of Castle Windsor facilities. Castle provide a set of facilities out of the box including Logging, FactorySupport and NHibernate. There is also a MethodValidator facility available which allows you to add Design by Contract style functionality into your applications. An example was given using the StartableFacility which can be used to add standard functionality before and after each method call. This could be used for instance to log the entry and exit of each method. It is also possible to create custom facilities.

This is just a subset of the areas covered in the session. If you're interested in Castle Windsor then I'd urge you to watch the screencast of the session on Gojko's blog.

Continuous Improvement

simon.brown — Sat, 04 Oct 2008 14:09:00 GMT

Sometimes in life you really come down to earth with a bump!

This is what happened to me on the first day of J.P. Boodhoo's recent Nothin But .NET bootcamp in Dusseldorf.

I like to think that I've been developing applications in the right way. I've been trying to follow good design principles, using design patterns and following best practice agile processes such as automated unit testing. Not only that, but trying to encourage others to do the same and championing some of these processes within my project. I don't think I'm the best developer in the world but I do pride myself on developing quality solutions in a professional manner. I try to keep up with new trends, tools and techniques and new language features and products.

This is however, a very fast moving industry and it doesn't take long to fall behind. This was the first lesson I learnt on day 1 of JP's course.

JP is a consummate professional. He is probably the most capable developer I have ever met. All of the course attendees were in awe of him, and these are no ordinary developers. The attendees were all very talented developers too, some of the best in Europe. JP writes code at the speed of light, having complete command of the keyboard (he never uses a mouse). In fact it seems that the only thing that's slowing him down is the speed of the virtual machine which is struggling to keep up with the ferocious battering of the keyboard. This is not only due to the fact that JP is fast at typing but more due to the fact that he has configured his development environment for optimum performance, using any tools at his disposal and learning every aspect of them. Resharper is his main tool of choice, as it is for many of us, but JP knows it inside out. He has an encyclopedic knowledge of keyboard shortcuts, it's a joy to watch.

Not only is he fast but the quality and design of the code is very high. JP is very well read and has extensive knowledge of design patterns and OO design principles, but the impressive bit is that he knows exactly when to use them. In the past I've worked with developers who have learnt a new pattern and then decided to use it everywhere like it's a silver bullet. Not so with JP. So what do we end up with? A very well designed application. Small classes containing small methods adhering to the Single Responsibility and Open Closed principles amongst others.

The way JP works is also very efficient. He takes a top down approach to development, starting with the UI, working down to the domain layer, introducing stubs as early as possible. Taking this approach the client gets very early visibility to the UI and is able to see if it works for them. Let's face it, a lot of the time the UI is the main part of the application that the client is interested in, so it makes sense to get this to them as early as possible. And let me be clear here, we're not talking about a prototype UI, but production quality code. Once the UI is finished, we can then move on to the Service and Domain layers. Taking a top down approach also stops you from over engineering a solution and being too reliant on underlying legacy data structures.

JP is also a vociferous proponent of Test Driven Design, or more specifically Behaviour Driven Design. Not only does he "talk the talk" but he also "walks the walk". JP never writes a line of production code without first writing a failing test, no excuses. In the past I’ve worked with developers who are very resistant to concepts such as TDD and good design principles, always having an excuse for not doing it (haven’t got enough time, the managers/clients aren’t interested etc.). This is not the case with JP. The tests are written using human readable English and fluent interfaces and constructed using interfaces and mocks meaning even the least technical of us can understand the functionality of the code we are testing. Writing the tests in this way helps to flesh out the design.

By now you're probably thinking that JP's bootcamp course is some kind of a cult, and this is the start of a big recruitment drive! Well, you'd be wrong. In fact one of the things that JP discourages is putting people on a pedestal. It's not healthy and it holds you back. Everybody has something to offer and improvements can always be made.

I learnt an awful lot about C#, OO Design, patterns, and best practice development on the course, and got to spend the week with a fantastic group of talented developers. However, the main thing I've learnt is that you can't rest on you laurels or past glories in this industry. Every single one of us can improve. We'll never know everything, we may never be a big shot in the industry, but that shouldn't stop us putting in the effort to improve ourselves.

Attending JP's course was like a big kick up the backside for me. That's enough talking for now. I'm wasting valuable study time!

For a more detailed and humorous account of JP's Dusseldorf course, checkout Michel Grootjans blog at http://geekswithblogs.net/alternativedotnet.

Talking of humour, I said I'd dedicate my first blog post to my good friend Ciaran Roarty, a fellow developer and the hottest new act on the Glasgow comedy scene! Check out his blog at http://www.ciaranroarty.com.