I’ll let a few queries from my current project say all that needs to be said.

public IEnumerable GetRolledUpEventsFor(DateTime tradeDate, IEnumerable tickers)
        {
            return worker.On(connection, session =>
                                             {
                                                 OrderEventRollup rollup = null;
                                                 return session.QueryOver()
                                                     .Where(x => x.TradeDate == tradeDate)
                                                     .WhereRestrictionOn(x => x.Ticker).IsIn(tickers.ToArray())
                                                     .Select(
                                                         list =>
                                                         list.SelectGroup(x => x.Ticker).WithAlias(() => rollup.Ticker)
                                                             .SelectSum(x => x.Shares).WithAlias(() => rollup.SharesTotal))
                                                     .TransformUsing(Transformers.AliasToBean())
                                                     .List();
                                             });
        }

 public IEnumerable GetBrokersByCode(IEnumerable brokerCodes)
        {
            if (brokerCodes.Count() == 0) return Enumerable.Empty();
            return worker.On(connection, session =>
                                         session.Query()
                                             .Where(x => brokerCodes.Contains(x.Code))
                                             .ToList()
                );
        }

public IEnumerable GetByTradeDateAndTicker(DateTime tradeDate, string ticker)
        {
            return worker.On(connection, session =>
                                             {
                                                 CSMSecurity security = null;
                                                 return session.QueryOver()
                                                     .Fetch(x => x.CSMSecurity).Eager
                                                     .Fetch(x => x.TSOrderSecuritySpec).Eager
                                                     .Fetch(x => x.CSMSecurity.CSMSecurityType).Eager
                                                     .JoinAlias(x => x.CSMSecurity,() => security)
                                                     .Where(x => x.TradeDate == tradeDate)
                                                     .Where(() => security.Ticker == ticker)
                                                     .List();
                                             });
        }

This last week Jeff Schumacher and I have been working on a fairly complex set of business logic driving the entire design from the outside in with specification style unit tests. In an effort to help our tester get a head start validating the logic and assumptions in our code we promised to create a simple UI. Jeff has some WPF experience, so I suggested we do a simple WPF application and he can show me his “XAML Fu”. I have yet to get beyond playing with XAML, so having a little toy project and pairing with someone who has some experience already is a great way to get your feet wet. I also suggested we use Calibun.Micro and awesome little library Rob Eisenberg that brings convention over configuration for WPF applications to the table. So we pulled down the library and cracked open Rob’s Soup to Nuts series of tutorials.

In part two of his series, Rob describes how to override Caliburn.Micro’s default Bootstrapper with a custom implementation using the Managed Extensibility Framework. At work we use Castle Windsor, so we followed along with the tutorial injecting Castle magic at the appropriate spots.

To provide a custom bootstrapper for Caliburn.Micro, you simply inherit from the Bootstrapper<T> where T is your shell view model and then override the GetInstance, GetAllInstances and BuildUp methods providing your own implementation. With the exception of the BuildUp method, they pretty much line up perfectly with Castle Windsor’s interface allowing you to simply wrap it. The BuildUp method is used to perform property injection on an already created instance, Castle Windsor does property injection by default on resolution of your types and does not explicitly expose a build up method. This is easily overcome by adding an extension method to the container to provide that service.

public static class WindsorExtensions
    {
       
        public static void BuildUp(this IWindsorContainer container, object instance)
        {
           instance.GetType().GetProperties()
                .Where(property => property.CanWrite && property.PropertyType.IsPublic)
                .Where(property => container.Kernel.HasComponent(property.PropertyType))
                .ForEach(property => property.SetValue(instance, container.Resolve(property.PropertyType), null));
        }
    }

The bootstrapper then looks like this:

public class CastleBootstrapper : Bootstrapper
    {
        private ApplicationContainer container;

        protected override void Configure()
        {
            container = new ApplicationContainer();
        }

        protected override object GetInstance(Type service, string key)
        {
            if (string.IsNullOrWhiteSpace(key))
                return container.Resolve(service);

            return container.Resolve(key);
        }

        protected override IEnumerable