Los Techies

Announcing: the Nashville ALT.NET User Group

hoffe — Wed, 06 Aug 2008 03:42:36 GMT

This has been a long time coming, but it's finally here!

Join the announcements list and jump in on the discussion. We'll plan our first meeting for later this month via the discussion list.

Disconnected - Channels Of Communication

mo.khan — Tue, 05 Aug 2008 05:05:59 GMT

A few weeks ago I started feeling a little over whelmed by the volume of interest in what I was up to. After reading a chapter from Tim Ferris' book, I decided to disconnect. It was the most effective advice I could have ever received. I went cold turkey. I turned off my phone and put it in a drawer. I completely stopped checking my email, and wouldn't allow myself to "surf" the net.

The result after a couple of weeks, I feel liberated... and refreshed!

The 4-Hour work Week: Escape 9-5, Live Anywhere, and Join the New Rich
by Timothy Ferris

Read more about this book...

The first couple of days were hard, I had the itch. I kept wondering... "what if an emergency happens and someone needs to get a hold of me?" There was no emergency, and the best part no shackles. When I finally checked my email, I spent 5 minutes scanning the email that seemed to contain "information" that was important to me. It was amazing how much "noise" I was able to filter out. This is something that Tim describes as a "Low Information Diet."

I'm toying with the idea of completely disconnecting my phone and I'm currently checking my email once a week (Mondays).

I looked back at a post that made remarkable difference to me when I first read it last year. It was JP's tips on becoming a more effective developer. In it he told us to limit the amount of instant messaging that we do during the day. Today I feel that instant messaging has been replaced by mailing lists, twitter, texting and RSS feeds. All of this can consume a good portion of your day, and for me causes me to lose focus, quickly. It's important to be selective about what information is important to keep you focused and to filter out what can wait.

I'm not saying this is for everyone, but the Low Information Diet is working for me, and my daughter is loving the extra focused attention she gets from her daddy (likewise for her daddy).

Rails notes, from the .NET side

bogardj — Tue, 05 Aug 2008 03:09:10 GMT

I'm starting a small experiment to try out Rails, and I'm keeping notes as I go. From the first day, here's what I have so far:

Rails easy to install

First MySQL (easy)
Ruby, another MSI and go
Rails - from gem
All easy to install, basically a one-click installer for all

gem installer is crazy nuts
Don't forget to actually start the MySQL service (duh)
rake is also nuts

rake db:migrate is my friend

The generators trump ridiculous wizards any day of the week

We as .NET developers seem to be rather infatuated with projects and wizards

Ridiculous how little code is needed
The Rails console script is nice to try things out (it's an interactive Ruby session)
I can't tell when I need to restart the console to pick up changes

On that last point, it's unbelievably ridiculous how little code is needed. When using Active Record, I don't have to create properties and business as I would with any other ORM. This comes from the ingenuity of Rails, combined with the power of Ruby. Literally, an Active Record class could be just two lines of code, with as many properties as you wanted.

Convention over configuration, or "the Rails way", took exactly 5 minutes to accept
e is a nice text editor, which I need to remember to pay for someday
I need to find a good color template for e
Remember when using e, to set the tab size to 2, and use soft tabs
I'm surprised how little I care that I'm not in VS when developing in Rails

I'm pretty much primarily using VS right now for a handful of features:

Compile, run, debug
Host ReSharper, TD.NET and VisualSVN (thanks Jeremy for reminding me on the last two)
An explorer-ish window to see my files

I got rid of all the other items quite a while back. I don't use the Toolbox window, the Server explorer, or the designer (the biggest waste).

I'm not trading my career for a Rails path, not by a long shot, but I'm really curious to see what other communities have come up with. More soon...

Ooops...

mo.khan — Mon, 04 Aug 2008 16:55:16 GMT

Mike left a comment on my last post on Windows Forms Databinding asking:

What do the tests look like?

On the ComboBox binding, why aren't you using adding the binding through DataBinding.Add? With the way you have it now if you change the value the combobox is bound too it doesn't get pushed back to the screen.

Well Mr. Mike, on the view implementation there were no tests... *hang my head in shame* Yup, we went at it trying to understand how Windows Forms Data bindings works, but if we had gone at it test first, we would have found that leveraging the built-in data bindings are not very testable. It requires having a BindingContext setup, and in some cases the controls have to actually be displayed for the bindings to actually kick in. Second, if we had gone test first, we would have noticed the issue the Mike brought up in regards to the ComboBox.

Feeling a little guilty about publishing code that wasn't well thought out, I decided to go at it again, with a test first approach. The test started off very high level. I knew the API that I wanted to work with, in this case a fluent interface for defining a binding to a control. The end result was quite different..

    [Concern(typeof (Create))]
    public class when_binding_a_property_from_an_object_to_a_combo_box : context_spec {
        [Test]
        public void should_initialize_the_combo_box_with_the_current_value_of_the_property() {
            combo_box.SelectedItem.should_be_equal_to(baby_girl);
        }

        protected override void under_these_conditions() {
            combo_box = new ComboBox();
            thing_to_bind_to = Dependency<IAnInterface>();
            baby_girl = Dependency<IAnInterface>();
            baby_boy = Dependency<IAnInterface>();

            combo_box.Items.Add(baby_boy);
            combo_box.Items.Add(baby_girl);

            thing_to_bind_to
                .setup_result_for(t => t.Child)
                .Return(baby_girl);
        }

        protected override void because_of() {
            Create
                .BindingFor(thing_to_bind_to)
                .BindToProperty(t => t.Child)
                .BoundToControl(combo_box);
        }

        private ComboBox combo_box;
        private IAnInterface thing_to_bind_to;
        private IAnInterface baby_girl;
        private IAnInterface baby_boy;
    }

The end result doesn't leverage the Windows Forms databindings at all. It registers event handlers for events on the controls.

    public class ComboBoxPropertyBinding<TypeToBindTo, PropertyType> : IPropertyBinding<PropertyType> {
        private readonly IPropertyBinder<TypeToBindTo, PropertyType> binder;

        public ComboBoxPropertyBinding(ComboBox control, IPropertyBinder<TypeToBindTo, PropertyType> binder) {
            this.binder = binder;
            control.SelectedItem = binder.CurrentValue();
            control.SelectedIndexChanged +=
                delegate { binder.ChangeValueOfPropertyTo(control.SelectedItem.ConvertedTo<PropertyType>()); };
        }

        public PropertyType CurrentValue() {
            return binder.CurrentValue();
        }
    }

If you're interested in the rest of the source code download the source here. The moral of the story... Don't become complacent and take off your TDD hat, prematurely. In most cases it can, and should be, tested. Your design will probably come out much cleaner then going at the problem head on without tests to back you up. Not only that, but tests also give you extension points for making changes, and dealing with different contexts you probably wouldn't have thought of right off the bat.

Query Objects with Repository Pattern Part 2

chadmyers — Sat, 02 Aug 2008 06:29:27 GMT

As promised in my previous post, I’m going to make our query object a little more flexible and dynamic.

First, this is what I really want to be able to do something like this:

var customers = repo.FindBy(
                new TopCustomersWithLowDiscountQuery()
                    .IncludePreferred()
                    .BelowDiscountThreshold(3)
                    .WithMoreSalesThan(500)
                    .As_BLOCKED EXPRESSION
);

Better yet, maybe even something like this:

var customers = repo.FindBy(
        new TopCustomersWithLowDiscountQuery()
            .IncludePreferred()
            .BelowDiscountThreshold(3)
            .WithMoreSalesThan(500)
        .AndAlso(
            new DeliquentCustomersQuery()
                .WithDebtOver(9999))
            
);

Strongly typed query objects, completely testable outside of the repository, chain-able together with other like-typed query objects using AndAlso or OrElse.

Ok, now how do we do it?

Expression Tree Helper (Naive)

First, I started with an extension method class to make dealing with some of the Expression<Func<ENTITY, bool>> expressions (which can get old to type) easier. What I needed was the ability to take two expressions and AndAlso or OrElse them together. AndAlso (&&) and OrElse (||) are both binary expressions represented by the BinaryExpression class in System.Linq.Expressions. You can combine two expressions together with any binary expression type by using the Expression.MakeBinary() method. One problem though is that both Expressions start with a different parameter (i.e. the ‘c’ in (c=>c.AnnualSales > 999)). So you can’t just join them together because, unfortunately, the Expression Tree compiler will get the ‘c’ parameters jumbled and it won’t work.

The way I found to deal with this problem is to basically wrap an ‘Invoke()’ expression around the other lambda using the first lambda’s parameter. In C# parlance, it’s the difference between these two things:

c => c.AnnualSales > 99 && c.Discount < 4
    -- VS.--
c => c.AnnualSales > 99 && new Func<Customer, bool>(x=> x.Discount < 4)(c));

See how the second one actually involves wrapping the other Lambda (.Discount < 4) with a function and then invokes it? I’m not sure if that’s EXACTLY what goes on when you use Expression.Invoke(), but that’s what I like to tell myself when I’m working with Expression Trees. It also helps to keep me from ending up in the corner in the fetal position drooling and babbling incoherently which is, unfortunately, a frequent occurrence when dealing with Expression Trees.

You may notice that I put the condition “naive” on this section. This is because my expression tree helper is very naive and doesn’t account for a lot of the crazy things you can do with Expression Trees. This means that you will probably bump against its limitations and have problems. Sorry in advance for this, but I’m stretching the limits of my knowledge here and doing well to write coherently about it. If you have problems, let me know and maybe we can work it out together.

Anyhow, once you’ve invoked the other lambda, you can join them together with whatever binary expression you want, and then you have to re-wrap them in a Lambda again in order to continue working with it. Without further ado, here’s my expression helper extension methods:

public static class ExpressionHelpers
{
    public static Expression<Func<T, bool>> AndAlso<T>(
        this Expression<Func<T, bool>> left,
        Expression<Func<T, bool>> right)
    {
        return BinaryOnExpressions(left, ExpressionType.AndAlso, right);
    }

    public static Expression<Func<T, bool>> OrElse<T>(
        this Expression<Func<T, bool>> left,
        Expression<Func<T, bool>> right)
    {
        return BinaryOnExpressions(left, ExpressionType.OrElse, right);
    }
        

    public static Expression<Func<T, bool>> BinaryOnExpressions<T>(
        this Expression<Func<T, bool>> left,
        ExpressionType binaryType,
        Expression<Func<T, bool>> right)
    {
        // Invoke that lambda with my parameter and give me the bool back, KKTHX
        var rightInvoke = Expression.Invoke(right, left.Parameters.Cast<Expression>());

        // make a binary expression between the results (i.e. AndAlso(&&), OrElse(||), etc)
        var binExpression = Expression.MakeBinary(binaryType, left.Body, rightInvoke);

        // Wrap it in a lambda and send it back
        return Expression.Lambda<Func<T, bool>>(binExpression, left.Parameters);
    }
}

With that out of the way, we can get on to the less complicated stuff which is chaining all these things together. The next thing I did was to create a simple abstract base class for my query objects (I’m sure there’s a million better ways to do this, but to get things running, this was the simplest thing that worked for right now).

Query Base Class

The query base is quite simple, actually. It just shuffles around the expressions and provides some convenience methods for you to chain them together:

public abstract class QueryBase<ENTITY>
{
    private Expression<Func<ENTITY, bool>> _curExpression;

    public Expression<Func<ENTITY, bool>> AsBLOCKED EXPRESSION
    {
        return _curExpression;
    }

    public Expression<Func<ENTITY, bool>> AndAlso(QueryBase<ENTITY> otherQuery)
    {
        AsBLOCKED EXPRESSION.AndAlso(otherQuery.AsBLOCKED EXPRESSION;
    }

    public Expression<Func<ENTITY, bool>> OrElse(QueryBase<ENTITY> otherQuery)
    {
        AsBLOCKED EXPRESSION.OrElse(otherQuery.AsBLOCKED EXPRESSION;
    }

    protected void addCriteria(Expression<Func<ENTITY, bool>> nextExpression)
    {
        _curExpression = (_curExpression == null)
                            ? nextExpression
                            : _curExpression.AndAlso(nextExpression);
    }
}

You can AND and OR two queries together (must be of the same type, for now). Sub-classes can add their own expressions in a nice, easy-to-use lambda expression style.

Query Implementation

And now, on to one of the actual query classes. Remember our ridiculously named and implemented TopCustomersWithLowDiscountQuery from my last post? Here it is in its more simplified form complete with Fluent-API bonus material:

public class TopCustomersWithLowDiscountQuery : QueryBase<Customer>
{
    public TopCustomersWithLowDiscountQuery IncludePreferred()
    {
        addCriteria(c => c.Preferred);
        return this;
    }

    public TopCustomersWithLowDiscountQuery BelowDiscountThreshold(decimal discountThresh)
    {
        addCriteria(c => c.Discount < discountThresh);
        return this;
    }

    public TopCustomersWithLowDiscountQuery WithMoreSalesThan(int salesThresh)
    {
        addCriteria(c => c.AnnualSales > salesThresh);
        return this;
    }
}

To use it, just chain the methods together. Consider this test case:

[Test]
public void low_discount_high_sales_customers_should_be_selected()
{
    _query = new TopCustomersWithLowDiscountQuery()
        .BelowDiscountThreshold(3)
        .WithMoreSalesThan(500);

    var high = 15m;
    var low = 1m;

    _customers.AddRange(new[]
    {
        new Customer {Id = 1, Discount = low, AnnualSales = 200},
        new Customer {Id = 2, Discount = low, AnnualSales = 800},
        new Customer {Id = 3, Discount = high, AnnualSales = 1000}
    });

    Results.Count().ShouldEqual(1);
    Results.ElementAt(0).Id.ShouldEqual(2);
}

If you want to chain them together, just use the AndAlso or OrElse methods. Consider this other test case which uses OrElse:

[Test]
public void preferred_customers_that_are_also_bad()
{
    _query = new TopCustomersWithLowDiscountQuery()
        .IncludePreferred();

    var otherQuery = new DeliquentCustomersQuery()
        .WithPendingLitigation()
        .WithDebtOver(999);

    _customers.AddRange(new[]
    {
        new Customer {Id = 1, Preferred = true, PendingLitigation = false, OutstandingDebts = 4000},
        new Customer {Id = 2, Preferred = false},
        new Customer {Id = 3, Preferred = false,  PendingLitigation = true, OutstandingDebts = 4000}
    });

    var results = _customers
        .AsQueryable()
        .Where(_query.OrElse(otherQuery));

    results.Count().ShouldEqual(2);
    results.ElementAt(0).Id.ShouldEqual(1);
    results.ElementAt(1).Id.ShouldEqual(3);
}

Windows Forms Data Binding

mo.khan — Sat, 02 Aug 2008 05:36:34 GMT

A couple of weeks ago, Adam and I were pairing on a new screen in a windows forms application. He started showing me some stuff that he had learned about windows forms data bindings. I showed him a little bit of what JP tried to teach me, back in the Austin Nothin' But .NET boot camp, about Expressions and we decided to try a different way of binding domain object to screen elements in our application. The following is a method on the view that's invoked from a presenter. It's given an object from our model to display.

        public void Display(IActionPlan actionPlan)
        {
            Create
                .BindingFor(actionPlan)
                .BindToProperty(a => a.RecommendedAction)
                .BoundToControl(uxRecommendedAction);

            Create
                .BindingFor(actionPlan)
                .BindToProperty(a => a.AccountablePerson)
                .BoundToControl(uxAccoutablePerson);

            Create
                .BindingFor(actionPlan)
                .BindToProperty(a => a.EstimatedCompletionDate)
                .BoundToControl(uxEstimatedCompletionDate);

            Create
                .BindingFor(actionPlan)
                .BindToProperty(a => a.EstimatedStartDate)
                .BoundToControl(uxEstimatedStartDate);

            Create.BindingFor(actionPlan)
                .BindToProperty(a => a.RequiredResources)
                .BoundToControl(uxResourcesRequired);

            Create.BindingFor(actionPlan)
                .BindToProperty(a => a.Priority)
                .BoundToControl(uxPriority);
        }

Each of our controls are prefixed with "ux". What we did was bind different types of controls to property's on the object to display. This immediately changed that state of the object as the user filled out information on the screen. The BindToPropery() method is given the property on the object to bind too. The following was the implementation we came up with.

    public static class Create
    {
        public static IBinding<T> BindingFor<T>(T object_to_bind_to)
        {
            return new ControlBinder<T>(object_to_bind_to);
        }
    }

    public interface IBinding<TypeToBindTo>
    {
        IBinder<TypeToBindTo> BindToProperty<T>(Expression<Func<TypeToBindTo, T>> property_to_bind_to);
    }

    public interface IBinder<TypeOfDomainObject>
    {
        string NameOfTheProperty { get; }
        TypeOfDomainObject InstanceToBindTo { get; }
    }

The implementation of the BindToProperty method takes in an input argument of type Expression<Func<TypeOfDomainObject>>. This allows us to inspect the expression to parse out the name of the property the binding is for. It's like treating code as data. The IControlBinder implements two interfaces. One that's issued to client components (IBinding) which restricts what they can do with the type. (see above in the Create class) The second interface exposes enough information for extension methods to pull from to build bindings for specific windows forms controls.

    public interface IControlBinder<TypeToBindTo> : IBinding<TypeToBindTo>, IBinder<TypeToBindTo>
    {
    }

    public class ControlBinder<TypeOfDomainObject> : IControlBinder<TypeOfDomainObject>
    {
        public ControlBinder(TypeOfDomainObject instance_to_bind_to)
        {
            InstanceToBindTo = instance_to_bind_to;
        }

        public IBinder<TypeOfDomainObject> BindToProperty<TypeOfPropertyToBindTo>(
            Expression<Func<TypeOfDomainObject, TypeOfPropertyToBindTo>> property_to_bind_to)
        {
            var expression = property_to_bind_to.Body as MemberExpression;
            NameOfTheProperty = expression.Member.Name;
            return this;
        }

        public string NameOfTheProperty { get; private set; }

        public TypeOfDomainObject InstanceToBindTo { get; private set; }
    }

The BoundToControl overloads were put into extension methods, allowing others to create new implementations of bindings without having to modify the Control binder itself. The extension methods....

    public static class ControlBindingExtensions {
        public static IControlBinding BoundToControl<TypeOfDomainObject>(
            this IBinder<TypeOfDomainObject> binder,
            TextBox control) {
            var property_binder = new TextPropertyBinding<TypeOfDomainObject>(
                control,
                binder.NameOfTheProperty,
                binder.InstanceToBindTo);
            property_binder.Bind();
            return property_binder;
        }

        public static IControlBinding BoundToControl<T>(this IBinder<T> binder, RichTextBox box1) {
            var property_binder = new TextPropertyBinding<T>(box1,
                                                             binder.NameOfTheProperty,
                                                             binder.InstanceToBindTo);
            property_binder.Bind();
            return property_binder;
        }

        public static IControlBinding BoundToControl<T>(this IBinder<T> binder, ComboBox box1) {
            var property_binder = new ComboBoxBinding<T>(box1,
                                                         binder.NameOfTheProperty,
                                                         binder.InstanceToBindTo);
            property_binder.Bind();
            return property_binder;
        }

        public static IControlBinding BoundToControl<T>(this IBinder<T> binder, DateTimePicker box1) {
            var property_binder = new DatePickerBinding<T>(box1,
                                                           binder.NameOfTheProperty,
                                                           binder.InstanceToBindTo);
            property_binder.Bind();
            return property_binder;
        }
    }

For completeness... the control bindings...

    public class TextPropertyBinding<TypeToBindTo> : IControlBinding {
        private readonly Control control_to_bind_to;
        private readonly string name_of_the_propery_to_bind;
        private readonly TypeToBindTo instance_of_the_object_to_bind_to;

        public TextPropertyBinding(
            Control control_to_bind_to,
            string name_of_the_propery_to_bind,
            TypeToBindTo instance_of_the_object_to_bind_to
            ) {
            this.control_to_bind_to = control_to_bind_to;
            this.name_of_the_propery_to_bind = name_of_the_propery_to_bind;
            this.instance_of_the_object_to_bind_to = instance_of_the_object_to_bind_to;
        }

        public void Bind() {
            control_to_bind_to.DataBindings.Clear();
            control_to_bind_to.DataBindings.Add(
                "Text",
                instance_of_the_object_to_bind_to,
                name_of_the_propery_to_bind);
        }
    }

    public class ComboBoxBinding<TypeToBindTo> : IControlBinding {
        private readonly ComboBox control_to_bind_to;
        private readonly string name_of_the_propery_to_bind;
        private readonly TypeToBindTo instance_of_the_object_to_bind_to;

        public ComboBoxBinding(ComboBox control_to_bind_to,
                               string name_of_the_propery_to_bind,
                               TypeToBindTo instance_of_the_object_to_bind_to) {
            this.control_to_bind_to = control_to_bind_to;
            this.name_of_the_propery_to_bind = name_of_the_propery_to_bind;
            this.instance_of_the_object_to_bind_to = instance_of_the_object_to_bind_to;
        }

        public void Bind() {
            control_to_bind_to.SelectedIndexChanged +=
                delegate {
                    typeof (TypeToBindTo)
                        .GetProperty(name_of_the_propery_to_bind)
                        .SetValue(
                        instance_of_the_object_to_bind_to,
                        control_to_bind_to.Items[control_to_bind_to.SelectedIndex],
                        null);
                };
        }
    }

    public class DatePickerBinding<TypeToBindTo> : IControlBinding {
        private readonly DateTimePicker control_to_bind_to;
        private readonly string name_of_the_propery_to_bind;
        private readonly TypeToBindTo instance_of_the_object_to_bind_to;

        public DatePickerBinding(DateTimePicker control_to_bind_to,
                                 string name_of_the_propery_to_bind,
                                 TypeToBindTo instance_of_the_object_to_bind_to) {
            this.control_to_bind_to = control_to_bind_to;
            this.name_of_the_propery_to_bind = name_of_the_propery_to_bind;
            this.instance_of_the_object_to_bind_to = instance_of_the_object_to_bind_to;
        }

        public void Bind() {
            control_to_bind_to.DataBindings.Clear();
            control_to_bind_to.DataBindings.Add(
                "Value",
                instance_of_the_object_to_bind_to,
                name_of_the_propery_to_bind);
        }
    }

We found that using the fluent interface for creating bindings was pretty easy and made screen synchronization a breeze, however, our implementation wasn't the easiest thing to test. So far it's been good to us.

As a side note... go register for the Las Vegas course, it may cause you to love your job! Also, if you've already attended a boot camp, and you think you already know what the course is about, you have no idea, it keeps getting better and better.

Query Objects with the Repository Pattern

chadmyers — Sat, 02 Aug 2008 04:17:46 GMT

Nate Kohari (whose primate brain is far too small to comprehend this post [inside joke, he’s actually really sharp]) was asking on Twitter today about how to structure his repositories: Per aggregate root, Per entity, or just one repository for everything?

The two suggestions that rose to the top were the per-aggregate and one repository approaches. Jeremy and I use a the one repository approach at work and it’s working well for us so far. The was one compelling argument for the per-aggregate repository and that is that you could encapsulate your aggregate-specific queries inside your aggregate-specific repositories.

Thinking about this a little more, I felt it had a little smell to it, namely the potential for business logic (also known as ‘where’ clauses) to creep into the repository which would be bad. Perhaps a better alternative would be to encapsulate the specific logic of a given query into an object. You could then have this object produce something that the repository could (blindly, decoupled) use to query on.

This approach allows you to maintain the one repository approach, yet still have encapsulated domain-specific queries. Plus, you can test your queries independently of the repository which is a huge benefit.

Creating and Passing Around Expression Trees

What might the query object produce that the repository could blindly use? In the .NET 3.5 world, you could use expression trees! These come in quite handy and play well with LINQ-style (IQueryable) behavior of Linq2NHibernate, Linq2Objects, and Linq2JustAboutAnythingThatInvolvesAListOfThings.

Producing an expression tree is actually quite simple: Have a method or property that returns Expression<Func<T,bool>>. Yep. That’s it. We can all go home now. In case you actually wanted to see some code, here’s a simple, extremely naive example of what I mean. Let’s say we wanted to find all our customers that have significant sales with our company, but whose discount is really low (for some reason). We’d like to find these customers and give them a better discount since they do so much business with us. Your query probably (wouldn’t) look something like this:

public class TopCustomersWithLowDiscountQuery
{
    public bool IncludePreferred { get; set; }
    public decimal DiscountThreshold { get; set; }
    public int SalesThreshold { get; set; }

    public Expression<Func<Customer, bool>> AsBLOCKED EXPRESSION
    {
        return (c =>
                c.Preferred == IncludePreferred
                && c.Discount < DiscountThreshold
                && c.AnnualSales > SalesThreshold);
    }
}

Using this query object, we can still get all the benefits of delayed execution that LINQ/IQueryable provides us without forcing us to sprinkle little surprises of business logic everywhere in LINQ queries.

Using the Expression Tree to Query

To actually use the expression tree, you can call the Where() method on any IEnumerable<T> or IQueryable<T>. Consider this silly/contrived example:

var query = new TopCustomersWithLowDiscountQuery
{
    IncludePreferred = true,
    DiscountThreshold = 3,
    SalesThreshold = 100000
};

var customerList = new List<Customer>
{
    new Customer {Id = 1, Preferred = true},
    new Customer {Id = 2, Preferred = false},
    new Customer {Id = 3, Preferred = true}
};

var filteredCustomers = 
    customerList
        .AsQueryable()
        .Where(query.AsBLOCKED EXPRESSION;

Once GetEnumerator() is called on filteredCustomers, the magic happens and you’ll end up with an IEnumerable<T> that has only 2 elements in id (ID=1, and ID=3).

Full Code Example

Here’s the full code of the test fixture I was using for these examples. Yes, I know it’s not very realistic and there are lots of potential problems with the logic in the query object, but the point was to illustrate how you might go about encapsulating LINQ where clauses, so please go easy on me :)

[TestFixture]
    public class TopCustomersWithLowDiscountQueryTester
    {
        [Test]
        public void preferred_customers_should_be_selected_when_IncludePreferred_is_true()
        {
            _customers.AddRange(new[]
            {
                new Customer {Id = 1, Preferred = true},
                new Customer {Id = 2, Preferred = false},
                new Customer {Id = 3, Preferred = true}
            });

            Results.Count().ShouldEqual(2);
            Results.ElementAt(0).Id.ShouldEqual(1);
            Results.ElementAt(1).Id.ShouldEqual(3);
        }

        [Test]
        public void high_discount_customers_should_not_be_selected()
        {
            _query.IncludePreferred = false;

            var high = 15m;
            var low = 1m;

            _customers.AddRange(new[]
            {
                new Customer {Id = 1, Discount = high},
                new Customer {Id = 2, Discount = low},
                new Customer {Id = 3, Discount = high}
            });

            Results.Count().ShouldEqual(1);
            Results.ElementAt(0).Id.ShouldEqual(2);
        }

        [SetUp]
        public void SetUp()
        {
            _query = new TopCustomersWithLowDiscountQuery
            {
                IncludePreferred = true,
                DiscountThreshold = 3,
                SalesThreshold = 100000
            };

            _customers = new List<Customer>();
            _resultsCached = null;
        }

        private TopCustomersWithLowDiscountQuery _query;
        private List<Customer> _customers;
        private IEnumerable<Customer> _resultsCached;

        public IEnumerable<Customer> Results
        {
            get { return _resultsCached ?? _customers.AsQueryable().Where(_query.AsBLOCKED EXPRESSION; }
        }
    }

    public static class SpecificationExtensions
    {
        public static void ShouldEqual(this object actual, object expected)
        {
            Assert.AreEqual(actual, expected);
        }
    }

Coming up…

Stay tuned: I’m going to do a follow-on post on how you can make the query object code a little more elegant, as well as chain them together with AndAlso and OrElse expressions.

StuctureMap: Advanced-level Usage Scenarios (Part 1: Type/Convention Scanners)

chadmyers — Sat, 02 Aug 2008 01:51:58 GMT

I’ll start with my strong hand on the advanced StructureMap-foo and go straight to the type scanners (a.k.a. convention scanners). Thankfully, there was a thread on the StructureMap Users mailing list with just the kind of problem these things solve. I’ll use that problem as the strawman for this post.

The Problem

Let’s say you had an IRepository<T> interface implemented by an abstract base class (RepositoryBase<T>) which, in turn, is implemented by many classes – one for each entity. Let’s say your implementations looked something like this:

public interface IRepository<T>
{
    // intersting stuff here    
}

public abstract class RepositoryBase<T> : IRepository<T>
{
    // interesting abstract base stuff here
}

public class UserRepository : RepositoryBase<User>
{
        // interesting abstract base stuff here
}

// ... a bunch more of these CustomerRepository, SaleRepository, etc

And you you may add more in the future and you’d rather not have to register them all individually in StructureMap like this:

// You don't have to do this!
StructureMapConfiguration
    .ForRequestedType<IRepositor<User>>.TheDefaultIsConcreteType<UserRepository>()
    .ForRequestedType<IRepositor<Customer>>.TheDefaultIsConcreteType<CustomerRepository>()
    .ForRequestedType<IRepositor<Sale>>.TheDefaultIsConcreteType<SaleRepository>();

What would be nice is if StructureMap could automatically figure my convention out. Well, unfortunately it won’t do that. BUT you can give it enough of a hint so that it CAN do it using your own ITypeScanner implementation. ITypeScanner has one method on it: Process(Type, Registry). StructureMap will call Process() for each Type it finds when scanning (using ScanAssemblies). Your scanner can, if it wants, add things to the container (through the ‘Registry’ parameter). This allows you to do all sorts of cool things like automatically find any types Foo which implement an interface named IFoo (or Bar/IBar, Something/ISomething, etc) and register them for you. In fact, this last example is done for you using StructureMap.Graph.DefaultConventionScanner. Here, let me show you:

ScanAssemblies().IncludeTheCallingAssembly()
    .IncludeTheCallingAssembly()
    .With<DefaultConventionScanner>()

Implementing our Repository Convention ITypeScanner

First, create a class that implements ITypeScanner. Let’s call it RepositoryConvention.

The next thing we’ll need is a method that will, given a type, see if it’s the type of generic type we’re looking for (i.e. RepositoryBase<T>), and return what the T parameter is (i.e. <User>). With this, we can register an IRepository<User> in StructureMap for that class (UserRepository, for example). It might look something like this:

private static Type GetGenericParamFor(Type typeToInspect, Type genericType)
{
    var baseType = typeToInspect.BaseType;
    if (baseType != null
        && baseType.IsGenericType
        && baseType.GetGenericTypeDefinition().Equals(genericType))
    {
        return baseType.GetGenericArguments()[0];
    }

    return null;
}

This will take a given type (i.e. UserRepository) and check it’s base type (i.e. RepositoryBase<User>) to see if it’s generic and if it’s the generic type we’re looking for. If so, it’ll return the “User” portion of RepositorBase<User>, for example.

Now, our process method looks something like:

public void Process(Type type, Registry registry)
{
    Type entityType = GetGenericParamFor(type, typeof(RepositoryBase<>));

    if (entityType != null)
    {
        var genType = typeof(IRepository<>).MakeGenericType(entityType);
        registry.ForRequestedType(genType).AddInstance(new ConfiguredInstance(type));
    }
}

We try to get the entityType (i.e. User). If present, then we create a new specific type from the generic IRepository<T> and register it. In our UserRepository case, it’ll register IRepository<User> with the default concrete type of UserRepository. Our whole class now looks like this:

public class RepositoryConvention : ITypeScanner
{
    public void Process(Type type, Registry registry)
    {
        Type entityType = GetGenericParamFor(type, typeof(RepositoryBase<>));

        if (entityType != null)
        {
            var genType = typeof(IRepository<>).MakeGenericType(entityType);
            registry.ForRequestedType(genType).AddInstance(new ConfiguredInstance(type));
        }
    }

    private static Type GetGenericParamFor(Type typeToInspect, Type genericType)
    {
        var baseType = typeToInspect.BaseType;
        if (baseType != null
            && baseType.IsGenericType
            && baseType.GetGenericTypeDefinition().Equals(genericType))
        {
            return baseType.GetGenericArguments()[0];
        }

        return null;
    }
}

Now, we need to let StructureMap know about it…

Configuring StructureMap with the new Scanner

Now, somewhere in your bootstrapping/startup routines for your app, add the With() call to your ScanAssemblies configuration. It should end up looking like this:

StructureMapConfiguration
   .ScanAssemblies()
   .IncludeTheCallingAssembly()
    // maybe other assemblies, too?
   .With(new RepositoryConvention());  // add our convention for wiring up the repos

As StructureMap mines through all the types in your assemblies, it’ll pass them to your Process() method where you can evaluate whether they meet your Repository convention and register them accordingly.

Using the Repository

Finally, to grab one of your newly configured repositories, you can simple make a normal ObjectFactory GetInstance call:

var userRepo = ObjectFactory.GetInstance<IRepository<User>>();

Also, it’ll work with for normal constructor injection scenarios. For example:

public class SomeService
{
    private readonly IRepository<User> _userRepo;

    public SomeService(IRepository<User> userRepo)
    {
        _userRepo = userRepo;
    }
}

What else can you do?

I hope as you come up with clever uses for this convention technique you let us know about them! As a teaser, here’s something Jeremy and I are doing:

public class ControllerConvention : TypeRules, ITypeScanner
{
    public void Process(Type type, Registry registry)
    {
        if (CanBeCast(typeof (IController), type))
        {
            string name = type.Name.Replace("Controller", "").ToLower();
            registry.AddInstanceOf(typeof (IController), new ConfiguredInstance(type).WithName(name));
        }
    }
}

See if you can guess what that’s for… ;)

Recursive Command

mo.khan — Fri, 01 Aug 2008 15:38:55 GMT

Note: this entry has moved.

When building up a tree view that represents the directory structure of a file system, like the windows explorer, my first reaction was to use recursion to traverse the file system and build up a tree. I quickly found that doing something like that is a time consuming process, and required some optimization.

I came up with what I like to call the recursive command. Each Tree Node item on a tree view is bound to a command to execute. The command looks like this...

public interface ITreeNodeClickedCommand {
    void Execute(ITreeNode node);
}

When the command is executed, the command gets an opportunity to modify the state of the tree node that was clicked. In this case I wanted to lazy load the sub directories of a node that was clicked. The command implementation looks like this...

public interface IAddFoldersCommand : ITreeNodeClickedCommand {}

public class AddFoldersCommand : IAddFoldersCommand {
    private readonly DirectoryInfo the_current_directory;
    private bool has_executed;

    public AddFoldersCommand(DirectoryInfo the_current_directory) {
        this.the_current_directory = the_current_directory;
    }

    public void Execute(ITreeNode node) {
        if (!has_executed) {
            foreach (var directory in the_current_directory.GetDirectories()) {
                node.Add(new TreeNodeItem(directory.Name, ApplicationIcons.Folder, new AddFoldersCommand(directory)));
            }
        }
        has_executed = true;
    }
}

This command is executed each time the tree node that it is bound too is clicked, but will only build up the child tree node items once. Each of the child tree nodes are bound to a new instance of the same command. Hence, what I like to call the recursive command.

For more information on the command pattern check out WikiPedia's write up.

Parents, talk to your kids about Linux...

Jason Meridth — Fri, 01 Aug 2008 03:58:02 GMT

Saw this today on xkcd.com: I wish this wasn't true, but I've seen it happen.

Trusted Subsystem, WCF and IIS 5 - revisited

bogardj — Fri, 01 Aug 2008 01:26:00 GMT

In my last post, I tried to get the following scenario to work:

One thing I didn't add was that I'm running IIS in Windows XP, in IIS 5. In this article on CodePlex, which I originally modeled my solution after and a couple of folks pointed out, it recommends setting both the ASP.NET identity (outside the Trusted Zone) and the App Pool identity to the Service account identity.

Now, in my case, I don't care about who calls my service, nor do I want any requirement on their side to provide any transport security. The article also recommends this, but I don't need it.

The real problem came from me running in IIS 5. In IIS 5, the aspnet_wp process runs as MACHINE\ASPNET, which examining WindowsIdentity.GetCurrent() confirmed. Even though I set the identity in IIS to use the service account as anonymous user, WCF by default uses the process identity, not any other identity. WCF has no knowledge of the host environment, by default, so it doesn't know it's hosted in ASP.NET or IIS normally.

To do a Trusted Subsystem model under IIS 5, I had to make the following changes:

Set the anonymous account to the service account, turn off any other security (like Integrated Windows Security)
Turn on impersonation in the web.config (<identity impersonate="true" />)
Turn on ASP.NET compatibility for the service hosting environment and each individual service

The last part is critical, and detailed in this MSDN article. I've had to do that before, when designing JSON services for an AJAX application, where the services needed access to HttpContext.Session.

Once ASP.NET compatibility is turned on, WCF requests now go through the ASP.NET pipeline, which means the normal ASP.NET impersonation model. From the article:

WCF services run using the current identity of the ASP.NET impersonated thread, which may be different than the IIS process identity if ASP.NET impersonation has been enabled for the application.

With the full ASP.NET impersonation set up, and the correct identity set up in IIS, WCF could now take the identity of the ASP.NET impersonated thread. Even though Thread.CurrentPrincipal reflected the service identity, WCF won't use it unless I set up the compatibility mode.

Of course, if I had been developing in a Workstation 2008 machine, or something with IIS 6 or 7, this wouldn't be a problem. Setting the App Pool identity is the process identity. In IIS 5, the identity is configured elsewhere. In any case, it's all working now locally. I guess this means it's finally time to upgrade to Workstation 2008.

Thanks to everyone for all the pointers!

Trusted Subsystem, WCF and IIS

bogardj — Thu, 31 Jul 2008 03:43:39 GMT

I've just about pulled my hair out on this one. This used to be very easy with ASMX:

Basically, I have IIS running as a trusted user, "Service". I want WCF to run as this user for connecting to databases, etc. I don't care who's calling me, I'm in an intranet environment, and this service is open to the world. Unfortunately, all I can ever get is "user not associated with a trusted connection", no matter what I do. I suspect it's due to a network hop issue, or something similar. I can get it to work by flowing identity down, but I don't want to do that, it's not Trusted Subsystem.

I've spent about a day on two separate occasions trying to get this to work, but all examples seem to force me to set the service account on the ASP.NET side. But I don't want to force clients to do any kind of security, that defeats the purpose.

The quickest way to Trusted Subsystem now is to use SQL Server authentication. With ASMX, I used ASP.NET configuration, along with IIS security configuration to set the identity, and it worked just fine. WCF works outside the ASP.NET stack, so I don't have that luxury. Security in WCF is tough, kids, don't let anyone tell you any different.

Boo.

Integrating StructureMap with WCF

bogardj — Wed, 30 Jul 2008 03:44:00 GMT

When developing with an IoC container like StructureMap, eventually some place in your code you will need to call the registry to instantiate your classes with their dependencies. With StructureMap, this means a call to ObjectFactory.GetInstance. Ideally, we'd like to limit the number of places the registry is called, so that we don't have a lot of StructureMap concerns sprinkled throughout our application.

Suppose we have the following WCF service:

public class CustomerSearchService : ICustomerSearchService
{
    private readonly ICustomerRepository _customerRepository;
    private readonly ICustomerSummaryMapper _customerSummaryMapper;

    public CustomerSearchService(ICustomerRepository customerRepository, ICustomerSummaryMapper customerSummaryMapper)
    {
        _customerRepository = customerRepository;
        _customerSummaryMapper = customerSummaryMapper;
    }

    public CustomerSearchResult FindCustomerByName(string fullName)
    {
        Customer customer = _customerRepository.FindCustomerByName(fullName);

        if (customer == null)
        {
            return new CustomerSearchResult
                       {
                           IsSuccessful = false,
                           FailureReasons = new[] {"Customer not found."}
                       };
        }

        CustomerSummary summary = _customerSummaryMapper.MapFrom(customer);

        return  new CustomerSearchResult {IsSuccessful = true, Result = summary};
    }
}

Nothing too exciting, just a search service that returns customer summary information from a name search. Now, if we just try to use this service as is, we get a fun exception:

The service type provided could not be loaded as a service because it does not have a default (parameter-less) constructor. To fix the problem, add a default constructor to the type, or pass an instance of the type to the host.

That makes sense, as WCF is in charge of instantiating my service class (CustomerSearchService), but it only knows how to call a no-args constructor. For a quick fix, we can add this constructor:

public CustomerSearchService()
    : this(ObjectFactory.GetInstance<ICustomerRepository>(), 
        ObjectFactory.GetInstance<ICustomerSummaryMapper>())
{
}

Each of our WCF services would need to the same thing, have a bunch of ObjectFactory calls to set up the dependencies appropriately. But we can find a better way, and have all of our services wired up automatically, with only one call to StructureMap in the entire application. To do this, we'll need to plug in to a few WCF extension points to make it happen.

A custom instance provider

WCF provides an interface just for this purpose, IInstanceProvider, that allows us to create custom instantiation behavior. This interface has basically two methods:

CreateInstance - needs to return the right service
ReleaseInstance - if we have some custom cleanup to do

Just creating the IInstanceProvider isn't enough, we'll have to tell WCF to use our instance provider, instead of its own default instance provider. This requires a custom endpoint behavior. We can't configure the instance provider directly, through configuration or other means. Instead, we'll use a custom service behavior through the IServiceBehavior interface. Here's the implementation of our custom service behavior:

public class StructureMapServiceBehavior : IServiceBehavior
{
    public void ApplyDispatchBehavior(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase)
    {
        foreach (ChannelDispatcherBase cdb in serviceHostBase.ChannelDispatchers)
        {
            ChannelDispatcher cd = cdb as ChannelDispatcher;
            if (cd != null)
            {
                foreach (EndpointDispatcher ed in cd.Endpoints)
                {
                    ed.DispatchRuntime.InstanceProvider = 
                        new StructureMapInstanceProvider(serviceDescription.ServiceType);
                }
            }
        }
    }

    public void AddBindingParameters(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase, Collection<ServiceEndpoint> endpoints, BindingParameterCollection bindingParameters)
    {
    }

    public void Validate(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase)
    {
    }
}

For all of the endpoints in all of the channels, we need to give WCF our custom instance provider. Also, since StructureMap needs to know what type to create, we have to pass that information along to our instance provider. This comes from the ServiceDescription passed in above.

With our service behavior done, let's create the actual instance provider, which will call StructureMap:

public class StructureMapInstanceProvider : IInstanceProvider
{
    private readonly Type _serviceType;

    public StructureMapInstanceProvider(Type serviceType)
    {
        _serviceType = serviceType;
    }

    public object GetInstance(InstanceContext instanceContext)
    {
        return GetInstance(instanceContext, null);
    }

    public object GetInstance(InstanceContext instanceContext, Message message)
    {
        return ObjectFactory.GetInstance(_serviceType);
    }

    public void ReleaseInstance(InstanceContext instanceContext, object instance)
    {
    }
}

Pretty straightforward, we just capture the service type (passed in from our service behavior earlier), then use ObjectFactory to create an instance of that service when asked. There's no information on the InstanceContext about the service type, or we could have just used it instead.

Now that we have our IInstanceProvider and IServiceBehavior, it's time to hook up this new service behavior to the rest of WCF. We have a few choices:

Attributes
Custom service host
Configuration

With attributes, we'd decorate all of our services with something like [StructureMapServiceBehavior] or something similar, so that WCF would know to attach our IServiceBehavior to the ServiceDescription behaviors. Attributes are okay, but again, we'd have to put something on all of our services. Since the whole point of this exercise was to reduce the footprint, let's go the custom service host route.

As for configuration, I can't stand XML, so let's just pretend that one doesn't exist.

A custom service host

By going the custom ServiceHost route, we'll just need to plug in to the right event to add our custom service behavior to the mix. Here's what we wind up creating:

public class StructureMapServiceHost : ServiceHost
{
    public StructureMapServiceHost()
    {
    }

    public StructureMapServiceHost(Type serviceType, params Uri[] baseAddresses)
        : base(serviceType, baseAddresses)
    {
    }

    protected override void OnOpening()
    {
        Description.Behaviors.Add(new StructureMapServiceBehavior());
        base.OnOpening();
    }
}

Nothing too exciting, we just add our custom service behavior to the ServiceDescription Behaviors collection, right before the service host is opened in the OnOpening method.

Next, to plug in our custom service host, we'll need a custom service host factory:

public class StructureMapServiceHostFactory : ServiceHostFactory
{
    public StructureMapServiceHostFactory()
    {
        StructureMapConfiguration
            .ScanAssemblies()
            .IncludeTheCallingAssembly()
            .With<DefaultConventionScanner>();
    }

    protected override ServiceHost CreateServiceHost(Type serviceType, Uri[] baseAddresses)
    {
        return new StructureMapServiceHost(serviceType, baseAddresses);
    }
}

The overridden method makes sense, override the CreateServiceHost to...create our custom service host. However, there's quite a bit going on in the constructor.

At this point, it will start to matter how you'd like StructureMap to be configured:

Attributes
XML config
Code

I'm liking the code way, as we don't have to have crazy XML or a bunch of attributes everywhere. Which way you configure is up to you, but if you go the code route, you'll need to put the StructureMap configuration in the constructor here.

Finally, we'll need to configure our WCF service to use this service host factory. I'm using IIS to host, so I'll just need to change my .svc file:

<%@ ServiceHost Language="C#" Debug="true" 
    Service="SMExample.Wcf.CustomerSearchService" 
    Factory="SMExample.Wcf.StructureMapServiceHostFactory" %>

Other hosting solutions will use different ways of using the custom service host factory.

Recap

We wanted to use StructureMap with WCF, but this initially presented us with some problems. WCF requires a no-args constructor, which means we'll have to use a lot of ObjectFactory.GetInstance calls on every service implementation.

Instead, we can use WCF extension points to use StructureMap to create the service for us, without needing that messy constructor. We created two extensions:

IInstanceProvider
IServiceBehavior

Once we had our custom instance provider and service behavior, we needed to decide how our custom service behavior would get attached to our service. We chose the custom service host route, which meant two more custom WCF implementations:

ServiceHost
ServiceHostFactory

The ServiceHostFactory implementation forced us to decide how our dependencies should be configured in StructureMap, and we went the code route. Finally, we configured our service host in IIS to use the right service host factory.

With all this in place, none of our service classes nor their implementations need to know anything about StructureMap, allowing their design to grow and change outside of WCF construction concerns. We also reduced the footprint of StructureMap in our application, where we now had exactly one call to the StructureMap infrastructure, ObjectFactory.GetInstance. With this one place StructureMap is used, it will be easier to swap out IoC container implementations (just kidding, Jeremy).

StructureMap: Interlude

chadmyers — Sat, 26 Jul 2008 17:54:53 GMT

I'm trying to wrap up the "StructureMap: Advanced Scenarios Usage" post. In the meantime, I wanted to make you aware of a few things:

I just updated my StructureMap: Basic Scenario Usage post with a correction. I was mistaken about being able to set properties on configured objects. Currently, you cannot configure properties on configured objects unless the property has the [SetterProperty] attribute defined. This was on purpose since there is a good argument that property injection is 'bad' (i.e. leads to problems later, can complicate configuration and testing, etc). There are, however, scenarios where property injection is acceptable so being able to configure properties without using the attribute is being seriously considered for the StructureMap 2.5 release.
Derik Whitaker posted about how to use StructureMap in an MSTest situation to work around some of MSTest's quirks. He used StructureMap's ability to configure itself through XML in your web.config/app.config file rather than having a separate XML file. Or you could, of course, save half your time and tons of complexity and just use NUnit/MBUnit/XUnit and not deal with the hassle. But it's good for those people required to use MSTest to still be able to take advantage of StructureMap.
You should know that Joshua Flanagan was the one who contributed that feature (the app.config configuration stuff) to StructureMap which is useful for a variety of reasons -- not just the MSTest reason. The reason you should know of him is because...
The same Joshua just posted a great post on how to get started from the most basic level with StructureMap. It's a "Hello World" type app, but shows off some of the ways StructureMap works. Of course it's overdone as a Hello World app, but that wasn't the point. The point is to show how to get started with StructureMap and I think it does a really good job at that.

Arrange Act Assert and BDD specifications

bogardj — Thu, 24 Jul 2008 13:18:04 GMT

With Rhino Mocks 3.5 just around the corner, I've started using it to create much more readable tests. One of the things that always bothered me with Expect.Call, constraints and the like was that it mixed in the Arrange with Assert. For those that haven't heard of AAA, it's a pattern for authoring unit tests:

Arrange - set up the unit under test
Act - exercise the unit under test, capturing any resulting state
Assert - verify the behavior through assertions

As I moved towards BDD context/specification style tests, working with Rhino Mocks didn't fit the picture very well. But with the new AAA syntax of Rhino Mocks 3.5, I can very cleanly separate out the behavior I want to observe from the mechanics of setting up the test.

Here's a normal unit test, as I would have written it about a year ago:

[Fact]
public void Should_send_email_when_order_is_over_200()
{
    MockRepository repo = new MockRepository();

    //Arrange
    ISmtpClient mockClient = repo.DynamicMock<ISmtpClient>();
    IOrderSpec stubSpec = repo.DynamicMock<IOrderSpec>();
    MailMessage actual = null;

    Order order = new Order();
    order.Total = 201.0m;

    using (repo.Record())
    {
        mockClient.Send(null);

        // Also assert?
        LastCall
            .IgnoreArguments()
            .Do(new Action<MailMessage>(message => actual = message));

        SetupResult
            .For(stubSpec.IsMatch(order))
            .Return(true);
    }

    OrderProcessor pr = new OrderProcessor(mockClient, stubSpec);

    // Act
    pr.PlaceOrder(order);

    // Assert
    actual.ShouldNotBeNull();
    actual.To.Count.ShouldEqual(1);
    actual.To[0].Address.ShouldEqual("salesdude@email.com");

    repo.VerifyAll();
}

It's a really long test, but the basic idea is that an email needs to be sent out to the sales guy when big orders get placed. The sales guy wanted to follow up immediately, to try and sell more (we think). I see many issues with this test:

It's frickin' huge
I can't tell what the point of it is at first glance
It's really hard to tell what's being tested

Moving towards the context/specification style, but still with Rhino Mocks improved things somewhat, but it's still quite awkward:

public class When_placing_a_large_order 
    : ContextSpecification
{
    private MockRepository _repo;
    private OrderProcessor _orderProcessor;
    private Order _order;
    private MailMessage _actual;

    protected override void EstablishContext()
    {
        _repo = new MockRepository();

        ISmtpClient mockClient = _repo.DynamicMock<ISmtpClient>();
        IOrderSpec stubSpec = _repo.DynamicMock<IOrderSpec>();
        _actual = null;

        _order = new Order();
        _order.Total = 201.0m;

        using (_repo.Record())
        {
            mockClient.Send(null);

            // Also assert?
            LastCall
                .IgnoreArguments()
                .Do(new Action<MailMessage>(message => _actual = message));

            SetupResult
                .For(stubSpec.IsMatch(_order))
                .Return(true);
        }

        _orderProcessor = new OrderProcessor(mockClient, stubSpec);
    }

    protected override void Because()
    {
        _orderProcessor.PlaceOrder(_order);
    }

    [Test]
    public void Should_send_the_email_out()
    {
        _actual.ShouldNotBeNull();
    }

    [Test]
    public void Email_sent_should_be_addressed_to_the_sales_guy()
    {
        _actual.To.Count.ShouldEqual(1);
        _actual.To[0].Address.ShouldEqual("salesdude@email.com");
    }

    [Test]
    public void Should_verify_all_expectations()
    {
        _repo.VerifyAll();
    }
}

Again, I have to do some strange things to capture the output, and the record/replay model doesn't jive well with BDD-style specifications. I always had this one observation that said, "Should verify all expectations". Not very interesting, and not descriptive of the behavior I want to observe. It doesn't describe any behavior, just some cleanup assertion for the MockRepository.

Finally, let's see how the AAA syntax of Rhino Mocks 3.5 clears things up:

public class When_placing_a_large_order 
    : ContextSpecification
{
    private OrderProcessor _orderProcessor;
    private Order _order;
    private ISmtpClient _mockClient;

    protected override void EstablishContext()
    {
        _mockClient = Dependency<ISmtpClient>();
        IOrderSpec stubSpec = Stub<IOrderSpec>();

        _order = new Order();
        _order.Total = 201.0m;

        stubSpec.Stub(x => x.IsMatch(_order)).Return(true);

        _orderProcessor = new OrderProcessor(_mockClient, stubSpec);
    }

    protected override void Because()
    {
        _orderProcessor.PlaceOrder(_order);
    }

    [Test]
    public void Should_send_the_email_to_the_sales_guy()
    {
        _mockClient.Expect(x => x.Send(Arg<MailMessage>.Matches(msg => msg.To[0].Address == "salesdude@email.com")));
    }
}

That's a lot smaller! I clearly separate the Arrange (EstablishContext) from Act (Because) and the Assert, which is my actual observation. To stub the indirect input of the IOrderSpec, I can use the Stub extension method provided by Rhino Mocks 3.5.

But the best aspect of the new AAA syntax is that I can finally create readable specifications that use Rhino Mocks. Before, all of the noise of the Record/Replay and the MockRepository obscured the intention of the specification. I had to rely on test spies earlier to capture the output of the ISmtpClient.Send call, as the old constraint model would have mixed in the Assert with the Arrange (i.e., I would have to put the constraints in the record section. Not pretty.)

I've found that without the distractions of the old Rhino Mocks syntax, I can better focus on the behavior I'm trying to observe. It's now just one line to set up indirect inputs with stubs, and one line to verify interactions and indirect outputs.