Twitter Feed Popout byInfofru

Adventures in .NET Software Craftsmanship!

Bundling and Minimizing JavaScript and CSS with ASP.NET 4.5

I am in the process of getting back from the Build 2011 conference in Anaheim, California where  I got to see a ton of stuff related to Windows 8 development and designing Metro style application, and I shall blog a bit on the topic after I have had a good chance to digest all the information.  But right now, I just want to showcase one of the coolest new features of ASP.NET 4.5 “Bundling and Minimization of JavaScript and CSS”.


Now for those of you not familiar with the benefits of bundling and minimizing your JavaScript and CSS files, lets just say that reducing the number and raw size of web requests a browser needs to make to interact with your server is going to make your application faster.  A faster web application in most internet business scenarios equals more clients equals more money ( faster = more clients = more money).


So you might be asking yourself how complicated is it to setup Bundling and Minimizing of JavaScript and CSS in an ASP.NET 4.5 web application, and the short answer is, not hard at all.  You can setup bundling and minimizing in your Global.asax Application_Start to define what to bundle (See following snippet).


protected void Application_Start() {

private static void RegisterBundlers() {


    var cssBundle = new Bundle("~/Content/css", typeof(CssMinify));
    cssBundle.AddDirectory("~/Content", "*.css", false);


Finally, you can modify the reference to your scripts and styles in your layout or master page to target the proper resources.


<link href="Styles/css" rel="stylesheet" type="text/css" />
<script src="Scripts/js" type="text/javascript"></script>


For more information make sure to read the ASP.NET 4.5 Preview bits release notes (here).

Learning Razor–Writing an Inline Recursive HTML Helper

I have been using Spark ( as my default view engine for the past 5 or 6 months and I love everything about it.  I like its elegance, simplicity and I depend on some of its features to be efficient in doing most of my daily tasks.   That being said, there is a new kid on the block and his name is Razor.  Razor, will be an out of the box alternative for the ASP.NET WebForm’s view engine for ASP.NET MVC3 (Read Scott Guthrie’s blog on the topic here).   I don’t intend to write a full blown tutorial on Razor,  but as I learn the basics for this alternative view engine, I will try to write some “Learning Razor” posts that relate my experience in learning this new technology.


Writing an Inline Recursive Html Helper

The Spark view engine provides you with the ability to define inline macros that allow for recursive calls (Read Louis DeJardin blog on the topic here, and additional documentation here).  These macros are extremely useful for rendering a hierarchical structure such as the one in the following snippet.


  <li>Fuller, Andrew
      <li>Davolio, Nancy</li>
      <li>Leverling, Janet</li>
      <li>Peacock, Margaret</li>
      <li>Buchanan, Steven
          <li>Suyama, Michael</li>
          <li>King, Robert</li>
          <li>Dodsworth, Anne</li>
      <li>Callahan, Laura</li>


Now, the Razor view engine allows you to easily build a hierarchical structure by the use of inline HTML helpers that can be called recursively.  The following is a basic snippet of a “Hello World” inline HTML helper, and a call to trigger its functionality.



@helper HelloWorld(string name) {
    <h1>Hello World! @name</h1>


Finally, if we wanted to output the html from the first snippet using Razor we could write the following inline HTML helper.


@model IEnumerable<OrganizationNodeViewModel>
@using MVC3.Playground.ViewModels;
    View.Title = "OrganizationTree";
    Layout = "~/Views/Shared/_Layout.cshtml";


@OrgTree(Model, null);

@helper OrgTree(IEnumerable<OrganizationNodeViewModel> nodes, int? parentId) {
    if (nodes.Any(n => n.ParentId == parentId)) { 
        @foreach (var node in nodes.Where(n => n.ParentId == parentId)) {
                @OrgTree(nodes, node.Id)

MVC Model Validation–Refactor (Part Deux)

This post enhances the functionality of the code in the Blog titled “MVC2 Validation and Testing” at the following link.


A comment was made on one of my previous blogs requesting additional functionality for the extension method I wrote in April for testing controller action’s that rely on MVC2 Model Validation.  The request was simple, to be able to test class level validation attributes such as the ones found on the ChangePasswordModel in the default MVC2 project template.   Well, as requested!


public static class ControllerExtensions {

    public static ActionResult CallWithModelValidation<TController, TResult, TModel>(
            this TController controller, 
            Func<TController, TResult> action, 
            TModel model)
        where TController : Controller
        where TResult : ActionResult
        where TModel : class {

        var provider = new DataAnnotationsModelValidatorProvider();

        var metadata = new List<ModelMetadata>();

        foreach (ModelMetadata modelMetadata in metadata) {
            ApplyValidatorsFromMetadata(model, provider, modelMetadata, controller);
        return action(controller);

    private static ModelMetadata GetMetadataForClass<TModel>(TModel model) 
        where TModel : class {

        return ModelMetadataProviders
            .GetMetadataForType(() => model, typeof (TModel));

    private static IEnumerable<ModelMetadata> GetMetadataForProperties<TModel>(TModel model)
       where TModel : class {
        return ModelMetadataProviders
            .GetMetadataForProperties(model, typeof(TModel));

    private static void ApplyValidatorsFromMetadata<TModel, TController>(TModel model, 
        DataAnnotationsModelValidatorProvider provider, 
        ModelMetadata modelMetadata, 
        TController controller)
            where TController : Controller
            where TModel : class {
        IEnumerable<ModelValidator> validators = provider
            .GetValidators(modelMetadata, new ControllerContext());
        foreach (ModelValidator validator in validators) {
            IEnumerable<ModelValidationResult> results = validator.Validate(model);
            foreach (ModelValidationResult result in results)
                    modelMetadata.PropertyName ?? "Model", 

MVC Extensibility–CMAP Code Camp

downloadThe following is the download link for the demo code and slides for my presentation on MVC Extensibility done at the Central Maryland Association of .NET Professionals Code Camp (CMAP Code Camp).  Thanks to all who attended my presentation, it was extremely fun plowing through a ton of code all across the stack of the ASP.NET MVC Framework request execution lifecycle.


Download Demo Code & Slides


Also, big thanks to Christopher Steen and Randy Hayes for hosting and allowing me to participate as a speaker in such a wonderful event.

Code and Slides on “Intro to NHibernate 3.0 Alpha”

As promised, and in record time, the code and slides for my presentation on NHibernate 3.0 Alpha are now available for download.  As usual, I would like to express my thanks to Justin Etheredge and Kevin Hazzard for hosting and allowing me to present at Richmond Code Camp 2010.2 (

The following are links to the materials used in the presentation.

Download Slides & Demo Code

Happy coding in .NET!!!

image      Richmond Code Camp