Pace yourself

MvcToFubu - Transition your website from ASP.NET MVC to FubuMVC Part 1

2011-06-11

So you are thinking about using FubuMVC but you are having a hard time justifying to your coworkers or boss or even yourself the level of effort it would take to switch your existing ASP.NET MVC website over to a new web framework. You wish there was a way you could get into FubuMVC with the ability to slowly transition your site piece by piece and not all at once.

Or perhaps you are content using ASP.NET MVC for your project, but are interested in taking advantage of FubuMVC behavior chains to deal with common before and after request responsibilities.

It is the goal of the MvcToFubu project to help enable these two scenarios and encourage everyone to try FubuMVC out for themselves. By smoothing the transition away from ASP.NET MVC towards FubuMVC hopefully anyone who was sitting on the fence about giving Fubu a try will be able to check it out with less risk.

Clone from the github repository here:

https://github.com/bobpace/MvcToFubu

Make sure you have ASP.NET MVC 3 installed to view the sample projects.

Also, when you build for the first time it will have build errors before it pulls down the nuget package references, just build again and you will be good.

NOTE: Since FubuMVC runs on StructureMap, if your website uses a different container you will need to use StructureMap in order to take advantage of any of the techniques shown by this MvcToFubu project.

Part 1

Enable FubuMVC Behavior chains in your ASP.NET MVC web application.

I will assume some familiarity with behavior chains already but you can read more about them here:

http://guides.fubumvc.com/getting_started.html#behaviorsand-behavior-chains

After pulling down the MvcToFubu source and building, set the MVCWithFubuBehaviors project as the startup project and run it.

After arriving at the example view you can look in your Visual Studio Output window and you should see a line containing:

Executing example behavior...

This ExampleBehavior is set up in the ExamplePolicy class to be applied to all actions on the ExampleController.

I want to point out a few of the important pieces that help make this work.

MvcToFubuApplication

Creates and populates a BehaviorChainIdLookup that matches ASP.NET MVC controller action invocations to their corresponding behavior chain. This lookup is used in the MvcToFubuControllerActionInvoker so that when the normal ASP.NET MVC pipeline invokes a controller action it can defer the execution of the ActionResult until the MvcActionCall node in your behavior chain. Behaviors for OutputNodes, or nodes that come after the ActionCall are not supported since after running the MvcActionCall the default ASP.NET MVC rendering pipeline takes over.

MvcToFubuRegistry

Ignores methods that come from base ASP.NET MVC Controller class, since controllers will be inheriting it.

Replaces the default ActionCall in the behavior chain with our MvcActionCall which will enable us to invoke the regular ASP.NET MVC pipeline for the controller action.

ControllerContextBehavior

A base class for behaviors for your convenience since much of what you may want to deal with will be contained on the ControllerContext.

Part 2 will go over the details of how to run FubuMVC right inside your existing ASP.NET MVC site, letting you transition your site slowly to FubuMVC while maintaining existing ASP.NET MVC site functionality.

Getting Started With Develop With Passion Specifications for Unit Testing

2011-06-05

One area I am seeking to improve myself in is better unit testing of the code that I write. After attending the develop with passion training course in Denver last month I saw an excellent approach to testing demonstrated by JP Boodhoo that I would like to share with anyone who is interested.

Develop with Passion specifications

Easy to use consistent approach to unit testing that gives you access to all the tools necessary and encourages design choices in the tests themselves.

Prerequisites:

Have a copy of resharper (not absolutely necessary, but greatly enchances the experience of using these specifications)

Goal 1:

Be able to run develop with passion specifications from within Visual Studio.

Install machine.specifications for your version of Resharper so you can run these unit tests via Resharpers test menu. — optionally you can install for test driven .net if you prefer to use that.

Resources: readme @ https://github.com/agross/machine.specifications/

git clone git://github.com/agross/machine.specifications.git
cd machine.specifications

if using git bash or cygwin / can cmd into command prompt, otherwise just:

build.cmd

After build is complete, change directory to Build/Debug and run the appropriate .bat file to install for either resharper or test driven .net. I ran InstallResharperRunner.5.1 - VS2010.bat

Goal 2:

Import resharper live templates provided for develop with passion specifications.

Obtain the following template files:

Open resharper live templates menu (Resharper: Live Templates)

On the file templates tab select the User Templates node and then click the import icon and navigate to file_templates_developwithpassion_specifications_rhino_mocks.xml and click open.

Next, select and drag the ObservationsWithContract, ObservationsWithoutContract, and StaticObservations templates over to the right side window and drop them on the C# projects section. Now you will be able to create these when using resharpers alt + insert shortcut to add new files.

On the live templates tab, import both live template files into User Templates: C#

live_templates_developwithpassion_specifications.xml:

deps – for providing mocks that are automatically dependency injected to your sut
fake – for providing all other mocks

live_templates_machine_specifications.xml:

bddb – because block
bddc – establish block
tc – it block
sa – subject class
bddcu – cleanup

Making good use of these resharper templates greatly enhances the experience of using these specifications for consistent unit testing throughout projects.

Goal 3:

Change resharper formatting options for optimal test readability.

This step is optional but I find the improved readability is pretty nice.

Make the following changes to your resharper formatting options: (Resharper: Options)

Languages: C#: Formatting Style: Braces Layout

Anonymous method declaration: At next line (BSD style)
Array and object initializer: At next line (BSD style)

Languages: C#: Formatting Style: Other

Modifiers: Use explicit private modifier: Uncheck
Align Multiline Constructs: Expression: Uncheck
Other: Indent anonymous method body: Uncheck
Align Multiline Constructs: Array, object and collection initializer: Uncheck
Other: Indent array, object and collection initializers: Uncheck

Goal 4:

Create a test project to contain your develop with passion tests.

Suggested project name: ProjectName.Specs

Obtain NuGet Package Manager extension for Visual Studio 2010:

Add developwithpassion.specifications via NuGet package installation.

Right click References: Add Library Package Reference
Search for developwithpassion (all one word)
Install the developwithpassion package of your choice, I am using the rhino mocks one.

Use the resharper file templates available via ALT+INSERT to create new ObservationsWithContract, ObservationsWithoutContract, or StaticObservations.

Suggested test classes naming convention: SystemUnderTestSpecs

Goal 5:

Learn to use develop with passion specifications.

There is an execellent example project available to inspect and gain an understanding of how to make use of the features provided, pull it down with git and take a look through it.

https://github.com/developwithpassion/developwithpassion.specifications/

git clone git://github.com/developwithpassion/developwithpassion.specifications.git
cd developwithpassion.specifications
start solution.sln

Spend some time familiarizing yourself with the developwithpassion.specifications.examples project. These are excellent examples that demonstrate the various features available which should cover every scenario you will encounter while unit testing.

Well that should get you on your feet to evaluating this for yourself. I am pretty excited to be using it, I feel it will help to streamline much of the repetitive work involved with test setup that deterred me from bettering my testing techniques in the past.

Nothing But .NET Postmortem

2011-05-28

I just got back from attending the Nothin' but .NET developer training course in Denver, Colorado last week and wanted to pass on some of the take aways from it.

It was an awesome experience, JP had a great setup for teaching our group of 15 people. He had us fork one of his repositories on github and used various scripts to automate the process of pulling change sets from students back into the master branch as well as allowing students to catch back up to the latest version of what was going on.

It was seriously the best way to run an all day workshop that I have ever seen implemented. I think back to various code camps or competitions where this kind of a setup would have trivialized the difficulty in enabling efficient collaboration between a group of people.

After presenting a concept he would check in some code, have us pull it down and then we would go to work on trying to solve the problem for ourselves. As soon as someone had something finished they would push their changes and the class would stop their work on the exercise and watch as JP looked over the changes and then refactored the code using a true object oriented approach where each concern was broken down into its individual parts and tackled gracefully with the appropriate design pattern that was best suited to the job.

Oh, and he did it at like 100 miles per hour. I thought I was fast, but now I have a new definition for the word.

Watching JP’s speed and sheer amount of automation while he coded in front of an audience was a nice glimpse into the true potential of what we can all become if we are willing to invest the time to hone our craft.

Overall this was a great course which has inspired me to better myself as a developer.

Here’s my list of goals after attending the course:

Craft your work bench!
Learn a shell like the back of your hand
Make the business concerns you deal with first class citizens in your code base.
Tests to drive the design.
Don’t just apply refactorings to your code base, but to your programming experience in general.

Managing client side javascript with require.js

2011-05-14

Its been a long while since my last post, which is mostly due to the amount of work projects going on.

Of the many interesting things I would like to blog about the first one that comes to mind is what we’ve been doing with our client side javascript lately. Javascript can feel like the wild wild west sometimes with the way that it gets haphazardly strewn about littering the global namespace with who knows what variables and generally just being a giant mess that gets harder to maintain over time.

Most people are at least using a modular approach with something along the lines of:

(function() {
 //export something useful to global namespace
})()

But what do you do when you start to get a lot of these, and they start to interact with each other in ways such that certain modules are dependent on others being there or having to juggle whether or not you’ve already loaded it so as not to have to load it again, etc…

Well gone are those days, enter Require.js and a civilized approach to organizing your client side javascript into modules that can be easily managed and comes with the perk of an optimization tool which enables you to combine all dependencies for a page into practically one single minified/obfuscated file to get screaming fast load times with far fewer requests that need to be made to bring down your content.

So not only am I going to describe a possible approach to getting set up, but I’ve already got it running on this page right now so feel free to open your web development tool of choice be it FireBug or Chromes Javascript console and take a look for yourself. It goes without saying that if you are using Internet Explorer you should seriously reconsider your web browsing habits.

So first things first, the idea of using require is that you include a snippet such as this up in your head tag.

<script type="text/javascript">
  var require = {
    priority: ['jquery-1.6.min', 'underscore']
  };
</script>
<script type="text/javascript" data-main="/js/main" src="/js/require.js"></script>

This is but one of many possible ways to set this up, but it’s my current preferred approach. Dependencies that you know you are going to want before any of your modules even try to load can be specifed in the priority array. The data-main attribute lets require know which javascript file you want to be the main entry point aka the require bootstrapper as I like to call it. Note that you leave off the .js extension.

main.js

require(['util/module-activator', 'util/analytics'],
  function(moduleActivator, analytics){
    analytics.track('UA-17910584-1');
    moduleActivator.execute();
  });

The example above takes in an array of dependencies as a first parameter, and a function which will make use of those dependencies as its second parameter.

Not every dependency needs to be included as a parameter to the function. If all you need to do is just execute some arbitrary javascript or link to a .js file that is not defined in the require syntax then feel free to leave it out of the parameters to your function however anything like that will need to be at the end of your dependency array as the arguments to the function are passed in the order they were specified.

The two modules you see me using here are great examples of some of the things you can get done using require. Lets take a look at them.

util/analytics

define(function(){
    var exports = {
      track: function(accountId) {
        var _gaq = window._gaq = _gaq || [],
            ga = document.createElement('script'),
            s = document.getElementsByTagName('script')[0];

        _gaq.push(['_setAccount', accountId]);
        _gaq.push(['_trackPageview']);

        ga.type = 'text/javascript';
        ga.async = true;
        ga.src = ('https:' == document.location.protocol ?
          'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';

        s.parentNode.insertBefore(ga, s);
      }
    };

  return exports;
});

You may recognize this as the google analytics script, but rewritten according to my interpretation of current best javascript practices gleaned from Javascript: The Good Parts which if you haven’t read yet I would recommend that you do.

util/module-activator

define(function(){
  var module = {};

  function loadModule(domElement) {
    var element = $(domElement),
        moduleName = element.data("module");

    require([moduleName], function(module) {
      module.init(element);
    });
  };

  module.execute = function(element) {
    var element = element || $("html"),
        dataModules = $("[data-module]", element);

    _.each(dataModules, loadModule);
  };

  return module;
});

The module activators power is second only to its mystery. It scrapes the page for any elements with a data-module attribute on them and issues a require call to load a module by the name of the value provided and then invokes an init function on the module passing it the element as a jquery wrapped set. The element can then be used to scope selectors against inside your module using jquery or put to any purpose you can think of.

Step 1: Add a data-module attribute to an element on page:

<div id="color-changer" data-module="color-changer"></div>

Step 2: Enjoy your functionality. Click the div below and watch it change colors.

The implementation of color-changer looks like this:

define(function() {
  var exports = {},
      colors = ['red', 'blue', 'yellow', 'green', 'orange', 'purple'],
      getRandomColor = function() {
        var max = colors.length,
            index = Math.floor(Math.random()*max+1);
        return colors[index];
      };

  exports.init = function(element) {
    var previousColor;
    element.click(function() {
      var color;
      while (!color || color === previousColor) {
        color = getRandomColor();
      }
      element.css('background', color);
      previousColor = color;
    });
  };

  return exports;
});

To demonstrate this modules reusability look back up at Step 2 and try clicking on the word “div”. The markup for it looks like this:

<span data-module="color-changer">div</span>

It will also change colors, and if you notice the two different color changers keep their own state of previous color to ensure that the next random color selected is not the same as the one before.

I hope this shows you some of the potential an approach like this can have and gets you excited about using require.js for yourself.

The Enumerang: A CQRS helper with potential other uses

2010-10-21

To give a little bit of background we have a shopping cart we are developing that performs adds or removes via ajax posts. As all operations are asynchronous when we fire off a command to add/remove an item and then immediately refresh the view of the cart it will not yet contain the newly added item or in the case of remove it will still contain the removed item. Our goal was to make it as smooth an operation as possible, without waiting for a response back to confirm that the operation had finished before refreshing the view.

So I thought if we could make something that could temporarily alter an IEnumerable to make it seem as if a particular operation had already taken place then the resulting view would look correct, and then later when the view is refreshed again if the item that the pending operation was standing in for was actually there (or not there if it was a remove) then that pending operations purpose will have been fulfilled and it will drop out of the list of known pending operations.

It worked out for my needs pretty nicely so I went ahead and put it up on GitHub if anyone is interested in checking it out. I’ll go over it a bit and explain what the thought process was behind it and show some potential usages.

The Enumerang holds onto a list of PendingOperations, but it does not actually contain the source collection itself. You pass the sourceCollection through its AlterCollection method to get the end effect of what each pending operation would have done to the source collection.

public class Enumerang<T>
{
    public Enumerang()
    {
        PendingOperations = new List<IPendingOperation<T>>();
    }

    public IEnumerable<T> AlterCollection(IEnumerable<T> sourceCollection)
    {
        var result = PendingOperations.Aggregate(
            sourceCollection, (current, operation) => operation.Alter(current))
            .ToList();
        PendingOperations = PendingOperations.Where(x => !x.PurposeFulfilled).ToList();
        return result;
    }

    public IList<IPendingOperation<T>> PendingOperations { get; private set; }
}

IPendingOperations can alter an IEnumerable in any way you choose, and just need to know when their purpose has been fulfilled so they can drop out of the list of pending operations.

public interface IPendingOperation<T>
{
    bool PurposeFulfilled { get; }
    IEnumerable<T> Alter(IEnumerable<T> source);
}

I have provided two IPendingOperation implementations, the AddPendingOperation and the RemovePendingOperation.

The AddPendingOperation checks each item in the source collection as it yield returns them and if nothing in the source collection matches the MatchTarget condition then it will additionally yield return the result of the ProvideItem func that you provide. If the item is already in the source collection then the AddPendingOperation’s purpose is fulfilled and it is removed from the list of PendingOperations.

public class AddPendingOperation<T> : IPendingOperation<T>
{
    public Func<T, bool> MatchTarget { get; set; }
    public bool PurposeFulfilled { get; set; }
    public Func<T> ProvideItem { get; set; }

    public IEnumerable<T> Alter(IEnumerable<T> source)
    {
        foreach (var item in source)
        {
            if (!PurposeFulfilled && MatchTarget(item))
            {
                PurposeFulfilled = true;
            }
            yield return item;
        }

        if (!PurposeFulfilled)
        {
            yield return ProvideItem();
        }
    }
}

The RemovePendingOperation returns all items from the source collection as long as they don’t match the MatchTarget func that you provide for it. If it does match, then that item is excluded from the list. If your RemovePendingOperation fails to match an item in the source collection then its purpose is fulfilled and it drops out of the list of PendingOperations.

public class RemovePendingOperation<T> : IPendingOperation<T>
{
    public Func<T, bool> MatchTarget { get; set; }
    public bool PurposeFulfilled { get; set; }
    private bool _wasUsed;

    public IEnumerable<T> Alter(IEnumerable<T> source)
    {
        _wasUsed = false;
        Func<T, bool> noPendingRemoveOperationsForItem = x =>
            {
                var result = MatchTarget(x);
                if (result)
                {
                    _wasUsed = true;
                }
                return !result;
            };

        foreach (var item in source.Where(noPendingRemoveOperationsForItem))
        {
            yield return item;
        }

        PurposeFulfilled = !_wasUsed;
    }
}

The way we are using this right now is to store one instance of an Enumerang which we call the CartActivityMonitor in the session and any time we send off a command to add or remove an item we also add a PendingOperation to it like this:

CartActivityMonitor.PendingOperations.Add(new AddPendingOperation<ShoppingCartItem>
{
    MatchTarget = x => x.Id == 1,
    ProvideItem = () => new ShoppingCartItem { Id = 1},
});

Or in the case of a remove:

CartActivityMonitor.PendingOperations.Add(new RemovePendingOperation<ShoppingCartItem>
{
    MatchTarget = x => x.Id == 1,
});

For simplicity this example uses only single int id to match on, but if your needs are more complex you can provide any Func<T, bool> to consider what ‘matching’ means to you.

We can then immediately refresh our view, and even if it does not yet reflect the changes we have made from our adds/removes if we pass our IEnumerable through the AlterCollection method on the CartActivityMonitor it will project them as if they had already occurred.

List<ShoppingCartItem> shoppingCartItems = //get shopping cart items
var shoppingCartItemsToDisplay = CartActivityMonitor.AlterCollection(shoppingCartItems);

Note: AlterCollection does not modify the underlying source collection, so you need to use the IEnumerable returned from it, which in the example above would be shoppingCartItemsToDisplay instead of shoppingCartItems.

Refactoring object comparison code in C#

2010-09-20

I’ve come across many occasions where we have a giant statement that compares a number of properties on two objects of the same type to determine whether to perform some logic or other.

You know, the kind of code like this:

if (object1.Property1 == object2.Property1 &&
        object1.Property2 == object2.Property2 &&
        object1.Property3 == object2.Property3)
{
}

Whether its found in an overriden Equals method, an IComparer implementation, or just exists in your code somewhere else (which it tends to) this code has the potential to get pretty large once you are comparing a large number of properties.

The first place I usually start when attempting to refactor something is to try to sort out what is different and what is the same. Then we can usually identify a pattern to the similar parts and extract them out which leaves us with only the truly different pieces left.

Lets use the following class for our example:

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public DateTime DateOfBirth { get; set; }
}

And update our example to make use of it:

if (person1.FirstName == person2.FirstName &&
        person1.LastName == person2.LastName &&
        person1.DateOfBirth.Equals(person2.DateOfBirth))
{
    //logic of some kind
}

If we take inventory of what we are working with at the moment, we could break it down like this:

We have 3 different properties

We have 2 instances of the same class

We compare each of our properties on the 2 instances of the same class in the same way

So if we list the differences only it would look like this:

FirstName

LastName

DateOfBirth

Now if we could represent that in code in as close to that form as possible that would be a lot of noise taken out of our comparison code.

Using a list of Func<Person, object> we can do something like this:

x => x.FirstName
x => x.LastName
x => x.DateOfBirth

This lets us describe the properties, regardless of which of the two instances they belong to.

Now we can extract out the code to compare the values of each of the properties we care about on the two different instances.

We can use the All extension from System.Linq to make sure all of the comparisons share similar comparison code. We would like whatever value comes off the first instance to equal the value that comes off the second instance.

Person firstInstance = new Person();
Person secondInstance = new Person();

var comparisons = new List<Func<Person, object>>
{
    x => x.FirstName,
    x => x.LastName,
    x => x.DateOfBirth,
}

var result = comparisons.All(x => x(firstInstance) == x(secondInstance));

However the == is not sufficient in all cases, as is the case with DateTime

var firstDateTime = new DateTime(2010, 1, 1);
var secondDateTime = new DateTime(2010, 1, 1);

firstDateTime == secondDateTime will be false

firstDateTime.Equals(secondDateTime) is true

So we can change it to be this:

var result = comparisons.All(x => x(firstInstance).Equals(x(secondInstance)));

But then if FirstName is null on the first instance, it will throw a null reference exception when attempting to call the Equals method on it, so to prevent that we can do this:

comparisons.All(x =>
    {
        var firstValue = x(instance);
        var secondValue = x(otherInstance);
        return firstValue == null && secondValue == null ||
               firstValue != null && secondValue != null && firstValue.Equals(secondValue);
    });

That way if our comparison func returns null from both instances that will count as true, if only one produces null it will be false, and if both produce non null values we will use the Equals implementation to determine equality.

Then we can put it behind a helper extension method for reuse:

public static bool Compare<T>(this T instance, T otherInstance, params Func<T, object>[] equalityMembers) where T : class
{
    var comparisons = new List<Func<T, object>>(equalityMembers);
    return comparisons.All(x =>
        {
            var firstValue = x(instance);
            var secondValue = x(otherInstance);
            return firstValue == null && secondValue == null ||
                   firstValue != null && secondValue != null && firstValue.Equals(secondValue);
        });
}

Edit 9/28/2010 As Ryan pointed out we can make it even better by using the static object.Equals method for the comparison:

public static bool Compare<T>(this T instance, T otherInstance, params Func<T, object>[] equalityMembers) where T : class
{
    var comparisons = new List<Func<T, object>>(equalityMembers);
    return comparisons.All(x =>
        {
            var firstValue = x(instance);
            var secondValue = x(otherInstance);
            return object.Equals(firstValue, secondValue);
        });
}

And now our original example can make use it:

if (person1.Compare(person2,
            x => x.FirstName,
            x => x.LastName,
            x => x.DateOfBirth))
{
}

If our comparison needs grow to include more properties its easy to add a new member to the list and I think it ends up being overall less code to write and maintain.

This could be extended further as needed, however the point of most value I would like to reinforce is the refactoring technique used to enable us to describe the differences in the shortest most concise way possible and let any similarities take advantage of reusing the same code.

Breaking down C# Flags enums into individual values for comparison

2010-09-13

In dealing with C# flags enums I have rarely needed to do anything too fancy to get the job done, however I recently came across a scenario that required a bit of extra work to produce the desired result and so I thought I would share it with everyone.

Consider the following simple enum:

[Flags]
public enum MyColor
{
    None = 0,
    Red = 1,
    Green = 2,
    Blue = 4,
    White = 8,
    Magenta = 16,
}

Now lets say you have an instance of this enum with any number of the flags turned on.

How would you ouput a list of the individual flags turned on?

If you had two instances of this enum, each with a different set of flags turned on, how would you compare the two and ouput a list of the differences?

As an extra catch, lets say the enum has a few combined values and it looks like this instead:

[Flags]
public enum MyColor
{
    None = 0,
    Red = 1,
    RedAndGreen = Red | Green,
    Green = 2,
    Blue = 4,
    White = 8,
    WhiteAndGreen = White | Green,
    Magenta = 16,
}

But for your comparisons you only care about pure values of the enum, and the combined ones should be broken down into the pure values that make them up.

When I first started thinking about how to solve this problem I threw together some quick unit tests to poke around at a few ideas.

I observed the following ToString() results from different instances of the MyColor enum:

MyColor.RedAndGreen

RedAndGreen

MyColor.Blue

Blue

MyColor.Red | MyColor.Green | MyColor.Blue

RedAndGreen, Blue

MyColor.Blue | MyColor.Green

Green, Blue

Which sent me down this path:

public static IEnumerable<T> GetIndividualValues<T>(this Enum myEnum) where T : struct
{
    return myEnum
        .ToString()
        .Split(new[] { ',' })
        .Select(x => (T)Enum.Parse(typeof(T), x.Trim()))
        .ToUniqueFlagEnumValues();
}

Relying on the ToString() emitting valid values of the enum, parsing them back into values, and then I was left with the task of determining which values were pure and which were combined. Which led to the following extension methods:

public static bool IsPowerOfTwo(this int value)
{
    return (value & (value - 1)) == 0;
}

public static IEnumerable<T> ToUniqueFlagEnumValues<T>(this IEnumerable<T> flagsEnumValues) where T : struct
{
    foreach (T item in flagsEnumValues)
    {
        int intValue = Convert.ToInt32(item);
        //if our int is a power of two, its a unique value of the flags enum
        if (intValue.IsPowerOfTwo())
        {
            yield return item;
        }
        //otherwise its a combination of several unique values and we need to break it down further
        else
        {
            //the enum value output as binary string representation
            string fullBinaryString = Convert.ToString(intValue, 2);
            //an empty template with all 0's that is the length of our binary string
            char[] individualBitTemplate = new string('0', fullBinaryString.Length).ToCharArray();

            IEnumerable<T> individualFlagsEnumValues = fullBinaryString
                .Select((character, index) =>
                    {
                        //project each individual bit into its own binary string with 0's in every position
                        //other than the index of the individual bit
                        //Example: binary string 1111
                        //produces 4 individual binary strings
                        //0001
                        //0010
                        //0100
                        //1000
                        char[] template = (char[])individualBitTemplate.Clone();
                        template[index] = character;
                        return new string(template);
                    })
                .Where(individualBitBinaryString =>
                    {
                        //filter the results to exclude any binary strings that are all 0's
                        return !individualBitBinaryString.All(character => character == '0');
                    })
                .Select(individualBitBinaryString =>
                    {
                        //cast the individual binary strings back to their int value, and then into the enum value
                        int intValueOfIndividualBit = Convert.ToInt32(individualBitBinaryString, 2);
                        return (T)Enum.ToObject(typeof (T), intValueOfIndividualBit);
                    });

            foreach (T value in individualFlagsEnumValues)
            {
                yield return value;
            }
        }
    }
}

So if it was a pure value (aka if it was a power of 2) then I yield return the item and move on. If it is not a pure value, then I use the following strategy to break it down into the individual pure values that it contains.

1) Convert the numeric value to a binary string

2) Break the binary string down further into one binary string per bit turned on.

If our value is 1111 Then we produce the following 4 binary strings: 0001 0010 0100 1000

3) Eliminate empty entries

Since not every flag will be on in sequential order we will sometimes be left with empty binary strings, so I filter them out.

4) Cast the resulting binary strings back to a numeric value and then cast them back into the enum.

5) Yield return each of these results

So now that we are able to ouput a list of unique values, we can accomplish the task of comparing two instances and outputting the differences with the following:

public class FlagsEnumDifference<T>
{
    private List<T> _added;
    private List<T> _removed;

    public FlagsEnumDifference(IEnumerable<T> added, IEnumerable<T> removed)
    {
        Added = new List<T>(added);
        Removed = new List<T>(removed);
    }

    public List<T> Added
    {
        get { return _added; }
        private set { _added = value; }
    }

    public List<T> Removed
    {
        get { return _removed; }
        private set { _removed = value; }
    }

    public override string ToString()
    {
        return string.Format("Added: {0} - Removed: {1}", Added.ToCommaSeperatedList(), Removed.ToCommaSeperatedList());
    }
}

With a few more extension methods to help it out:

public static string ToCommaSeperatedList<T>(this IEnumerable<T> enumerable)
{
    StringBuilder stringBuilder = new StringBuilder();
    foreach (T item in enumerable)
    {
        stringBuilder.Append(item).Append(',');
    }
    //trim the last , off
    if (stringBuilder.Length > 0)
    {
        stringBuilder.Remove(stringBuilder.Length - 1, 1);
    }
    return stringBuilder.ToString();
}

public static FlagsEnumDifference<T> GetDifference<T>(this Enum source, Enum compare) where T : struct
{
    IEnumerable<T> sourceValues = source.GetIndividualValues<T>();
    IEnumerable<T> compareValues = compare.GetIndividualValues<T>();

    IEnumerable<T> added = compareValues.Where(value => !sourceValues.Contains(value));
    IEnumerable<T> removed = sourceValues.Where(value => !compareValues.Contains(value));
    return new FlagsEnumDifference<T>(added, removed);
}

The usage can be seen here:

var color1 = MyColor.Green | MyColor.Blue;
var color2 = MyColor.Blue | MyColor.Red;
var color3 = MyColor.RedAndGreen | MyColor.Magenta;

var result1 = color1.GetDifference<MyColor>(color2);

result1.ToString()

Added: Red – Removed: Green

var result2 = color1.GetDifference<MyColor>(color3);

result2.ToString()

Added: Red,Magenta – Removed: Blue

While writing this blog post it occurred to me that I should probably have just used an algorithm to break the numeric value of the enum down into unique powers of two rather than rely on the ToString() implementation and working backwards from there. However I still thought it would be useful to go over the thought process behind this solution.

Adding collection binding support to FubuMVC Part 2

2010-09-07

Continuing from the last post, my next question was how exactly did the current model binding implementation work in Fubu?

The first place I looked was at the OneInOneOutActionInvoker which is the IActionBehavior that represents a controller action that takes in one parameter and returns one result.

Inside the OneInOneOutActionInvoker, you can see the following:

private readonly IFubuRequest _request;
...

protected override DoNext performInvoke()
{
    var input = _request.Get<TInput>();
    TOutput output = _action(_controller, input);
    _request.Set(output);

    return DoNext.Continue;
}

Which shows us that the FubuRequest is responsbile for providing the input parameter to the action.

How does that work? If you look at the FubuRequest:

private readonly Cache<Type, BindResult> _values = new Cache<Type, BindResult>();

public FubuRequest(IRequestData data, IObjectResolver resolver)
{
    _values.OnMissing = (type => resolver.BindModel(type, data));
}

public T Get<T>() where T : class
{
    return _values[typeof (T)].Value as T;
}

We can see that the values are being provided via the OnMissing func which calls the ObjectResolvers BindModel method.

public virtual BindResult BindModel(Type type, IBindingContext context)
{
    IModelBinder binder = _binders.BinderFor(type);
    try
    {
        return new BindResult()
        {
            Value = binder.Bind(type, context),
            Problems = context.Problems
        };
    }
    catch (Exception e)
    {
        throw new FubuException(2201, e, "Fatal error while binding model of type {0}.  See inner exception", type.AssemblyQualifiedName);
    }
}

That _binders is the IModelBinderCache which at the moment has only one binder: the StandardModelBinder in it.

StandardModelBinder is the place where the actual instance of your model gets instanciated, and then each property gets bound one by one by looking to the IPropertyBinderCache to see which IPropertyBinder should step in to provide the value, as can be seen here:

public object Bind(Type type, IBindingContext context)
{
    object instance = Activator.CreateInstance(type);
    Bind(type, instance, context);

    return instance;
}

public void Bind(Type type, object instance, IBindingContext context)
{
    context.StartObject(instance);
    populate(type, context);
    context.FinishObject();
}

private void populate(Type type, IBindingContext context)
{
    _typeCache.ForEachProperty(type, prop =>
    {
        IPropertyBinder binder = _propertyBinders.BinderFor(prop);
        binder.Bind(prop, context);
    });
}

So then the PropertyBinderCache when asked to bind a certain property for the first time will check its own OnMissing function to attempt to look through the list of IPropertyBinders that have been supplied for one that matches the current PropertyInfo for the property being bound.

private readonly IList<IPropertyBinder> _binders = new List<IPropertyBinder>();
private readonly Cache<PropertyInfo, IPropertyBinder> _cache = new Cache<PropertyInfo, IPropertyBinder>();

public PropertyBinderCache(IEnumerable<IPropertyBinder> binders, IValueConverterRegistry converters, ICollectionTypeProvider collectionTypeProvider)
{
    _binders.AddRange(binders);
    _binders.Add(new ConversionPropertyBinder(converters));
    _binders.Add(new NestedObjectPropertyBinder());

    _cache.OnMissing = prop => _binders.FirstOrDefault(x => x.Matches(prop));
}

public IPropertyBinder BinderFor(PropertyInfo property)
{
    return _cache[property];
}

Each IPropertyBinder provides a Matches(PropertyInfo property) method to determine if the property should be bound by it.

ConversionPropertyBinder matches by checking the ValueConverterRegistry for an IConverterFamily that matches the PropertyInfo and if it finds one it uses it to perform a custom conversion.

NestedObjectPropertyBinder matches everything which is why it is listed last. It serves as the fallback case when none of the other IPropertyBinders match anything.

It calls context.BindChild inside its Bind method providing the propertys name to be used as a prefix to the request data and then creating a new BindingContext from that and attempts the process all over again using the ObjectResolver which calls the StandardModelBinder and then passes back through all the IPropertyBinders again.

public void BindChild(PropertyInfo property, Type childType, string prefix)
{
    var target = Object;
    if (_propertyStack.Any(p => p.PropertyType == childType))
    {
        _propertyStack.Push(property);
        throw new FubuException(2202, "Infinite recursion detected while binding child properties: {0} would try to resolve {1} again.", string.Join("=>", _propertyStack.Reverse().Select(p => "{1}.{0}".ToFormat(p.Name, p.ReflectedType.Name)).ToArray()), childType.Name);
    }
    _propertyStack.Push(property);

    var resolver = Service<IObjectResolver>();
    var context = prefixWith(prefix, _propertyStack.Reverse());

    try
    {
        var result = resolver.BindModel(childType, context);
        property.SetValue(target, result.Value, null);
    }
    catch (Exception e)
    {
        LogProblem(e);
    }

    _problems.AddRange(context._problems);

    _propertyStack.Pop();
}

private BindingContext prefixWith(string prefix, IEnumerable<PropertyInfo> properties)
{
    var prefixedData = new PrefixedRequestData(_requestData, prefix);
    var child = new BindingContext(prefixedData, _locator);
    properties.Each(p => child._propertyStack.Push(p));
    return child;
}

After seeing all of this I decided to try and fit in collection binding support by providing a new type of IPropertyBinder, the CollectionPropertyBinder, and put it in between the other two.

_binders.Add(new ConversionPropertyBinder(converters));
_binders.Add(new CollectionPropertyBinder(collectionTypeProvider));
_binders.Add(new NestedObjectPropertyBinder());

And have it match anything that looks like a collection:

public bool Matches(PropertyInfo property)
{
    var type = property.PropertyType;
    return type.IsGenericType &&
           type.GetInterfaces().Any(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(ICollection<>));
}

With the following Bind implementation:

public void Bind(PropertyInfo property, IBindingContext context)
{
    var type = property.PropertyType;
    var itemType = type.GetGenericArguments()[0];
    if (type.IsInterface)
    {
        type = _collectionTypeProvider.GetCollectionType(type, itemType);
    }

    object collection = Activator.CreateInstance(type);
    var collectionType = collection.GetType();

    Func<object, bool> addToCollection = obj =>
        {
            if (obj != null)
            {
                var addMethod = _addMethods[collectionType];
                addMethod.Invoke(collection, new[] { obj });
                return true;
            }
            return false;
        };

    //TODO: work in the IElementNamingConvention somehow to ensure that it still can deserialze when others provide
    //a different implementation

    var formatString = property.Name + "[{0}]";

    int index = 0;
    string prefix;
    do
    {
        prefix = formatString.ToFormat(index);
        index++;
    } while (addToCollection(context.BindCollectionItem(prefix, itemType)));

    property.SetValue(context.Object, collection, null);
}

If the PropertyInfo type is an interface we need to pick a concrete type to back it. I put this behind an ICollectionTypeProvider interface along with a DefaultCollectionProvider to hand out List<> for everything, but with the intent that someone can swap in their own if necessary.

Based on the concrete type chosen, we need to invoke its Add method which is backed by a cache to match each unique collection type to its Add MethodInfo.

We then greedily try to grab as many collection items as we can by calling into context.BindCollectionItem which I made following the example provided by the NestedObjectPropertyBinder and its usage of context.BindChild.

public object BindCollectionItem(string prefix, Type childType)
{
    var resolver = Service<IObjectResolver>();
    var context = prefixWith(prefix, _propertyStack.Reverse());

    //need to determine if the item is in there or not since we will be greedy
    //and try to get as many items for our list as possible
    if (_requestData.HasValueThatStartsWith(prefix))
    {
        var bindResult = resolver.BindModel(childType, context);
        return bindResult.Value;
    }
    return null;
}

So it also ties back into the existing model binding capabilities and correctly binds anything further along after the collection items are resolved.

Since I had no idea how many collection items would be there ahead of time I had to extend the RequestData to able to check for values that start with a value rather than knowing exactly what the value was.

The RequestData uses the AggregateDictionary to provide its values, which in turn relies on a set of Locators to check various places for values. I extended the Locator with an additional StartsWithChecker to determine if it had a value that started with a given key.

public class Locator
{
    public RequestDataSource Source { get; set; }
    public Func<string, object> Getter { get; set; }
    public Func<string, bool> StartsWithChecker { get; set; }

    public bool Locate(string key, Action<RequestDataSource, object> callback)
    {
        object value = Getter(key);
        if (value != null)
        {
            callback(Source, value);
            return true;
        }

        return false;
    }

    public bool StartsWith(string key)
    {
        return StartsWithChecker != null && StartsWithChecker(key);
    }
}

Added an overload:

public AggregateDictionary AddLocator(RequestDataSource source, Func<string, object> locator, Func<string, bool> startsWith)
{
    _locators.Add(new Locator
                  {
                      Getter = locator,
                      StartsWithChecker = startsWith,
                      Source = source
                  });

    return this;
}

And then changed out the configuration inside the AggregateDictionary for the Locator that represents the request to include the StartsWithChecker so I can greedibly grab for things until I determine that no more are available.

private void configureForRequest(HttpContextBase @base)
{
    HttpRequestBase request = @base.Request;

    AddLocator(RequestDataSource.Request,
               key => request[key],
               key => request.Form.AllKeys.Any(x => x.StartsWith(key)));
    AddLocator(RequestDataSource.File, key => request.Files[key]);
    AddLocator(RequestDataSource.Header, key => request.Headers[key]);
    AddLocator(RequestDataSource.RequestProperty, key => GetRequestProperty(request, key));
}

There are a few holes in the implementation still, the biggest being properly considering the IElementNamingConvention when checking for form values to try and bind from within the CollectionPropertyBinders Bind method.

I think what needs to happen is to reassamble an Accesor out of the current properety info and prefixs we know about and then run it through the IElementNamingConvention to produce the prefix name to check with rather than assuming it will always be the property.Name + “[{0}]”. I will attempt to come up with something to test this idea out.

Adding collection binding support to FubuMVC Part 1

2010-08-30

We have been considering the idea of using FubuMVC for an internally hosted site to hold a suite of tools available to administrators. One feature we knew for certain we would need that Fubu did not yet support was the ability to model bind collections since we were already using that feature heavily in ASP.NET MVC. So with this in mind I set out to try and come up with an implemenation that not only met our needs but that could possibly be contributed back and be useful to others as well.

This serves a dual purpose as part of my goal to get a new blog post out weekly and also to potentially prove useful as documentation to anyone who is curious about what changes were made and the thought process behind them.

To give a little bit of background, we had already started using Fubu Html Conventions in our ASP.NET MVC project using ryanohs approach from his Fubu-HtmlTags-For-ASP.NET.MVC Git hub project.

We had also swapped out the default IElementNamingConvention:

public class DefaultElementNamingConvention : IElementNamingConvention
{
    public string GetName(Type modelType, Accessor accessor)
    {
        return accessor.Name;
    }
}

With this one to produce a more familiar naming convention for what we were using to dealing with in ASP.NET MVC:

public class PropertyNamesElementNamingConvention : IElementNamingConvention
{
    public string GetName(Type modelType, Accessor accessor)
    {
        return accessor.PropertyNames.Join(".");
    }
}

My goal starting out was just to get the existing ASP.NET MVC collection model binding to work with the Fubu Html Conventions Input/Label/Display for stuff.

I wanted to be able to do something like this:

Html.InputFor(x => x.CollectionOfSomeKind[0].PropertyName)

So I started digging into what happens inside the InputFor call.

The TagGenerator takes an Expression you provide it

public HtmlTag InputFor(Expression<Func<T, object>> expression)
{
    return buildTag(expression, _profile.Editor);
}

Builds an ElementRequest from it:

private HtmlTag buildTag(Expression<Func<T, object>> expression, TagFactory factory)
{
    ElementRequest request = GetRequest(expression);

    return factory.Build(request);
}

By first turning it into an Accessor:

public ElementRequest GetRequest(Expression<Func<T, object>> expression)
{
    Accessor accessor = expression.ToAccessor();
    return GetRequest(accessor);
}

And invoking the IElementNamingConvention implementation to provide the ElementId:

public ElementRequest GetRequest(Accessor accessor)
{
    var request = new ElementRequest(_model, accessor, _services, _stringifier);
    determineElementName(request);
    return request;
}

private void determineElementName(ElementRequest request)
{
    // TODO -- this is a klooge because of the tag wrapping around partials
    if (request.Accessor == null) return;

    var prefix = ElementPrefix ?? string.Empty;
    request.ElementId = prefix + _namingConvention.GetName(typeof(T), request.Accessor);
}

And then over in DefaultHtmlConventions you’ll find this:

Editors.Always.Modify(AddElementName);

And the AddElementName implementation here:

public static void AddElementName(ElementRequest request, HtmlTag tag)
{
    if (tag.IsInputElement())
    {
        tag.Attr("name", request.ElementId);
    }
}

So we can see how the ElementId ends up on the input that gets generated.

Which left me with a few questions to explore. What is that Accessor? How is it created? It seems there are two kinds of them, a PropertyChain and a SingleProperty. What was the difference?

So continuing onward into the creation of that Accessor inside the ReflectionHelper class:

public static Accessor ToAccessor<T>(this Expression<Func<T, object>> expression)
{
    return ReflectionHelper.GetAccessor(expression);
}

public static Accessor GetAccessor<TModel>(Expression<Func<TModel, object>> expression)
{
    MemberExpression memberExpression = getMemberExpression(expression);

    return GetAccessor(memberExpression);
}

public static Accessor GetAccessor(MemberExpression memberExpression)
{
    var list = new List<PropertyInfo>();

    while (memberExpression != null)
    {
        list.Add((PropertyInfo) memberExpression.Member);
        memberExpression = memberExpression.Expression as MemberExpression;
    }

    if (list.Count == 1)
    {
        return new SingleProperty(list[0]);
    }

    list.Reverse();
    return new PropertyChain(list.ToArray());
}

This was where I could see that the expression was being turned into an Accessor, either one SingleProperty or a PropertyChain of many SingleProperties.

This is the first place I found where I thought I might actually change something to move a step in the direction I wanted to take.

I knew I could get the collection binding to work if I could just get the names on the form inputs to align with the current expectation of how to bind a collection. So I tried something like this on my page:

<%= Html.InputFor(x => x.Collection[0].PropertyName) %>

And then proceeded to debug through the GetAccessor implementation to see what I was working with and how I might go about changing it.

When it got to the [0] part of the expression the line

memberExpression = memberExpression.Expression as MemberExpression;

evaluated to null and it was unable to proceed. But I could see memberExpression.Expression was actually a MethodCallExpression represeting the get call on the collection with the index to get as the method call expressions first argument. This looked like it would work out for me so I decided to go with it.

My next step was to extend the PropertyChain to be able to handle more than just PropertyInfo. I made the following interface:

public interface IValueGetter
{
    object GetValue(object target);
    string Name { get; }
    Type DeclaringType { get; }
}

And then made two implementations. PropertyValueGetter to represent the PropertyInfo that was there before:

public class PropertyValueGetter : IValueGetter
{
    private readonly PropertyInfo _propertyInfo;

    public PropertyValueGetter(PropertyInfo propertyInfo)
    {
        _propertyInfo = propertyInfo;
    }

    public PropertyInfo PropertyInfo { get { return _propertyInfo; } }

    public object GetValue(object target)
    {
        return _propertyInfo.GetValue(target, null);
    }

    public string Name
    {
        get { return _propertyInfo.Name; }
    }

    public Type DeclaringType
    {
        get { return _propertyInfo.DeclaringType; }
    }

    public bool Equals(PropertyValueGetter other)
    {
        if (ReferenceEquals(null, other)) return false;
        if (ReferenceEquals(this, other)) return true;

        return _propertyInfo.Equals(other._propertyInfo);
    }

    public override bool Equals(object obj)
    {
        if (ReferenceEquals(null, obj)) return false;
        if (ReferenceEquals(this, obj)) return true;
        if (obj.GetType() != typeof(PropertyValueGetter)) return false;
        return Equals((PropertyValueGetter)obj);
    }

    public override int GetHashCode()
    {
        return (_propertyInfo != null ? _propertyInfo.GetHashCode() : 0);
    }
}

And MethodValueGetter to represent the MethodCallExpressions that would be the collection indexers:

public class MethodValueGetter : IValueGetter
{
    private readonly MethodInfo _methodInfo;
    private readonly object _firstArgument;

    public MethodValueGetter(MethodInfo methodInfo, object firstArgument)
    {
        _methodInfo = methodInfo;
        _firstArgument = firstArgument;
    }

    public object GetValue(object target)
    {
        return _methodInfo.Invoke(target, new[] { _firstArgument });
    }

    public string Name
    {
        get { return "[{0}]".ToFormat(_firstArgument); }
    }

    public Type DeclaringType
    {
        get { return _methodInfo.DeclaringType; }
    }

    public bool Equals(MethodValueGetter other)
    {
        if (ReferenceEquals(null, other)) return false;
        if (ReferenceEquals(this, other)) return true;

        return _methodInfo.Equals(other._methodInfo) && _firstArgument == other._firstArgument;
    }

    public override bool Equals(object obj)
    {
        if (ReferenceEquals(null, obj)) return false;
        if (ReferenceEquals(this, obj)) return true;
        if (obj.GetType() != typeof(MethodValueGetter)) return false;
        return Equals((MethodValueGetter)obj);
    }

    public override int GetHashCode()
    {
        unchecked
        {
            return ((_methodInfo != null ? _methodInfo.GetHashCode() : 0) * 397) ^ (_firstArgument != null ? _firstArgument.GetHashCode() : 0);
        }
    }
}

I then changed out the _chain field inside the PropertyChain class to hold an array of these IValueGetter types so we could have a mixture of properties and collection indexers instead of just PropertyInfos.

Then I altered the ReflectionHelpers GetAccessor implementation to treat MethodCallExpressions as those MethodValueGetters and the regular MemberExpressions as PropertyValueGetters.

public static Accessor GetAccessor(MemberExpression memberExpression)
{
    var list = new List<IValueGetter>();

    BuildValueGetters(memberExpression, list);

    if (list.Count == 1)
    {
        var propertyValueGetter = list[0] as PropertyValueGetter;
        return propertyValueGetter != null ? new SingleProperty(propertyValueGetter.PropertyInfo) : null;
    }

    list.Reverse();
    return new PropertyChain(list.ToArray());
}

private static void BuildValueGetters(Expression expression, IList<IValueGetter> list)
{
    var memberExpression = expression as MemberExpression;
    if (memberExpression != null)
    {
        var propertyInfo = (PropertyInfo)memberExpression.Member;
        list.Add(new PropertyValueGetter(propertyInfo));
        if (memberExpression.Expression != null)
        {
            BuildValueGetters(memberExpression.Expression, list);
        }
    }

    //deals with collection indexers, list[0] will be get(0) method call expression 
    var methodCallExpression = expression as MethodCallExpression;
    if (methodCallExpression != null)
    {
        var methodInfo = methodCallExpression.Method;
        //only supporting constant expression as means of providing index
        var firstArgumentExpression = methodCallExpression.Arguments.First() as ConstantExpression;
        if (firstArgumentExpression != null)
        {
            var value = firstArgumentExpression.Value;
            var methodValueGetter = new MethodValueGetter(methodInfo, value);
            list.Add(methodValueGetter);
        }
        if (methodCallExpression.Object != null)
        {
            BuildValueGetters(methodCallExpression.Object, list);
        }
    }
}

So after all this, I went to try it out to see how things were working and I could see one definite problem. Since my IElementNamingConvention that I was using joined the PropertyNames together with a . like this:

return accessor.PropertyNames.Join(".");

It was resulting in the following output:

CollectionOfSomeKind.[0].PropertyName

Not exactly what I needed with that extra . in there, but close. So to prevent that from happening I threw in a collapse properties method on the PropertyChain to identify places where indexers had been put and collapse them back into the previous entry. This piece I am iffy on and would like to see something better as it will definitely not play nice when it comes time to work in other IElementNamingConvention implementations.

Here are the changes:

public string[] PropertyNames
{
    get
    {
        return collapseCollectionIndexes(_valueGetters.Select(x => x.Name).ToList()).ToArray();
    }
}

private static IEnumerable<string> collapseCollectionIndexes(IList<string> strings)
{
    //Find any occurrences of indexer and collapse them back into previous entry
    var list = new List<string>(strings);
    Func<string, bool> matches = x => x.StartsWith("[") && x.EndsWith("]");
    for (int i = 0; i < strings.Count(); i++)
    {
        var currentString = strings[i];
        if (matches(currentString))
        {
            var previousIndex = i - 1;
            //attempt to combine this with previous entry
            if (previousIndex > -1)
            {
                list[previousIndex] += currentString;
                list.RemoveAt(i);
            }
        }
    }
    return list;
}

I wonder if we need to put another member on the IElementNamingConvention interface that allows someone to specify custom behavior to help the PropertyChain produce its PropertyNames, and then this piece could go into the custom IElementNamingConvetion that we are using instead of being direcly on the PropertyChain like it is now.

This was all for the first part of the collection binding implementation, I will follow up with details on the second half to the implementation in the next blog post.

Using Sass via Compass in ASP.NET MVC

2010-08-23

Sass brings some much desired functionality to CSS. We recently adopted it into an ASP.NET MVC project that I am working on and I would like to share some of that experience with anyone that may be interested.

If you are unfamiliar with some of the reasons why you might want to use Sass, I would recommend reading up on their website and see for yourself. The focus of this post will be to go over what it takes to get it and work with it in a windows environment for an ASP.NET MVC project.

How to get started?

1) Get Ruby

If you want to use Sass then you need to get some form of Ruby up and running on your computer. Maybe that’s out of your comfort zone, maybe not, but rest assured that you don’t need to know too much about Ruby in order to make use of Sass.

If you are already familiar with how to do this, feel free to skip on to the next section.

Start by grabbing the latest installer that is available and run it with the ‘add Ruby executables to your Path’ option checked.

Open up a command prompt and type ruby -v and you should see something like this:

ruby 1.9.1p430 (2010-08-16 revision 28998) [i386-mingw32]

Nice and easy. Congratulations you have Ruby.

You can even use the .NET port of Ruby called Iron Ruby for this if you like, which is what we started out with but we soon encountered unacceptably slow compile times once we had written a fair number of sass files that shared a common base partial. Any change to that partial sass file would take a long time to recompile all the sass files that depended on it. In frustration we switched over to regular Ruby 1.9 and our performance issues went away and we were once again happy with the speedy compile times. For this reason I recommend using Ruby and not Iron Ruby.

2) Get Compass

Compass is our choice for how to get sass compiled into css in a windows environment, as mentioned in this stack overflow post.

I would recommend taking the time to watch the tutorial videos available on their site and read up more on everything else that Compass can do for you as well, but for now I’m just going to focus on a few things you can do from the command line to get started.

Installation is easy, just open a command prompt and type gem install compass and let it download and install.

Next you should open a command prompt in your ASP.NET MVC project folder and use compass create to generate a few things for you.

Your project structure likely does not follow the defaults that compass will provide for you, so you will need to inform it about a few important folder locations such as where to look for sass files, where to put the generated css and where your images and javascript folders are located. You can freely edit the config.rb file that will be created to change any of this after the fact but if you want to get it all set up in one shot they have various options available that you can pass to the compass create command when you run it such as --sass-dir and --css-dir. You can type compass create -h to view the complete set of options available. Feel free to use any combination of this you are comfortable with to get things set up for your particular project.

3) Start writing Sass

We are using the newer SCSS syntax that Sass provides so be aware that anytime I say sass the actual file extension will be .scss.

If you create a new .scss file in your sass folder, write a little bit of sass and then use compass compile from the command line you will likely see something like this:

Encoding::CompatibilityError on line ["786"] of c: incompatible encoding regexp
match (UTF-8 regexp with IBM437 string)
Run with --trace to see the full backtrace

Text files created via Visual Studio are given a Unicode (UTF-8 with signature) encoding, but if we look at the sample .scss files that are generated when you do a regular compass create their encoding is all Western European (Windows). If you change the encoding on your file you will be able to use compass compile and see it work properly.

You can change the encoding for your files in Visual Studio by opening the file in question and then going to File – Advanced Save Options and pick a different encoding from the drop down menu.

During development time you should make use of the compass -w feature from the command prompt as it will monitor your sass files for changes and when it detects that something has changed it will automatically compile them to css for you without you having to manually run the compass compile command. This is pretty nice as you can tweak your sass and just refresh the browser to see the effects immediately.

You can also automate the sass compliation by including a step in your project file to run compass compile for you when you build. We use this approach to handle sass compilation for our release builds.

To do this you need to unload your project, right click to edit the project file and then you can add something like this to the end of it:

<Target Name="AfterCompile" Condition=" '$(Configuration)' == 'Release' ">
    <Exec Command="compass compile" />
    <ItemGroup>
        <Content Include="Styles\*.css" />
    </ItemGroup>
</Target>

Where Styles would be the folder location that you told compass where to put your css files in after it compiles.

One problem you may run into if you use some kind of versioning system with your code is that merging files may change the encoding for you and insert a byte order mark into the beginning of your file. We encountered this with TFS when merging our sass files on check in. This prevents compass from being able to compile your files properly but luckily its not too difficult to get around with a fix.

The necessary steps are to remove the byte order mark and then prevent it from being inserted again by putting a place holder there.

Thanks and credit belong to Jason Staten for identifying the problem and coming up with this nice solution:

Get Rake if you don’t have it already with gem install rake

Create a Rakefile in your project folder, it can be named rakefile.rb or just rakefile with no extension if you prefer.

Put the following code into it:

task :bomfix do
    puts "Begin Bomfix"
    files = Dir["Scss/*.scss"]
    files.each do |file|
        if !File.writable?(file)
            puts "Please checkout #{file} for edit"
            next
        end
        puts "Fixing #{file}"
        content = IO.read(file)
        content.gsub!("\xEF\xBB\xBF", '')
        File.open(file, 'w') do |f|
            f.write("//Do Not Remove This Comment -- BOM Safety\n") unless (content =~ /Do Not Remove This Comment/)
            f.write(content)
        end
    end
end

Make sure you change the directory from the line files = Dir["Scss/*.scss"] to point where your actual sass files are located and then you can just type rake bomfix to correct your files.

Another step you can take to speed up your sass compile times is make use of the sass-cache by adding this to your config.rb, you can read documentation on this here.

sass_options = { :cache_location => ".\\tmp\\sass-cache" }

If you want the cached files to go elsewhere feel free to change the folder location. Also note that you will need to create these folders before they will be used. You can verify they are working by running compass compile and then go look in the sass-cache directory and you should see a bunch of new folders with GUIDS for names.

Well that’s it for now. I hope this helps give you ideas on how to integrate sass into a web project hosted in a windows environment.