b#: Blog

Detecting a tap on a UITextView

benscheirman — Thu, 09 Jul 2009 18:04:33 GMT

I’ve been working on a little side project (that I’ll announce soon). It is an iPhone application that I intend to sell. Being a .NET guy, I’m certainly a bit lost when it comes to troubleshooting problems. Hopefully this post will help someone else out that ran into a similar issue.

In Cocoa, any class that derives from UIResponder (which means UIView and all of it’s subclasses) can get touch events by implementing these 4 optional methods:

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event;

- (void)touchesMoved:(NSSet *)touches withEvent:(UIEvent *)event;

- (void)touchesCancelled:(NSSet *)touches withEvent:(UIEvent *)event;

- (void)touchesEnded:(NSSet *)touches withEvent:(UIEvent *)event;

With this raw data you can construct any number of touch schemes, such as knowing when to scroll and when to select something, as is the case with UITableView.

UIControl derivatives (such as UIButton) get a simpler abstraction: they use that data & translate it to different events such as < code>and touchUpInside. These don’t work for all views, so sometimes to detect a tap you have to roll your own.

In general, you can just look at the touchesEnded event and check the tapCount property to see if the user tapped an element:

-(void)touchesEnded:(NSSet *)touches withEvent:(UIEvent *)event {
   UITouch *touch = [touches anyObject]; //assume just 1 touch
   if(touch.tapCount == 1) {
      //single tap occurred
   }
}

I wanted to use this on a view that contained a full-screen UITextView.

Unfortunately, as of the iPhone SDK 3.0, UITextView swallows this event completely. I imagine because of the new feature where you can select text to copy & paste. You can get touchesBegan, touchesMoved, and touchesCancelled, but no touchesEnded. (In fact, the touch actually gets cancelled by the UITextView). Even by subclassing UITextView I could not get this event.

Luckily I found a work-around. It’s not exactly pretty, but it works for me.

First I needed to subclass UIWindow so that I can get control at the very beginning of every touch.

Next I needed to change my MainViewController.xib, which creates the window, to point to my new class.

Then, in the sendEvent method, I need to check for 3 things:

is this touch ending?
is this touch hitting my custom text view?
is this touch a single tap?

Here' is the code for my custom window:

//CustomWindow.h
@interface CustomWindow : UIWindow {
}

@end

//CustomWindow.m

#import "CustomTextView.h"

@implementation CustomWindow

-(void)sendEvent:(UIEvent *)event {
   //loop over touches for this event
   for(UITouch *touch in [event allTouches]) {
      BOOL touchEnded = (touch.phase == UITouchPhaseEnded);
      BOOL isSingleTap = (touch.tapCount == 1);
      BOOL isHittingCustomTextView = 
           (touch.view.class == [CustomTextView class]);

      if(touchEnded && isSingleTap && isHittingCustomTextView) {
         CustomTextView *tv = (CustomTextView*)touch.view;
         [tv tapOccurred:touch withEvent:event];
      }
   }
}

@end

If all the 3 BOOLs turn out to be true, then I simply call a method I defined on my CustomTextView.

This CustomTextView then calls a similar method on it’s tapDelegate (which I created). My view controller then adheres to the TapDelegateProtocol (which contains this method) and can now detech taps over a UITextView!

Now my textview becomes fullscreen when you tap it, and another tap brings back the tab bar at the bottom and navigation bar at the top.

Technorati Tags: iPhone,Cocoa,Objective-C

Getting Started with Heroku on Windows

benscheirman — Wed, 10 Jun 2009 17:57:12 GMT

Heroku looks to be a very promising way of writing Rails applications with easy deployment, source control, and hosting all built-in.

Unfortunately, the windows story of Rails development, ruby gems, Git, SQLite, are all incredibly horrible, and make it tough to get started. Wish I were on a Mac, but yeah… not on my laptop… yet.

Step 1: Install Cygwin

I can’t stress enough how awesome this tool is. it gives you a unix-style shell that supports a number of things, namely Git. You can’t run Git on windows without msys-git or similar and it is required for Heroku. (Git is the deployment mechanism for packaging up your changes and sending them to Heroku).

When you install cygwin, make sure to expand the packages and install *at least* the following:

gcc
gcc-g++
git
git-completion
git-gui
gitk
grep
gzip
libsqlite3-devel
libsqlite3_0
make
man
openssh
ruby <—some say this is buggy, but it seems to work for me
sqlite3
tar
wget

Wait for it to download and install those packages. There might be others, but those are the major ones installed on my machine. If you already have cygwin installed, you can run the setup.exe file again and select the packages you’re missing.

Step 2: Install Rubygems

Note that this is required even if you already have the one-click ruby installer on windows. Steven Harman wrote about how to do this in cygwin:

Download the RubyGems tarball from Ruby Forge

Unpack the tarball

In a bash terminal, navigate to the unpacked directory
Run the following command:
ruby setup.rb install
Update RubyGems by running the following:
gem update --system
Note: You may need to run the updated command twice if you have any previously installed gems.

Note, if you try to run some ruby files and you get a “could not load rubygems” error, you may need to unset the RUBYOPT environment variable. The windows version might be conflicting with the cygwin version.

Step 3: Install sqlite3-ruby gem

The sqlite3-ruby gem is actually a CGem (not ruby) so it needs a windows binary. Unfortunately, there isn’t a windows version yet, so you need to back up to the latest one that does, which is 1.2.3 as of this post.

gem install sqlite3-ruby –v 1.2.3

If this fails with an error saying “looking for sqlite.h…no” then you probably haven’t installed the libsqlite3_devel package in cygwin. This tripped me up.

Step 4: Install json gem

Again, the latest version of this gem doesn’t work yet with Windows, so you have to request version 1.1.1.

gem install json –v 1.1.1

Step 5: Install Heroku gem

gem install heroku

Step 6: Create an SSH key file

In order to communicate securely with heroku, you need to create an SSH key file.

$ cd ~/
$ mkdir .ssh
$ cd .ssh
$ ssh-keygen –C “my key” –t rsa

This should create a public & private key file. Heroku will look for this.

Now we can follow the standard heroku instructions, which are pretty simple. Here’s how you’d create a sample rails app, initialize git, add files, and create the app on heroku. Finally we’ll push the code & you can see it running online.

$ rails foo
$ cd foo
$ git init
$ git add .
$ git commit –m “adding files”
$ heroku create (type in heroku credentials when prompted)
$ git push heroku master

You’ll be given a URL when you create the app on heroku, so after you push you can visit http://your-app-name.heroku.com to see it live!

Hope this helps someone else get started faster than me!

jQuery Autocomplete with a Hidden Value

benscheirman — Tue, 02 Jun 2009 13:34:20 GMT

A number of people commented on my post about a jQuery Autocomplete Textbox in ASP.NET MVC wanting to know how to provide a value for the items being displayed. It’s not an uncommon request. For many pieces of data you’ll have display values as well as unique identifiers to distinguish & provide reference to the items.

Unfortunately it’s not well document, however this is fully supported with Dylan Verheul’s jQuery autocomplete plugin.

The first step is to separate your display names from the values in your result from the server. We were retuning cities before, like this:

HOUSTON, AK 
HOUSTON, AL 
HOUSTON, TX 
HOUCK, AR 
HOUGHTON, IA

The individual items are separated by a new line character. In order to provide a value for each of these, you have to separate the item with a pipe “|”.

HOUSTON, AK|456 
HOUSTON, AL|1245 
HOUSTON, TX|553 
HOUCK, AR|99 
HOUGHTON, IA|401

If your display items might contain a pipe character, then you’ll have to change the separator setting for the plugin. You can do by providing the option cellSeparator.

Now that our items have a value coming back from the server, how can we retrieve it when an item is selected? That is done via the onSelectItem function. This is a callback that will send you the formatted <li> tag. If there was a value specified, it will be placed in the extra attribute.

Here’s an example:

$(cities).autocomplete(action_url, {
    lineSeparator: '\n',
    cellSeparator: '|',
    onItemSelect: function(li) { if(li.extra) alert("You selected " + li.extra[0]); }
});

I’ve specified the options for lineSeparator and cellSeparator. These are the default values, but you can easily change them if the character is a valid portion of the text being returned by the server.

You can use this handler to place the selected value in a hidden field to save it for a form submission.

Hope this helps! For more information, I suggest you read the source code and examine the plugin page source for more examples.

Hello Isaac & Isabella!

benscheirman — Mon, 01 Jun 2009 14:33:19 GMT

Last saturday, our twins were born!

Isaac Sawyer Scheirman (5 lbs 1 oz, born at 7:32 PM Saturday 5/23/2009)

Isabella Rose Scheirman (4 lbs 10 oz, born at 7:34 PM on 5/23/2009)

The babies were 6 weeks premature, so they're still in the hospital. They're both healthy, good lung development, they can maintain their temperature, etc. They just need to gain some more weight so they can come home!

Needless to say, I've been incredibly busy... :)

I've uploaded more photos are up on flickr if you're interested.

Upgrading my Hackintosh to 10.5.7

benscheirman — Wed, 13 May 2009 18:08:41 GMT

I updated my Hackintosh to OS X 10.5.7 last night. Luckily I had just backed up my system volume with SuperDuper the night before, so I felt confident in doing the update.

Usually updates are the bane of any hack-users existence (I wouldn’t exactly call myself a hacker, as I simply leverage smart peoples’ work). Updates to OS X generally replace hacked kexts, or add new road bumps that prevent previous hacks from working properly.

In my case, the upgrade went very smoothly. The system rebooted (twice for some reason) and I was able to log back in.

My sound didn’t work, so I loaded up Kext Helper and loaded up these two kexts again:

HDAEnabler
Custom AppleHDA for my Realtek ALC888 onboard sound card

(luckily I saved these from previous endeavors)

My drive icons were all orange (as if they were external USB drives instead of internal SATA ones), so I installed this fix to restore their normal icons:

http://pcwizcomputer.com/index.php?option=com_docman&task=doc_details&gid=82&Itemid=74

Everything seems to be running perfectly smooth.

As an aside, a lot of folks have asked me how my hackintosh is treating me. Is the honeymoon phase over? Yes and no. The system is not without it’s flaws. I only recently got my microphone to work, and I still haven’t been able to get 5.1 surround to work (which is pretty low on my important-things-to-do list). My printer doesn’t work, so I’m relegated to printing from XP in VMWare Fusion. I still need to purchase a nice webcam that works with OS X.

I still thoroughly enjoy using OS X, even more so than Windows 7. The software is just that much more polished.

For development, it kind of sucks to have to be in Windows to use Visual Studio. MonoDevelop may get there one day, or perhaps JetBrains will unload an awesome cross-platform .NET IDE. Who knows.

The last thing I miss are games. I’ve been seriously considering cancelling my World of Warcraft account, due to lack of time… but I’d still like to play an FPS or two when they come out, and it looks like I’ll have to dual boot if I want to do that, since they’re almost never on the Mac.

A Culture of Microcomponents

benscheirman — Fri, 01 May 2009 18:16:35 GMT

Imagine that you are given the opportunity to rewrite (or upgrade with extreme prejudice) one of your older .NET 2.0 (or 1.1) projects using .NET 3.5. You wrote it, so you have intimate knowledge of the current architecture, what parts smell, what works well. You know what custom components you wrote to solve various problems, etc. You also have a ton of lessons learned. Now you get to do again, only this time you have more advanced, sharper tools at your disposal.

I went through this process recently and came up with no shortage of 3rd party libraries I wanted to use for the new version:

This list is nothing to sneeze at, and it's just what I could remember... in fact it's probably a bit longer. This tends to scare people, as it is a lot of stuff to learn. What the heck are these things? Where did they come from? Do I need it? How do I learn it? Why did you include this?

That's a great question. Why do I want to use all of these things?

I firmly believe in leveraging the work of others, and writing code that is expressive and easy to maintain. Some of these projects exist solely to make working with another item from the list a lot easier. NHibernate is a great example. I loves me some NHibernate, but writing XML mapping files by hand isn't what I'd call a fun time. Fluent NHibernate makes this so much nicer. The last thing I want to do is reinvent the wheel.

I don't think I'm alone here. Most projects I come across have a similar attitude regarding re-using rather than re-inventing. Most come with a dozen or so additional libraries so that it can function. I recently asked on twitter how many 3rd party libraries folks are using. The average result was about 5, but some were as high as 12.

The bottom line for me is: The value I get from leveraging 3rd party tools is greater than the psychic weight that they cause. But others may not agree with me.

What about the Ruby community? Don't they have this problem? Absolutely. But I don't think they would classify it as a problem, and I'd tend to agree. Say you're writing a ruby app and you somehow want to integrate flickr with twitter and paypal.

> gem install flickr
> gem install twitter
> gem install paypal

...Wait what? That's it? Yep. Rubygems is a thing of beauty. It lowers the barrier to installing 3rd party plugins and libraries. Rails plugins has a similar concept. Need to rate one of your models?

script/install plugin acts_as_rateable

Want to use jQuery instead of prototype/scriptaculous? simply run

script/install plugin jrails

These techniques allow you to add small pieces of functionality to existing applications with relative ease. You don't have to open a web browser & search for the tool. You don't have to download & extract it somewhere. And you don't need to copy it into your project tree. Everything is done with a single command.

It seems as if every concept and service has their own gem or rails plugin. Rails applications today can be built rather simply by composing tiny pieces of functionality written by other people.

So why can't we do this in .NET? Well in short, we can... but it requires a culture shift. For starters, in .NET we generally check in all of our dependencies into source control, so that we can always guarantee that each developer has all of the required tools (and the specific versions of such tools). With ruby gems, each gem is installed into a common location, which is consistent across all machines (actually it is configurable, but the point is it's a global directory). To use one of the gems installed on your machine, you simply do this:

require 'hpricot'

It knows to load up that library from a central location. When this application is deployed to another environment, the same thing occurs. Gems are installed via the same commands as on the dev machines.

Back at ALT.NET Seattle 2009 I convened a session to discuss revitalizing one of the many gems-for-.NET projects. We identified several efforts along similar lines as gems:

ngems
cogs
nu
horn
Machine.PartStore

Out of this discussion, a few folks decided to start fresh with a new project (affectionately called rocks), and toy with getting rubygems to work with IronRuby and wrapping it all in our own command line interface. Not much has been done on this except a quick spike, but I think the idea is promising.

I believe that if something like this comes up in the .NET community it will lead to a shift in how we think about dependencies, components, and overall re-use of small pieces of code to build larger applications.

What do you think?

Awarded INETA Community Champion for Q1 2009

benscheirman — Sun, 26 Apr 2009 23:47:30 GMT

Just a small announcement: I was recently awarded the INETA Community Champion Award! I'm finding that my community work is rewarding in many ways. Over the past couple years I have met so many influential people that have helped me (inadvertently) build my own career. I sincerely hope that any efforts I make in the community have a similar effect to others.

jQuery Auto-Complete Text Box with ASP.NET MVC

benscheirman — Tue, 21 Apr 2009 14:55:01 GMT

This is an excerpt from Chapter 13 in my upcoming book, ASP.NET MVC in Action.

_________________________________________________

These days it is not uncommon to have text boxes automatically suggest items based on what we type. The results are further filtered as we type to give us the option to simply select an available item with the mouse or keyboard. One of the first examples of this in the wild was Google Suggest.

Figure 13.1 Google Suggest filters options as you type

A rudimentary implementation of this would simply monitor key-presses and fire off ajax requests for each one. Of course this means that fast typist would trigger many requests, most of which would be immediately discarded for the next request coming in 5 milliseconds. A good implementation will take into account a typing delay and also provide keyboard/mouse support for selecting the items.

Luckily jQuery has an extensive list of plugins available. One such plugin is Dylan Verheul’s autocomplete.

Dylan Verheul’s autocomplete
You can download the autocomplete plugin at http://www.dyve.net/jquery/ along with a few others including googlemaps and listify.

The basic idea is you have a simple text box on your page. The jQuery plugin adds the necessary behavior to handle key press events and fire the appropriate Ajax requests off to a URL that will handle the request. The URL needs point to a controller action, and by convention the response is formatted in a special way so the plugin could handle the response.

Assume for our purposes that we wanted to filter US Cities in the text box. The first step is to add a controller, action, and view for displaying the UI for this example. Ensure that jquery (in this case jquery-1.2.6.js) and jquery.autcomplete.js are referenced at the top of the view (or master page).

<script type="text/javascript" src="../../scripts/jquery-1.2.6.js"></script>
<script type="text/javascript" src="../../scripts/jquery.autocomplete.js"></script>

Next, add the text box. In this example we will call it city.

<%= Html.TextBox("city") %>

Package this up with a simple controller (Listing 13.1).

Listing 13.1 – a controller & action for displaying our test page

public class HomeController : Controller 
{ 
     public ActionResult Index() 
     { 
          return View(); 
     } 
}

Figure 13.2 – Our simple view with a text box.

Now we add a little Javascript to add the autocomplete behavior.

<script type="text/javascript"> 

$(document).ready(function() { 
     $("input#city").autocomplete('<%= Url.Action("Find", "City") %>'); 
}); 

</script>

Place this in the <head> of the page. You can see that the URL for the autocomplete behavior is specified as Url.Action("Find", "City"). This will point to a Find() action on the CityController. We'll need to write this controller & action next.

Local Data Mode
The autocomplete plugin can also filter local data structures. This is useful when you have a limited set of data and you want to minimize requests sent to the server. The autcomplete plugin in local mode is also much faster, since there is no Ajax request happening behind the scenes. The only downside is that you must render the entire array onto the view.

Listing 13.3 – An action to find cities from an autocomplete ajax request

public class CityController : Controller 
{ 
  private readonly ICityRepository _repository; 
  
  public CityController() 
  { 
    //load up a CSV file with the city data
    string csvPath = Server.MapPath("~/App_Data/cities.csv");
    
    //the repository reads the csv file
    _repository = new CityRepository(csvPath); #2 
  } 

  //this constructor allows our tests to pass in a fake/mock instance
  public CityController(ICityRepository repository) #3 
  { 
    _repository = repository; 
  } 

  //the autocomplete request sends a parameter 'q' that contains the filter
  public ActionResult Find(string q) #4 
  { 
    string[] cities = _repository.FindCities(q); 
    
    //return raw text, one result on each line
    return Content(string.Join("\n", cities));
  } 
}

The details of the CityRepository can be found in the code samples provided with the book. For now, we will focus on the new Find(string q) action. Since this is a standard action, you can actually just navigate to it in your browser and test it out. Figure 13.3 shows a quick test.

Listing 13.3 – A simple HTTP GET for the action with a filter of "hou" yields the expected results.

Now that we are sure that the action is returning the correct results, we can test the textbox. The Javascript we added earlier hooks up to the keypress events on the textbox and should issue queries to the server. Figure 13.4 shows this in action.

Figure 13.4 – The results are display in a <ul> tag. We can apply CSS to make it look nicer.

The drop down selections are unformatted by default, which makes them a little ugly. A little CSS magic will make it look much nicer. Listing 13.4 shows some sample CSS for this.

Listing 13.4 – CSS used to style the autocomplete results

<style type="text/css"> 

div.ac_results ul { 
  margin:0; 
  padding:0; 
  list-style-type:none; 
  border: solid 1px #ccc; 
} 

div.ac_results ul li { 
  font-family: Arial, Verdana, Sans-Serif; 
  font-size: 12px; 
  margin: 1px; 
  padding: 3px; 
  cursor: pointer; 
} 

div.ac_results ul li.ac_over { 
  background-color: #acf; 
} 

</style>

Figure 13.5 – The styled dropdown results look much nicer. The selected item is highlighted, and can be chosen with the keyboard or the mouse.

The auto-complete plug-in has many options for you to configure to your needs. For the simple case that we've shown here, it's as simple as this:

$(your_textbox).autocomplete('your/url/here');

Other options for the plugin are listed below:

inputClass	This class will be added to the input box.
resultsClass	default value: "ac_results"
loadingClass	The class to apply to the input box while results are being fetched from the server. Default is “ac_loading.”
lineSeparator	Default is \n
minChars	The minimum # of characters before sending a request to the server. Default is 1.
delay	The delay after typing when the request will be sent. Default is 400ms.

There are many more options, but these are some common ones. To set these options, you include them in a dictionary as the second argument to the autocomplete method like this:

$("input#city").autocomplete('<%= Url.Action("Find", "City") %>', { 
     minChars : 3, 
     delay : 300 
});

This type of functionality is immensely useful for selecting from large lists. It keeps your initial page size down by not loading all of these items at once and is very user-friendly.

________________________________________

This is an excerpt from Chapter 13 in my upcoming book, ASP.NET MVC in Action.

Exporting Visual Studio Solutions with SolutionFactory

benscheirman — Mon, 13 Apr 2009 16:20:29 GMT

Part of my job is to create reusable code, patterns, designs, solutions, etc for other developers to leverage. Getting started using some of these things can be initially tough for someone who hasn't had a lot of experience with long-term, maintainable solution structures for projects that use:

an automated build
3rd party libraries
machine-specific configuration
D.R.Y. for things like connection strings, etc.

Because of these things, I favor a folder structure similar to this one:

This keeps things tidy. There is a home for everything. Third party libraries get checked in to source control, as well as any light-weight developer tools that we use during the build. Everything you need to build the software on a developer's machine should be here. (Of course I assume that you already have the appropriate Visual Studio & database server on your local machine.)

In addition, many of our projects look something like this:

App.UI
App.Core
App.Persistence
App.Tests

Granted, this is very short-sighted and won't be the end-all-be-all solution structure for all projects. But the goal here is to get you (a developer) started really quickly. These projects can already contains some things that get from nothing to something tangible in short time.

My sample solution contains:

An MVC project with a standard look & feel
- images
- javascript files
A sample CRUD screen, showing a small example of the various players in displaying & updating data.
- NHibernate
- FluentNHibernate
- NHibernate.Linq
- an IOC container
- an MVC Controller factory
A test project that shows both unit and integration style tests. Some nice fluent testing extensions are left in to show how it works. (the target audience will probably only have a C# 2.0 background).

All of this is pre-wired up. Dependencies are referenced in each project. The libraries are located in a relative URL, meaning other people who check out this code can build immediately. In addition, there is a sample NAnt script that shows how to build & test the software.

It's about convention over configuration. For some applications, if they don't want to do it this way, fine. It's not about enforcement, it's about gentle guidance & encouragement.

Packaging it all up

So I went on the path of trying to export this into a set of Visual Studio project templates. I found the project templates to be less-than helpful for a few reasons. First, it assumes that you keep your projects in the root of the project folder structure. Second, there seemed to be no way to elegantly package up assemblies that the project depended on. I looked at S#arp Architecture for some help, but quickly realized that there isn't an easy road to doing all of this. In addition, as far as I could tell there is no way to automatically create solution templates. You have to create project templates for each project and then manually stitch them together.

This violated my #1 rule with the templates. In order for them to be successful, they must be really easy to change. I figure that in 2 months time, something in the template will have changed, or someone will want to tweak the design, or upgrade to a new version of a dependant assembly. If they have to go through all of those hoops to publish a new template, they just won't do it. All of the effort on the initial template will be wasted.

Then I came across SolutionFactory, which is a project started by Eric Hexter up on Codeplex. It consists of 2 major components:

A template wizard that handles all of the post-launch tasks, such as moving the projects to the right location, fixing up references, etc.
A Visual Studio add-in that creates a large solution template, containing multiple vstemplate files (project templates) and also respects my folder structure. Nice!

Usage is pretty dead simple. After installing, you get a new add-in. You have to enable the add-in before using it.

Once you place the checkmark next to the Solution Factory add-in and click OK, you should see a new menu item in Visual Studio.

When you select "Export Template" from the Solution Factory menu, you are presented with this dialog:

This controls your exported VSI file. One cool thing to note is that you can have a custom command run as part of the template invocation process. This is especially helpful if you have a firstTimeConfig.bat file or similar. Sometimes you just have to run the build once to make sure everything is in place.

During the export, any remnants of TFS source control will be stripped out in the target folder. Any read-only files will be unlocked, any *.*scc files will be deleted, and *.csproj files will be modified to remove the source control bindings. If this isn't done, you'll be prompted to remove source control bindings for each project every time you create a new project based on the template. Yuck!

When the export is finished (it takes about a minute) you should see a message box like this:

Now if we look in our c:\temp folder, we should see some new files:

The VSI is a Visual Studio Installer file, and it simplifies putting the template zip file into Visual Studio. All you really have to do is copy it to the appropriate Visual Studio 2008\Templates folder and run devenv.exe /installvstemplates to get it to rebuild the template cache. When you run the VSI, you'll get a simple installer. It will warn you that the template is not signed, just press OK.

There is one caveat though: Our template relies on SolutionFactory.Wizard.dll to run some custom actions when the template is invoked. The VSI file doesn't have permissions to copy files into C:\Program Files, so until a custom installer (MSI) is made, you have to copy this dll manually.

To do this, close down all instances of Visual Studio and copy SolutionFactory.Wizard.dll into c:\program files\Microsoft Visual Studio 9.0\Common 7\IDE\Private Assemblies. (on Vista/7 this path may be different, so adjust accordingly). This only has to be done once, and subsequent uses of the template will use this dll.

Now, fire up a fresh copy of Visual Studio, choose File->New Project, and see our new template!

When you click OK, Visual Studio will do a little dance, make sure you wait for it to finish! When it's all done, you'll end up with this:

Every thing is completely packaged up, with multiple projects, 3rd party libraries, tools, and an automated build. The best part is that we can keep the template up to date and re-publish easily.

Excerpt from ASP.NET MVC in Action Chapter 6

benscheirman — Thu, 09 Apr 2009 13:11:23 GMT

Extending URL Routing in ASP.NET MVC

Excerpted from

ASP.NET MVC in Action

Jeffrey Palermo, Ben Scheirman, and Jimmy Bogard

This article is taken from the book ASP.NET MVC in Action from Manning Publications. One of the greatest aspects of ASP.NET MVC is its flexibility. Among other things, this gives us the capability to customize standard components. In this article, we'll take a look at how URL routing functions, and then explore how to enhance it to behave differently. For the book’s table of contents, the Author Forum, and other resources, go to http://manning.com/palermo/.

The UrlRouteModule is an HttpModule and represents the entry point into the ASP.NET MVC Framework. This module examines each request, builds up the RouteData for the request, finds an appropriate IRouteHandler for the given route matched, and finally redirects the request to the IRouteHandler's IHttpHandler. Make sense?

Our default route looks like Listing 1. The MapRoute method is actually a simplified way of specifying routes. The same route can be specified with more detail, as is shown in Listing 2.

Listing 1 – a simple way of specifying routes

routes.MapRoute("default", "{controller}/{action}/{id}", 
    new { Controller="home", Action="index", id=""});

Listing 2 – a more detailed way of specifying routes

routes.Add(new Route("{controller}/{action}/{id}",
    new RouteValueDictionary(new { Controller = "home", Action = "index", id = "" }),
    new MvcRouteHandler()));

That third argument in Listing 2 is telling the framework which IRouteHandler to use for this route. We are using the built-in MvcRouteHandler that ships with the framework. By default we are using this class when using the MapRoute method. We can change this to be a custom route handler and take control in interesting ways. An IRouteHandler's responsibility is to create an appropriate IHttpHandler to handle the request given the details of the request. This is a good place to change the way routing works, or perhaps to gain control extremely early in the request pipeline. The MvcRouteHandler simply constructs an MvcHandler to handle a request, passing it a RequestContext, which contains the RouteData and IHttpContext.

A quick example will help illustrate the need for a custom route handler. When starting out defining your routes, you'll sometimes run across errors. Let's assume you also have the route shown in Listing 3 defined.

Listing 3 – Adding another route

routes.MapRoute("conferenceKey", "{conferenceKey}/{action}", 
    new { Controller = "Conference", Action="index" });

Here we’ve added a new custom route at the top position. What does it do? This will accept URLs like /HoustonCodeCamp2008/register and use the conference controller and call the register action on it, passing in the conferenceKey as a parameter to the action.

Listing 4 – a controller action that handles the new route

public class ConferenceController : Controller 
{ 
    /* snip */ 

    public ActionResult Register(string conferenceKey) 
    { 
        return View(); 
    } 
}

This is a good example of a custom route that makes your URLs a lot more readable.

Now let's assume that we have another controller called Home. HomeController has an index action to show the start page.

Listing 5 – A controller action to respond to the default route

public class HomeController : Controller 
{ 
    public ActionResult Index() 
    { 
        return View(); 
    } 

    /* snip */ 
}

We'd like the URL for the action in Listing 4 to look like /home/index. If we try this URL, we'll get a 404 error, as shown in figure 1. Why?

Figure 1 - This message doesn’t tell us much about what’s wrong. An action couldn’t be found on the controller, but which one?.

It's not apparent from that error message what the problem is. We certainly have a controller called HomeController, and it has an action method called Index(). If you dig deep and take a look at the routes we can deduce that this URL was picked up by the first route, /{conferenceKey}/{action}, which was not what we intended. We should be able to indentify quickly when we have a routing mismatch, so that we can fix it more quickly.

With lots of custom routes, it is easy for a URL to be caught by the wrong route. Wouldn't it be nice if we had a diagnostics tool to display which routes are being matched (and used) for quickly catching these types of errors?

What we’d like to do is have an extra query string parameter that we can tack on if we want to see the route information. The current route information is stored in an object called RouteData, which is available to us in the IRouteHandler interface. The route handler is also first to get control of the request, so it is a great place to intercept and alter the behavior for any route.

Listing 6 – A custom route handler creates an associated IHttpHandler

public class CustomRouteHandler : IRouteHandler 
{ 
    public IHttpHandler GetHttpHandler(RequestContext requestContext) 
    { 
        if(HasQueryStringKey("routeInfo", requestContext.HttpContext.Request)) 
        { 
            OutputRouteDiagnostics(requestContext.RouteData, requestContext.HttpContext); 
        } 
        
        var handler = new CustomMvcHandler(requestContext); 
        return handler; 
    } 

    private bool HasQueryStringKey(string keyToTest, HttpRequestBase request) 
    { 
        return Regex.IsMatch(request.Url.Query, string.Format(@"^\?{0}$", keyToTest)); 
    } 

    /* snip */ 
}

A route handler’s normal responsibility is to construct and hand-off the IHttpHandler that will handle this request. By default, this is MvcHandler. In our CustomRouteHandler we first check to see if the query string parameter is present (we do this with a simple regular expression on the URL query section). The OutputRouteDiagnostics method is shown in Listing 7.

Listing 7 – Rendering route diagnostics information to the response stream

private void OutputRouteDiagnostics(RouteData routeData, HttpContextBase context) 
{ 
    var response = context.Response; 
    response.Write( 
        @"<style>body {font-family: Arial;} 
                         table th {background-color: #359; color: #fff;} 
             </style> 
             <h1>Route Data:</h1> 
             <table border='1' cellspacing='0' cellpadding='3'> 
                  <tr><th>Key</th><th>Value</th></tr>"); #1 
    foreach (var pair in routeData.Values) 
    { 
          response.Write(string.Format("<tr><td>{0}</td><td>{1}</td></tr>", 
              pair.Key, pair.Value)); 
    } 

    response.Write(@"</table> 
           <h1>Routes:</h1> 
           <table border='1' cellspacing='0' cellpadding='3'> 
                   <tr><th></th><th>Route</th></tr>"); #2 
    bool foundRouteUsed = false; 

    foreach(Route r in RouteTable.Routes) 
    { 
        response.Write("<tr><td>"); 
        bool matches = r.GetRouteData(context) != null; 
        string backgroundColor = matches ? "#bfb" : "#fbb"; #3 
        if(matches && !foundRouteUsed) 
        { 
            response.Write("&raquo;"); #4 
            foundRouteUsed = true; 
        } 
        response.Write(string.Format( 
              "</td><td style='font-family: Courier New; background-color:{0}'>{1}</td></tr>", 
              backgroundColor, r.Url)); 
    } 

    response.End(); 
}

1. Create an HTML table to display the route values for the current request.
2. Create an HTML table to display the routes
3. Green if it matches, Red if it doesn't
4. Places a chevron character (») next to the route selected for the request

This method outputs two tables, one for the current route data, and one for the routes in the system. Each route will return null for GetRouteData if the route doesn’t match the current request. The table is then colored to show which routes matched, and a little arrow indicates which route is the one in use for the current URL. The response is then ended to prevent any further rendering.

To finalize this change, we have to alter the current routes to use our new handler.

Listing 8 – Assigning routes to our custom route handler

RouteTable.Routes.Add( 
  new Route("{conferenceKey}/{action}", 
  new RouteValueDictionary( new { Controller="Conference" }), 
  new CustomRouteHandler())); 

RouteTable.Routes.Add( 
  new Route("{controller}/{action}/{id}", 
  new RouteValueDictionary( new { Action="Index", id=(string)null }), 
  new CustomRouteHandler()));

The end result (shown in Listing 2) is incredibly helpful. Let’s use the /home/index URL (that resulted in a 404 in Listing 1) but this time we’ll add the ?routeInfo to the query string. We can see in the route data table that the value “home” was picked up as a conference key, as shown in figure 2. The route table confirms that the conference key route was picked up first, since it matched.

Listing 2 – appending ?routeInfo gives us detailed information about the current request’s route. We can easily see now that the wrong route was chosen.

Now you can immediately tell that the current route used is not the one we intended. We can also tell whether or not other routes match this request by the color of the cell: Both of the rows are green. We now quickly identify the issue as a routing problem and can fix it accordingly. In this case, if we add constraints to the first route such that conferenceKey isn’t the same as one of our controllers, the problem is resolved. Remember that order matters! The first route matched is the one used.

Of course you wouldn’t want this information to be visible in a deployed application, so only use to aid your development. You could also build a switch that changes the routes to the CustomRouteHandler if you’re in debug mode, which would be a more automated solution. I’ll leave this as an exercise for the reader.

Inspired by Phil Haack’s Route Debugger
This example was inspired by Phil Haack’s route debugger that he posted on his blog when the ASP.NET MVC Framework was in Preview 2. It is a great example of what you can do with the information provided to you by the routing system. You can see his original example of this here:
http://haacked.com/archive/2008/03/13/url-routing-debugger.aspx.

Another potential use of a custom route handler would be to append a specific identifier to the query string automatically. This could be useful in scenarios where you rely on cookie-less sessions or maybe you have a company identifier that limits what is displayed on the screen (your author has interfaced with such a framework). An IHttpHandler that would satisfy this requirement might look like this:

Listing 9 – An MvcHandler that can enforce query string parameters

public class EnsureCompanyKeyHandler : MvcHandler 
{ 
  public EnsureCompanyKeyHandler(RequestContext requestContext) 
    : base(requestContext) 
  { 
  } 

  protected override void ProcessRequest(HttpContextBase context) 
  { 
    var controller = (string) RequestContext.RouteData.Values["controller"]; 
    var company = context.Request.QueryString["company"]; 
    if (controller != "login" && company == null) 
    { 
      context.Response.Redirect("~/login"); #1 
    } 
    else  
    { 
      base.ProcessRequest(context); #2 
    } 
  } 
}

1. Force them to login
2. The URL contains a company key, so we can continue

In this example, every request must have a company key. The ProcessRequest method will not continue unless the URL contains this.

Hopefully you noticed how easy it was to extend the framework. Since most of the objects that you interact with are either interfaces or abstract base classes, it allows you to completely (or almost completely) substitute behavior for your own. It is in this level of flexibility where you will see the ASP.NET MVC Framework really shine.

This article is taken from the book ASP.NET MVC in Action from Manning Publications.