Chris Farrell

Getting Started with the Telerik MVC Extensions

Sun, 12 Feb 2012 17:01:31 -0800

Back before ASP.Net MVC when all we had was WebForms it was unthinkable for practically any mid to senior level developer to not use off the shelf UI tooling such as the Telerik WebControls or Component One's suite of tools on virtually every project. However, when ASP.Net MVC rolled around it seems that the preference quietly shifted away from using off the shelf components in favor of using jQuery plug-ins which sometimes were very easy to integrate but sometimes required a great deal of effort building server code to generate the desired client to server integration.

On my last few projects, whenever possible we have opted to use the Telerik extensions rather than integrating jQuery plugins whenever possible. Based upon this experience, I must admit I am quite satisfied and impressed.

Great Documentation and Examples

While some jQuery plugins have great examples and documentation there are plenty that do not. With the Telerik Extensions the documentation is as good as I have seen for any product. The installer sets up a local website with demos and code snippets, you get a CHM reference and even the Visual Studio projects of the demos.

A Wide Selection of Ready to Use UI Themes

The standard Telerik toolkit comes with a nice selection of themes. In most cases you can all together avoid investing ANY effort at all in styling the controls and can just use one of the provided themes as is resulting in huge time savings.

Another huge bonus of the UI themes is that all of the controls are styled to match. If you were to go grab a jQuery calendar plugin, a grid plugin and a menu plugin, you would have to invest time making the UI consistent between these controls.

Awesome support(with paid license)

When we first started using the Telerik MVC Extensions we did have a few hiccups as would be expected. Since support was available we submitted a few of our issues and to my surprise I received intelligent responses that provided either a solution or a workaround for our problem within a matter of a few hours

Getting Started

Depending upon your project you may be able to just add the Telerik components using a NuGet package. However, if you wish to manually install the extensions, the steps are

Download the Telerik MVC Controls from http://www.telerik.com/products/aspnet-mvc/download.aspx
Run Installer(next, next, finish)
Add reference to the Web Project for Telerik.Web.Mvc.dll located at (C:\Program Files (x86)\Telerik\Extensions for ASP.NET MVC Q2 2011\Binaries\Mvc3)

Add reference to Telerik.Web.Mvc.UI in pages element of web.config

Copy ENTIRE scripts folder to local project from C:\Program Files (x86)\Telerik\Extensions for ASP.NET MVC Q2 2011\Scripts. Keep files in the folder(ex, 2011.2.914). This prevents version conflicts
Copy ENTIRE folder from C:\Program Files (x86)\Telerik\Extensions for ASP.NET MVC Q2 2011\Content\2011.2.914 to local MVC project Content Folder

In MasterPage or <head> element of specific pages, add the StyleSheetRegister

         @Html.Raw("@(Html.Telerik().StyleSheetRegistrar().DefaultGroup(group => group.Add(\"telerik.common.css\").Add(\"telerik.webblue.min.css\")))");

This will render the CSS for the Telerik Controls

@(Html.Telerik().StyleSheetRegistrar().DefaultGroup(group => group
										.Add("telerik.common.css")
                                        .Add("telerik.webblue.min.css")
										))

In MasterPage or <head> element of specific pages, add the ScriptRegistrar...must be after any extensions that use it
```
         @(Html.Telerik().ScriptRegistrar().jQuery(false))
         
```

Running the Demos and Examples without SQL Express Installed

If you do not have SQL Express installed you will get an error about "Database .... cannot be upgraded because it is read-only or has read-only files.

Copy Database from C:\Program Files (x86)\Telerik\Extensions for ASP.NET MVC Q2 2011\Examples\Telerik.Web.Mvc.Examples\App_Data to your local SQL Server Instance Data Folder
Attach DB in SQL Management Studio, use a meaningful database name(ex TelerikQ2_2011)
Update Web.Config for Telerik Examples at C:\Program Files (x86)\Telerik\Extensions for ASP.NET MVC Q2 2011\Examples\Telerik.Web.Mvc.Examples to point to your SQL instance database rather than the file based SQL Express connection string

Codemash 2012 Recap & Pictures

Sat, 14 Jan 2012 15:54:56 -0800

First off, I would like to express my gratitude to

the volunteers who put forth hundreds of hours to organize Codemash. I cannot begin to imagine the challenges and headaches of organizing an event like CodeMash and somehow you guys pull it off with flawless execution every single year. Kudos.
the sponsors who make CodeMash possible(and also give out cool free stuff)
The presenters and the attendees
the pigs that committed themselves so that we could enjoy bacon
the chickens involvement in providing eggs for breakfast

Below are photos I took at Codemash 2012 including misc event photos, pictures of humorous Tweets on the large screen, a few presentations and the Pecha Kucha talks. If you are in one of these photos and want the high-res image, I have NEF/RAW and jpg

Misc CodeMash Images

This Is Why You Shouldn't Put Tweets on the Big Screen

Pecha Kucha

Scott Hanselman - Dealing with Information Overload

Findlay Area .Net Users Group(FANUG) - Improving Software Quality with Continuous Integration, and An Introduction to FluentMigrator

Wed, 28 Sep 2011 17:10:05 -0700

Continuous Integration is a set of processes that aim to improve the quality of software by applying quality control during development instead of the traditional model of testing after code is complete. In this presentation we will cover the various processes involved in implementing continuous integration, common obstacles developers face when implementing continuous integration and how to overcome them.

FluentMigrator is a database migration framework for .NET that allows you to write database migrations in C# using a Fluent Interface. FluentMigrator can update existing databases, create a specific version of the database as it was in some previous release or create a new database for automated testing.

MVC3 Unobtrusive Validation With MVC Contrib

Sun, 14 Aug 2011 15:58:23 -0700

Validation was a weakness of MVC until MVC3 came out with unobtrusive validation support. However, to get this feature you had to use the Microsoft provided MVC helpers. Having used MVC Contrib's helpers for a while, I found it frustrating to go back to the out of the box html helpers from Microsoft. After spending some time playing with it and doing research, I came up with a solution that I'm quite happy with that allows adding the unobtrusive validation attributes to the MVC Contrib controls.

The Markup

<% using (Html.BeginForm(a => a.Contrib())){ %>
        <%: Html.ValidationSummary(true) %>
        
            TestModel
    
            
                <%: Html.TextBox(a=>a.FirstName).Disabled(false) %>
                <%: Html.ValidationMessageFor(a=>a.FirstName) %>
            
            
                <%: Html.DropDownList(a=>a.SomeValue).Options(Model.ListOfSomething,a=>a.Id,a=>a.Name) %>
                <%: Html.ValidationMessageFor(a => a.SomeValue)%>
                    
    
            
                
            
        
    <% } %>

Contrib Extensions

public static class MvcFavoritesExtensions
    {
        public static MvcContrib.FluentHtml.Elements.TextBox TextBox(this HtmlHelper htmlHelper, Expression> expression) where TModel : class
        {
            return new TextBox(expression.GetNameFor()).AddValidationAttributes(htmlHelper, expression);
        }
        public static MvcContrib.FluentHtml.Elements.Select DropDownList(this HtmlHelper htmlHelper, Expression> expression) where TModel : class
        {
            return new Select(expression.GetNameFor()).AddValidationAttributes(htmlHelper, expression);
        }
        public static MvcContrib.FluentHtml.Elements.CheckBox CheckBox(this HtmlHelper htmlHelper, Expression> expression) where TModel : class
        {
            return new CheckBox(expression.GetNameFor()).AddValidationAttributes(htmlHelper, expression);
        }
        private static T AddValidationAttributes(this FormElement element, HtmlHelper htmlHelper, Expression> expression) where T : FormElement
        {
            var validationAttributes = htmlHelper.GetUnobtrusiveValidationAttributes(ExpressionHelper.GetExpressionText(expression));
            
            foreach (var attr in validationAttributes)
            {
                element.Attr(attr.Key, attr.Value);
            }
            return (T)element;
        }
    }

A Sample ViewModel

public class TestModel
    {
        [Required(ErrorMessage = "First Name is Required")]
        public string FirstName { get; set; }

        public IEnumerable ListOfSomething { get; set; }

        [DisplayName("Some Value")]
        [Range(2,5,ErrorMessage = "Must be second or higher")]
        public int SomeValue { get; set; }
    }

The Rendered Markup

 
        
            TestModel

Automating SSRS Report Deployment for CI

Sun, 10 Jul 2011 17:56:34 -0700

I am a big fan of automating as much as possible, especially when it comes to deployment and QA. One of the items I recently looked at automating is report deployment for SSRS.

The Standard Approach - Using rs.exe to Deploy Reports using Reporting Service Script(RSS)

SQL Server Reporting Services 2008 includes a command line utility for report deployment called rs.exe. Unfortunately, in order to use this tool, you have to pass in a Reporting Server Script(RSS) file consisting of VBScript. Writing Reporting Server Script(RSS) is not easy as you are writing it without intellisense and the documentation and examples are less than organized or complete.

While trying to find documentation on RSS Script files I discovered a 3rd party utility called RSS Scripter which generates the scripts for you. Unfortunately, this tool has not been updated to support SQL Server 2008 R2 and also works by deploying reports from a reporting server to another reporting server. I wanted a solution that could deploy reports that had not already been deployed and thus needed something that could deploy from the file system to a reporting server.

The Better Approach - Using the SOAP API

While researching how to automate deployment of SSRS reports, I stumbled upon a semi-hidden gem of SSRS. Apparently SSRS has a built in SOAP API published via ASMX web service that you can use for deployment and configuration.

SQL Server Reporting Services actually publishes several endpoints. Two of them, ReportingSerice2005.asmx and ReportingService2006.asmx are now deprecated in SQL Server 2008 R2. The service recommended for use with SQL Server 2008 R2 is located at http:///ReportServer/ReportService2010.asmx

Using these services is the same as using any other WebService. I personally felt this approach was superior to the RSS approach for several reasons

Better API documentation and examples
Code can be written in C# using Intellisense with compile time checking rather than being written in VB Script with no intellisense

References

http://msdn.microsoft.com/en-us/library/reportservice2010.aspx

http://msdn.microsoft.com/en-us/library/ms154699.aspx

http://msdn.microsoft.com/en-us/library/ms155134.aspx

Conditional Validation with jQuery Validate

Mon, 21 Mar 2011 20:28:02 -0700

In 90% of scenarios, fields that are required are always required. However, in some cases, you may only want to apply validation if some other form field has a specific value. For example, you may want a "please explain" box to be required only if a user selected "other" in a drop down list. These types of rules cannot be statically coded.

Adding Validation Rules Dynamically

Unless you have read the documentation in depth, you may not have known that you can add jQuery validation rules after a page is loaded and validation is configured. For example, if you want a textbox to be required only if a corresponding checkbox is checked

HTML markup

Javascript

Conditionally Applying Validation Rules

Using a trick I recently discovered, the above code can be greatly simplified. Where required is set to true or false on line 5 above, a selector can be used.

$(document).ready(function() {
      $("#otherExplanation").rules("add", { 
                   required: $("#checkbox1").is(':checked'), 
                   messages: { 
                         required: "Other Explanation is Required"
               } 
        });
 
});

As you can see, in line 3 of this example, required is not set to an absolute value of true or false. Any jQuery selector that returns a boolean can be used. Thus you could check if a panel is visible, if a value is selected in a drop down list, etc.

Bin Deploying MVC3

Sun, 20 Feb 2011 14:39:53 -0800

I recently upgraded this site to MVC3. My hosting provider(DiscountASP) allows full trust but does not have the MVC framework(s) installed so I have to bin deploy all necessary DLLs for the MVC framework I am using much the same as you may have to in production environments.

With MVC2 the deployment was pretty simple, just include the System.Web.Mvc dll and everything worked. With MVC3 I expected to deploy System.Web.Mvc and System.Web.WebPages, surprisingly quite a few more were needed.

The list of required DLLs is..

Microsoft.Web.Infrastructure - Not Part of MVC Futures as name suggests. Appears to be a part of the "ASP.Net WebPages" component that installs with MVC3
System.Web.Helpers
System.Web.Mvc
System.Web.WebPages.Deployment
System.Web.WebPages
System.Web.WebPages.Razor - interesting requirement since I am not using the Razor View Engine yet

Tips for Faster ASP.Net Debugging

Sat, 15 Jan 2011 23:39:03 -0800

As developers, one of the most time consuming things we do is debug our code. Some developers might actually spend more time debugging than writing code. This is not surprising. Developers are creatures of habit, we find a method that works then re-use it over and over. Changing our habits is not easy. Additionally, most of us have not dedicated much time to exploring the debugging tools to really get to know our way around them. In this blog I wanted to share a few features and techniques that maybe you either did not know or do not use that may save you considerable time. Note, most of these are not *new* techniques or features, some have been around since at least Visual Studio 2002.

Use IIS Express or IIS Instead of Cassini

By default, ASP.Net projects use a built in web server called Cassini for debugging. Cassini is the default mostly because it is very easy to use but unfortunately it has several problems with it. Instead of Cassini, I recommend using IIS Express. IIS Express was released by Microsoft as part of their WebMatrix project.

IIS Express is MUCH faster than Cassini for loading pages
IIS Express is MUCH more stable and reliable than Cassini. With Cassini I always had a problem where Cassini would show as running, would block the port, but the process had stopped. To resolve it I had to close all instances of Cassini then fire them back up(it IS a Microsoft product).
IIS Express allows Remote IP listening. I can send a link to allow acceptance testers or QA testers to see my local copy across our LAN.
Cassini does not support SSL, URL Rewriting rules and several other IIS features.

Download IIS Express(part of WebMatrix) using the Web Platform Installer

Debug vs Run Without Debugging

Only debug code when you need to debug it. If you just want to see the code run and do not need a debugger, run without debugging. On the Debug Menu choose "Start Without Debugging" or just press CTRL + F5.

Debugging is slow to start up.
Debugging makes your code read-only. When you stop debugging to make code changes, you lose your visual reference.

Attach/Detach to Process Instead of F5

Pressing F5 to fire up a new debugging session is a HUGE WASTE OF TIME. I almost never close my browser or leave the site I am working on. I simply attach and detach the debugger as needed. This means I do not have to re-create the problem that required debugging since I already have it on my screen. I also save the multiple steps of logging into the site and recreating the issue I already have on screen just to debug it.

Run the site in IIS Express(not debugging)
Compile and test in browser whenever you want
If you find a problem, go to the Debug Menu and Choose Attach(ALT + D + P). The processes vary based upon setup, for IIS is typically w3wp.exe, for IIS Express it is iisexpress.exe.
Once your debugging session is done and you have identified the problem, go to the Debug Menu and choose stop debugging(SHIFT + F5)
Make whatever code changes you need. Compile and then just run the page to test. If the problem still exists and further debugging is needed, re-attach to the process(Step 3) to continue debugging

Debug Code With Quickwatch

Sometimes when debugging, we realize a function does not give us the result we expect. Rather than starting and stopping the debugger in order to work out the right code, you can often just do it right there in that debug session.

Attach Debugger to Process via Debug Menu and Attach to Process or ALT + DP.
Fire up the QuickWatch with Debug -> QuickWatch(ALT + DQ)
You can enter code here to see what the output is. Ex, if you want to see what the Request.Form collection contains, you can just type in Request.Form and press enter.

Debug With Unit Tests

For those who are practicing TDD(if you aren't, you should be), writing a test can often be a nice way to debug code. The benefit of using a Unit Test for debugging is that we can call code several layers deep in our architecture with exact arguments. Ex, if I want to test a routine in my persistence layer, I can just call that routine directly with the exact arguments I want. Otherwise, you would have to either walk through a possibly lengthy UI setup to force the code down the exact path you want to test/debug or put test code your production codebase to create a shortcut to the path you want to test/debug.

Implementing OpenId Authentication for a ASP.Net MVC2 site using DotNetOpenAuth

Fri, 26 Nov 2010 20:12:13 -0800

OpenId is an excellent standard that has dramatically improved the user experience on the web allowing users to obtain personalized access to websites without creating an account on every site they visit. Trusted by some of the most popular websites on the internet such as Stack Overflow, DotNetOpenAuth is a powerful library that takes the pain out of implementing OpenId.

The Dilemma of Authentication

Authentication is a necessary evil; it is the unfortunate price we pay in order to have non-anonymous access to a system.

From a user perspective, you really just want personalized access but the idea of creating a login and password on each site you want personalized access on is a hassle. Aside from the initial friction of creating a login and password, you now have the burden of securely keeping track of yet another login and password.

As a webmaster, you are aware that your users may leave your site and never return as soon as you require them to create an account. You would like to avoid the hassle and cost of creating a secure login process, account registration process and forgotten password process. However you want to build personalized, interactive features and you cannot do that without somehow verifying the user’s identity.

OpenId as a Solution

Luckily there is a solution to this problem that benefits both users and webmasters, the solution is OpenId.

Users benefit as they no longer need to register an account and instead can just authorize your site to re-use an account they already have. This saves them time and results in one less password to remember.

Webmasters save time and money as they no longer need to worry about creating and maintaining the framework that would be needed to manage a database of accounts.

Using DotNetOpenAuth to Implement OpenId Relying Party

Unfortunately while OpenId is a very friendly for the users, it is a tedious and complicated protocol for system creators. There are many steps going on behind the scenes in the OpenId protocol and to develop and test an implementation from scratch would not be a simple task.

Fortunately there is a pre-packaged API that implements OpenId called DotNetOpenAuth that can be leveraged to greatly simplify this task. Using DotNetOpenAuth you can take away the pain of rolling your own OpenId Protocol implementation.

Getting Started with DotNetOpenAuth

To get started with DotNetOpenAuth you go to http://www.dotnetopenauth.net/ and download the current version. The files come as a zip, extract them to the location of your preference. In the zip file you will find a number of example projects inside of a samples folder. The sample we are using today is "OpenIdRelyingPartyMvc". Also note, Rick Strahl has a nice blog on how to setup OpenId using DotNetOpenAuth.

Improving the Samples - Adding ReturnUrl as a Callback Argument

At this point I am assuming you have downloaded DotNetOpenAuth and have reviewed the OpenIdRelyingPartyMvc sample. This sample is good and it works but needs some refinement to be ready for production.

With the MVC Relying Party example that comes with DotNetOpenAuth, ReturnUrl does not seem to be handled correctly. When a user requests a site that requires authentication they are sent to the login view with an optional Url argument for ReturnUrl as is standard with .Net Authentication. However, once on this view when the user posts to the server what their open id identifier is, the ReturnUrl is lost. To resolve this we will store ReturnUrl in the Login.aspx view so that it is posted by the user to the server. We will then add a Callback argument to our OpenId request so that this argument is then echoed back to us when the response is received. Finally, in this step we are cleaning up the usage of Request.Form and instead creating a model that will hold our form variables.

Store ReturnUrl as a hidden field in the Login.aspx View



	<% if (ViewData["Message"] != null) { %>
	
		<%= Html.Encode(ViewData["Message"].ToString())%>
	
	<% } %>
	You must log in before entering the Members Area: 
	" method="post">
	OpenID:

Create A New Model Called LogOnModel.cs In Your Models Folder

public class LogOnModel
{
    public string ReturnUrl { get; set; }
    public string openid_identifier { get; set; }
}

Modify the Login method in UserController.cs

public ActionResult LogOn(string returnUrl)
{
    //stage 1:  User loads logon view
    var model = new LogOnModel();
    if (!string.IsNullOrEmpty(returnUrl))
    {
        model.ReturnUrl = returnUrl;
    }
    return View();
}

Modify the Authenticate method in UserController.cs. The first change is adding returnUrl as a callback argument to the OpenId Request, we will also replace Request.Form usage and instead use LogonModel

[ValidateInput(false)]
public ActionResult Authenticate(LogOnModel model)
{
    var response = openid.GetResponse();
    if (response == null)
    {
        // Stage 2: user submitting Identifier
        Identifier id;
        if (Identifier.TryParse(model.openid_identifier, out id))
        {
            try
            {
                var request = openid.CreateRequest(Identifier.Parse(model.openid_identifier));
                       
                //add returnURL as a callback argument
                if (!string.IsNullOrEmpty(model.ReturnUrl))
                {
                    request.AddCallbackArguments("ReturnUrl", model.ReturnUrl);
                }
                return request.RedirectingResponse.AsActionResult();

            }
            catch (ProtocolException ex)
            {
                ViewData["Message"] = ex.Message;
                return View("Login");
            }
        }
        else
        {
            ViewData["Message"] = "Invalid identifier";
            return View("Login");
        }
    }
    else
    {
        // Stage 3: OpenID Provider sending assertion response
        switch (response.Status)
        {
            case AuthenticationStatus.Authenticated:
                Session["FriendlyIdentifier"] = response.FriendlyIdentifierForDisplay;
                FormsAuthentication.SetAuthCookie(response.ClaimedIdentifier, false);
                if (!string.IsNullOrEmpty(model.ReturnUrl))
                {
                    return Redirect(model.ReturnUrl);
                }
                else
                {
                    return RedirectToAction("Index", "Home");
                }
            case AuthenticationStatus.Canceled:
                ViewData["Message"] = "Canceled at provider";
                return View("Login");
            case AuthenticationStatus.Failed:
                ViewData["Message"] = response.Exception.Message;
                return View("Login");
        }
    }
    return new EmptyResult();
}

Getting First Name, Last Name and Email from the Trusted Party with a Fetch Request

With OpenId you have the ability to get additional information from the Trusted Party by doing a Fetch Request. In this case I wanted the first name, last name and email of the user. In Stage 2 below you add a FetchRequest to the OpenId Request. Then in Stage 3 you get the FetchResponse and grab the information.

Authenticate Method with Fetch Request and Fetch Response to Get User's Name and Email

[ValidateInput(false)]
public ActionResult Authenticate(LogOnModel model)
{
    var response = openid.GetResponse();
    if (response == null)
    {
        // Stage 2: user submitting Identifier
        Identifier id;
        if (Identifier.TryParse(model.openid_identifier, out id))
        {
            try
            {
                var request = openid.CreateRequest(Identifier.Parse(model.openid_identifier));

                //add fetch request to the OpenId request
                var fetch = new FetchRequest();
                fetch.Attributes.AddRequired(WellKnownAttributes.Name.First);
                fetch.Attributes.AddRequired(WellKnownAttributes.Name.Last);
                fetch.Attributes.AddRequired(WellKnownAttributes.Contact.Email);
                request.AddExtension(fetch);

                //add returnURL as a callback argument
                if (!string.IsNullOrEmpty(model.ReturnUrl))
                {
                    request.AddCallbackArguments("ReturnUrl", model.ReturnUrl);
                }
                return request.RedirectingResponse.AsActionResult();

            }
            catch (ProtocolException ex)
            {
                ViewData["Message"] = ex.Message;
                return View("Login");
            }
        }
        else
        {
            ViewData["Message"] = "Invalid identifier";
            return View("Login");
        }
    }
    else
    {
        // Stage 3: OpenID Provider sending assertion response
        switch (response.Status)
        {
            case AuthenticationStatus.Authenticated:
                //get values from fetch request
                var fetch = response.GetExtension();
                var email = fetch.GetAttributeValue(WellKnownAttributes.Contact.Email);
                var firstName = fetch.GetAttributeValue(WellKnownAttributes.Name.First);
                var lastName = fetch.GetAttributeValue(WellKnownAttributes.Name.Last);

                //do something with name and email here


                Session["FriendlyIdentifier"] = response.FriendlyIdentifierForDisplay;
                FormsAuthentication.SetAuthCookie(response.ClaimedIdentifier, false);
                if (!string.IsNullOrEmpty(model.ReturnUrl))
                {
                    return Redirect(model.ReturnUrl);
                }
                else
                {
                    return RedirectToAction("Index", "Home");
                }
            case AuthenticationStatus.Canceled:
                ViewData["Message"] = "Canceled at provider";
                return View("Login");
            case AuthenticationStatus.Failed:
                ViewData["Message"] = response.Exception.Message;
                return View("Login");
        }
    }
    return new EmptyResult();
}

How To Write Testable Code

Fri, 05 Nov 2010 23:10:22 -0700

Test Driven Development is great if you know how to do it right. Unfortunately many of the tutorials and training resources available skip right over how to write testable code because being samples they tend to not involve the typical layers you find in real code where you have services layers, data layers, etc. Inevitably when you go to test your code that does have these dependencies, the tests are very slow, difficult to write and often break as the underlying dependencies return results other than expected.

Code that is well written is separated into layers with each layer responsible for a different slice of the application. Actual layers vary based upon need and also upon developer habits but a common scheme is

User Interface/Presentation Layer This is your presentation logic and UI interaction code.
Business Logic/Services Layer This is your business logic. Ex, code for a shopping cart. This shopping cart knows how to calculate the cart total, how to count items on the order, etc.
Data Access Layer/Persistence Layer This code knows how to connect to the database and return a shopping cart or how to save a cart to the database.
Database This is where the cart's contents are saved

Without Dependency Management

Without dependency management, when you write tests for the presentation layer your code hooks into real services that hook into real data access code and then touch the real database. Really when you are testing the "add to cart" feature or the "get cart item count" you want to test the code in isolation and to be able to guarantee predictable results from your code. Without dependency management your UI tests for "add to cart" are slow and your dependencies return unpredictable results which can cause your test to fail.

The Solution is Dependency Injection

The solution to this problem is dependency injection. Dependency Injection or DI often seems confusing and complex to those who haven't done it but in reality it is a very, very simple concept and process with a few basic steps. What we want to do is centralize your dependencies, in this case the use of the ShoppingCart object and then loosely couple your code so that when you run your app it uses real services and when you test it you can use fake services that are fast and dependable. Note that there are several approaches you can take, to keep it simple I am just demonstrating constructor injection.

Step 1 - Identify Your Dependencies

Dependencies are when your code is touching other layers. Ex, when your presentation layer touches the services layer. Your presentation code depends on the services layer but we want to test the presentation code in isolation.

Step 2 - Centralize Your Dependencies

While there are several ways this can be done, in this example I am going to create a member variable of type ShoppingCartService and then assign it to an instance that I will create in the constructor. In each place where I use ShoppingCartService I will then re-use this instance rather than creating a new instance.

Step 3 - Loose Coupling

Program against an interface rather than against concrete objects. If you write your code against IShoppingCartService as an interface rather than against the concrete ShoppingCartService, when you go to test you can swap in a fake shopping cart service that implements IShoppingCartService. In the image below note that the only change is that the member variable is now of type IShoppingCartService instead of just ShoppingCartService.

Step 4 - Inject Dependencies

We now have all of our dependencies centralized in one place and our code is now loosely coupled to those dependencies. As with before there are several ways to handle the next step. Without having a IoC container such as NInject or StructureMap setup the easiest way to do this is to just overload the constructor.

Step 5 - Test with a Stub

An example of a possible test fixture for this is below. Note that I have created a fake(aka stub) of the ShoppingCartService. This stub is passed into my controller object and the GetContents method is implemented to return some fake data rather than calling code that actually goes to the database. As this is 100% code it is MUCH faster than querying a database and I never have to worry about staging test data or cleaning up test data when I am finished testing. Note that because of Step 2 where we centralized our dependencies, I only have to inject it once. Because of Step 3 our dependency is loosely coupled so I can pass in any object real or fake as long as it implements the IShoppingCartService interface.

Where do I go from here?

Use a IoC/DI container. The most common and popular IoC containers for .Net are StructureMap and Ninject. In real world code you are going to have a lot of dependencies, your dependencies will have dependencies, etc. You will quickly find it becomes unmanageable. The answer is to use a DI/IoC framework to manage it.
Use a Isolation Framework. Creating stubs and mocks can get to be a lot of work and using a mocking framework can save you a lot of time and code. The most common for .Net are Rhino Mocks and Moq

Understanding ASP.Net MVC Routing and the Model Binder

Thu, 23 Sep 2010 22:12:10 -0700

I have been doing ASP.Net MVC for a while now compared to many and one of the largest areas of fascination when I see people first experience MVC is just how clever and powerful the MVC model binder is. Today I caught myself bragging about how great the model binder is yet during this conversation I realized I didn’t really fully understand the magic going on behind the scenes.

As a developer I don’t like not understanding how things work so I decided to take some time to look it up. For starters, unless you have a custom model binder in place, you are using the DefaultModelBinder object out of the box. There are a few additional types that the model binder supports beyond the list below(ex, MVC2 adds binary data support) but for the sake of simplicity the default model binder supports binding to the following items

Primitive types, such as String , Double, Decimal , or DateTime objects.
Model classes, such as Person, Address, or Product.
Collections, such as ICollection, IList, or IDictionary

Assuming you have a controller action that accepts some combination of these items, the next step is URL Routing. The steps in the process are listed below

Route Objects are added to the RouteTable in the Global.asax file
The UrlRoutingModule uses the first matching route object to create the RouteData object which is then used to create a RequestContext object. In doing this the process is
- The route patterns that you have defined or the default route patterns, if any, that are included in your project type.
- The order in which you added them to the Routes collection.
- Any default values that you have provided for a route.
- Any constraints that you have provided for a route.
- Whether you have defined routing to handle requests that match a physical file.
The MvcRouteHandler object creates an instance of the MvcHandler class and passes the RequestContext instance to the handler
The MvcHandler object uses the RequestContext to identify the IControllerFactory object to create a controller instance with
The ControllerActionInvoker object that is associated with the controller determines which action method of the controller class and then calls that method
The route is executed.

I found it fascinating to actually look this up and understand it. Hopefully you enjoy it too!

Unsweetening the LINQ Syntactic Sugar

Tue, 21 Sep 2010 23:03:42 -0700

Of all the features built into the .Net framework, LINQ is probably my single favorite. However, sometimes the "syntactic sugar" that LINQ produces can be quite bitter when you get a runtime error and you start trying to decipher some cryptic stack trace where the line causing a problem looks something like "MyNamespace.MyClass._Closure$__111._Lambda$__97". Recently a colleage of mine shared a neat idea/tip on how to make sense out of these errors.

Credit for this idea goes to Jeff Walker, a fellow consultant of mine at Quick Solutions. I would like to thank Jeff for this idea and also thank him for not having a blog so that I can steal and publish his ideas(with permission).

If you have a lot of LINQ code, figuring out which statement is actually causing the problem can be a guess and check experiment when you get an error like this. Jeff's idea which I thought was brilliant, open the compiled code in reflector. Once you do this you can easily find the symbol referenced in the stack trace and decompile the code to find out which statement is actually causing the issue.

Securing A Website using Windows Live Web Authentication SDK

Sat, 18 Sep 2010 00:35:08 -0700

Unfortunately my web host(DiscountASP) wants $10/month for SSL even if I provide my own certificate(like a cheap one from GoDaddy). Their explanation is that getting IP addresses from ARIN is now more expensive. Whatever the reason, for a personal site, $10 for SSL is too much to pay. Instead of seeing this as a problem, I saw it as an opportunity to use Windows Live ID authentication(aka Passport).

The idea of using Windows Live credentials instead of rolling my own account system makes sense. I get a free ride on their SSL. As an added bonus, I am planning to add a comments feature to my blog at some point and since almost everyone already has a Windows Live account if I wanted to require login to prevent spam in comments most users will already have a login and not need to register.

Actually implementing the Windows Live Web Authentication was pretty easy and straightforward. Register your site, modify their sample code and go. There is more to it than that but that is saved for another post.

Unfortunately as with most APIs, you don't know the quirks until you get 80% of the way into them. Apparently with Live authentication all you get is a GUID(which is a hash of their Live ID guid and your registered application's GUID). You cannot get their name or email address.

I could of course just let users who are logged in provide their name at the time of posting a comment but then I'm trusting them to be honest. If anyone wanted to be abusive there is no way I could figure out who posted it from the GUID.

It is understandable why they do not allow you to get more than just a GUID from the user but given this limitation, if you need their name and email you must still force users through a custom registration process and then just associate this GUID with the account.

In conclusion, using Live ID for authentication does get me around the SSL barrier for login security but it is an incomplete solution.

New Website Launched

Mon, 23 Aug 2010 00:00:00 -0700

My old website is a perfect example of the costs of "Technical Debt". I am an IT consultant, I do websites for a living, yet for my personal blog up until recently I took the cheap & easy route. My site was hosted with Webhost4life because they were cheap, I was using an out of the box blog engine(SubText) because it was easy, it was only a matter of time before cheap & easy caught up with me. I noticed a few weeks ago my site was down...sort of.

One domain name pointed to a site with a server error(no recent code changes)
The other domain name was pointing to a working but out of date copy of my website

It seems they screwed up a prior server migration the last time my site crashed unexectedly, promising me that the new servers were reliable. I called tech support to get my site back up and was told the platform I was on was old and no longer supported, the only resolution they offered was to migrate...yet again...to new servers and this time hope it was done right.

Ultimately I decided that even if the new migration worked I was still unhappy.

I was tired of fighting the HTML web editor to make it do what I wanted
I wanted to add custom applications
Even if the migration worked correctly this time, I was hosting with an unreliable host

In the end I decided if it is worth doing, I should practice what I preech and do my own website the way I would do it for a customer if they were paying me. I hired a graphic designer to come up with a look and feel and started developing a new site. I wanted a good hosting provider that supported .Net 4.x and MVC2 so I opted to go with Discount ASP. It was not cheap or easy nor is the site done but at least now I am proud of my site.

HTML 5 Is Not Smart

Sun, 23 May 2010 00:00:00 -0700

As we all learned the hard way with the Netscape vs IE wars of past, web standards are a good thing. Standards produce better results for end users and save money for those paying for development.

Unfortunately, the lessons learned recently have been forgotten with the creation of the HTML 5 specification. This goal completely fails the SMART test. Smart goals should be

Specific
Measurable
Attainable
Realistic
Timely
S- Is it Specific?

Their aim is to "reduce" the need for plug-ins for Rich Internet Applications such as Flash and Silverlight. In my opinion, the term "reduce" is very not-specific and additionally the mere fact that the standard won't be done for 12 years(year 2022) means there is a lot that is up in the air for a very long time. Additionally, even in the areas that are finished the vendors have differing definitions of how to build standards compliant browsers.

M - Is it Measurable?

Reducing the need for something is not a specific goal. Reduce it by how much? Additionally, how do you measure compliance against a standard that is not yet finished? You are aiming at a moving target.

Attainable

The fact that the standard will take over a decade is pretty good evidence that they have bitten off more than they can chew.

Realistic

The 10 year time frame suggests this was not a realistic goal.

Timely

10+ years from now is a very long term goal. Given how fast technology advances the standard may well be obsolete before it is ever finished. By 2022 when the standard is finished the definition of what a web browser is and how we use the internet is likely to be very different.

Since we won't have a "finished" standard for 10+ years this means we are going to once again have the Wild Wild West where each browser will have different support for the standard. Maybe Safari will support something but nobody else does, or they do so differently. This is exactly the reason why standards exist is to prevent this type of thing not to encourage it.

The W3C would have been much SMARTer to pick a shorter term, more attainable, more realistic, more timely goal. Break the "ultimate vision" into bitesize pieces that can be delivered in a realistic time frame.

Is There A Future For Linq2SQL

Thu, 25 Mar 2010 00:00:00 -0700

Back in 2008 the ADO.Net team announced that moving forward new feature development would be focused towards the Entity Framework solution and not towards Linq2SQL. Given this kind of announcement you would expect developers to be abandoning the use of Linq2SQL. However, 2 years later in Scott Hanselman's poll of what tools developers are currently using Linq2Sql was twice as popular with developers.

From personal experience the popularity of Linq2SQL and the lack of adoption for EF is consistent. I know many who are using Linq2SQL happily, in production applications and have yet to meet anyone who is using the Entity Framework in production.

Fact is that Linq2Sql works and works well for many users. Linq2SQL, is still fully supported in .Net 4 so worst case scenario it may be depreciated in some later version of .Net but that is at least a few years out, it would still have to be supported due to the size of the userbase and by the time it is no longer supported there will likely be different choices in the ORM field to make a fresh decision with.

Kind of makes me wonder if the Entity Framework may become yet another vista or if over time the adoption rate will improve.