Twitter Feed Popout byInfofru

OverrideThis.com

Adventures in .NET Software Craftsmanship!

CapArea.NET–jQuery Mobile Introduction

 

imageAs promised, the following is the link to the bitbucket repository with all the sample code for my presentation on jQuery Mobile on the ASP.NET MVC platform.

https://bitbucket.org/rhp_74/overridethis.rsvpmobilesample

I would like to thank everybody who attended the user group and once again thank the Capital Area.NET User Group leadership for allowing me to share my ideas and thoughts in such a great venue.  Now, go build something and lets conquer the mobile space!

WebPiCmdLine–Easily provision your Web Servers!

The Web Platform Installer is Microsoft’s solution for distributing framework, products and applications that revolve around their web platform solutions.  If you are a web developer like me, it is probably the first thing you need to install on your development box or on the servers you manage.  Needless to say, I am a big fan but I don’t think I realized its true potential until I stumbled into the command line version of the Web Platform Installer, also known as the WebPiCmdLine.  Now, I get to do a lot of the infrastructure work in the projects that I take part of that means provisioning servers, installing the Continuous Integration software (Build Server), automating deployments to staging and production environments. In other words, I implement and design Deployment Pipelines for Continuous Delivery processes.  Anyway, too much conversation, lets look at a couple of working examples of when the WebPiCmdLine is useful and convenient.

 

Example 1 – Ramping up a Basic Developer Box

Lets say you want to install basic development tools on a Windows 7 Professional fresh install, perhaps you are performing a demo of a basic web application or maybe you are installing the latest and greatest technology and don’t want to ruin your current development environment.  Well one way you could setup all the required software on a fresh install  is to download the Web Platform Installer and browse through their list of frameworks, products and applications and click which products you want to install and your done.  The drawback though, is that you would have to be clicking around to find all the products and accepting all the EULA (End User License Agreement), it just takes too much attention and time.  The quick and easy way is to use the WebPiCmdLine to do the work.  Now my assumptions for the following snippet of code is that you have downloaded the WebPiCmdLine and extracted its content to a local folder on your drive, in my case “C:\Installer\WebPiCmd\”, the following script is located in the “C:\Installer\” folder.

 

@rem installer.cmd
SET WebPiCmd=.\webpicmd\WebPiCmd.exe
%WebPiCmd% /Install /Products:NETFramework4 /AcceptEula
%WebPiCmd% /Install /Products:SQLExpress /SQLPassword:P@ssw0rd /AcceptEula
%WebPiCmd% /Install /Products:SQLManagementStudio /AcceptEula
%WebPiCmd% /Install /Products:VWD /AcceptEula
%WebPiCmd% /Install /Products:MVC3 /AcceptEula
%WebPiCmd% /Install /Products:MVC4VS2010 /AcceptEula

 

Example 2 – Web Server for ASP.NET MVC Applications

The setup would be the same as above but in this scenario we are installing on top a Windows Server 2008 R2 fresh install.  This would be our web server to showcase a basic ASP.NET MVC application.

 

@rem installer.cmd
SET WebPiCmd=.\webpicmd\WebPiCmd.exe
%WebPiCmd% /Install /Products:NETFramework4 /AcceptEula
%WebPiCmd% /Install /Products:IIS7 /AcceptEula
%WebPiCmd% /Install /Products:MVC3 /AcceptEula
%WebPiCmd% /Install /Products:MVC4VS2010 /AcceptEula

 

Conclusion

I wrote a blog, not so long ago, about installing Rails on Ubuntu and how I had scripted out a basic install to ease the process of rolling a new Ubuntu image and rebuilding my developer environment.  The script that I wrote was fairly complex and tedious, but if a Linux noob like me could write it anybody can.  At the time, I felt there was no equivalent easy way to perform quick and clean scripted installations on the Windows platform but recent research has shown me that times are changing.  The WebPiCmdLine is just one of the relatively new tools (see NuGet, Chocolatey, or PowerShell)  that are providing developers the power to write deployment and automation scripts for the windows platform.  One comment, I do feel that the Web Platform Installer is powerful and useful enough that it really shouldn’t be only associated with the web, why not re-brand it as the Windows Platform Installer, and let it be used for installing anything on the operating system.

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() {
    AreaRegistration.RegisterAllAreas();
    RegisterGlobalFilters(GlobalFilters.Filters);
    RegisterRoutes(RouteTable.Routes);
    RegisterBundlers();
}

private static void RegisterBundlers() {

    BundleTable.Bundles.AddDefaultFileExtensionReplacements();
    BundleTable.Bundles.AddDefaultIgnorePatterns();
    BundleTable.Bundles.AddDefaultFileOrderings();

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

 

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 (http://www.sparkviewengine.com) 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.

 

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

 

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.

 

@HelloWorld("Roberto!")

@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";
}

<h2>OrganizationTree</h2>

@OrgTree(Model, null);

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

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. 
http://blog.overridethis.com/blog/post/2010/04/22/MVC2-Model-Validation-and-Testing-Scenarios.aspx

 

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>();
        metadata.Add(GetMetadataForClass(model));
        metadata.AddRange(GetMetadataForProperties(model));

        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
            .Current
            .GetMetadataForType(() => model, typeof (TModel));
    }

    private static IEnumerable<ModelMetadata> GetMetadataForProperties<TModel>(TModel model)
       where TModel : class {
        return ModelMetadataProviders
            .Current
            .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)
                controller.ModelState.AddModelError(
                    modelMetadata.PropertyName ?? "Model", 
                    result.Message);
        }
    }
}