The Asp.net Mvc 2.0 RTM came out last month and a lot of people are converting their projects over. If you’re just starting to manually move your projects over then stop what you are doing, download and run the Mvc Converter. It will save you eons of time and frustration.

If you are like me, however, and started porting your project over manually and are now knee deep in WTFBBQ sauce then follow the steps below and your project should be up and running in no time.

1. Back up your project. Just in case.

2. Open your project file(s) inside your favorite text editor (one with a decent find/replace system). Open the Find & Replace dialog and find "603c0e0b-db56-11dc-be95-000d561079b0", replacing it with "F85E285D-A4E0-4152-9332-AB1D724D3325". My project turned up 1 result.

3. Open the Web.Config files in the root of the project and the root of the /Views folder. Open the Find & Replace dialog again, this time searching for "System.Web.Mvc, Version=1.0.0.0" and replacing it with "System.Web.Mvc, Version=2.0.0.0".

4. Add the following BindingRedirect to the bottom of the root Web.Config, just before the </Configuration> node.

<runtime>
  <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
    <dependentAssembly>
      <assemblyIdentity name="System.Web.Mvc" publicKeyToken="31bf3856ad364e35"/>
      <bindingRedirect oldVersion="1.0.0.0" newVersion="2.0.0.0"/>
    </dependentAssembly>
  </assemblyBinding>
</runtime>

5. Open the solution in Visual Studio and replace the references to System.Web.Mvc 1.0 with the 2.0 assembly.
6. Finally, and only if you really need them, open a new MVC 2.0 project and copy all the files in the /Scripts folder to your project.

Enjoy your freshly migrated project!

.NET · asp.net · code · MVC

Earlier today I had to debug a function in our code that was calling an external webservice at a clients’ site. The webservice returns a list of items and the code on our end is supposed to place them in ascending order based on each items Order property.

The client pointed that the our order wasn’t matching up with what they were seeing internally so I spoke with their developer who suggested that we make sure that the request wasn’t being cached on my machine.

I opened up Fiddler locally and was surprised to see that the none of the request/response data for the connection to the webservice was showing up.

Fiddler, for those that don’t know is a really excellent Http tracing application that allows you to see what kind of http traffic is going in and out over your network connection. You can download fiddler here.

Thankfully, Fiddler runs a simple proxy service which you can point your service requests to in .net using:

if (System.Environment.MachineName.ToLower().Equals("MyMachineName"))
{
    service.Proxy = new System.Net.WebProxy("http://localhost:8888");
}

After adding that code we were off and debugging our .Net service requests in Fiddler!

asp. · asp.net · c# · Programming · webservices

Download the source code mentioned in this blog post.

A few weeks ago on the StackOverflow podcast, something Jeff said got me thinking. Jeff was discussing how the stackoverflow team implemented their route mappings:

Those routes are… the way we implemented them are actually like decorators. Attributes on the methods. - Jeff Atwood (stackoverflow episode #54)

This instantly piqued my interest and I completely zoned out for the rest of the podcast: caught up in working out the details of how I could do this for my own Asp.net MVC projects.

Coming up with the actual attribute code was easy; writing the code to set up all the Routes using only data defined in by the attribute was tricky.

Being new to attributes, and reflection in general, it took me a few hours until I had a very basic demo working. However, I was really starting to like where it was going.

As a side note: There are lot of “helper” classes and objects in the route attribute project (it feels cluttered to me) and the reason I did this was to make the code in AssemblyExtensions.GetRoutes() easier to read.

After a few nights of Mtn Dew and convenience-store cherry-pie I finished the rough code, tests and demo project (included in this blog post) and I was starting to realize that:

1. Using the attributes is more declaritive and it feels cleaner
2. Having your route information right above your actions is incredibly useful
3. I had no more need to switch back and forth between your controller and the Global.asax.cs

How does it work?

All of the real work for the RouteAttribute is done in the AssemblyExtensions class. This class uses extension methods to augment the System.Reflection.Assembly class with two methods: GetControllers() and GetRoutes().

GetRoutes is the only method that is used by other classes, I made GetControllers public for unit testing.

GetRoutes()

GetRoutes’ first order of business is to make a list of data that it will need to build out all the routes for the assembly it was passed. After thats done GetRoutes will loop through the collected route data, build up each route and add it to the dictionary that will eventually be returned.

namespace CodeImpossible.Mvc.Routing
{
    public static class AssemblyExtensions
    {

        public static BindingFlags ActionFlags =
            BindingFlags.Instance |
            BindingFlags.Public |
            BindingFlags.DeclaredOnly;

        public static IList<ControllerMetaData> GetControllers(this Assembly assembly)
        {
            var controllers = assembly.GetTypes().ToList().FindAll(type =>
            {
                var isValidController = type.IsClass &&
                    type.IsPublic &&
                    type.IsSubclassOf<Controller>();

                var hasValidActions = type.GetMethods(ActionFlags).ToList().Any(m =>
                {
                    var valid = false;
                    if (m.ReturnParameter != null && m.ReturnParameter.ParameterType == typeof(ActionResult))
                    {
                        valid = m.GetAttributesOfType<RouteAttribute>().Count > 0;
                    }

                    return valid;
                });

                return isValidController && hasValidActions;
            }).Select<Type, ControllerMetaData>((t) => new ControllerMetaData(t)).ToList();

            return controllers;
        }

        public static IDictionary<string, Route> GetRoutes(this Assembly assembly)
        {
            var Routes      = new Dictionary<string, Route>();

            var data = (from c in assembly.GetControllers()
                        from a in c.GetActions()
                        from r in a.Data
                        select new
                        {
                            ControllerName = c.Name,
                            ActionName = a.Name,
                            RouteData = r,
                            RouteParams = a.Params
                        }).ToList();

            foreach (var r in data)
            {
                var route               = new Route(r.RouteData.RoutePath, new MvcRouteHandler());
                route.Constraints       = new RouteValueDictionary();
                route.Defaults          = new RouteValueDictionary(new {
                    controller = r.ControllerName,
                    action = r.ActionName
                });

                if (r.RouteData.RequireRouteParams && r.RouteParams.Count() == 0)
                {
                    throw new MissingRouteParameterException("Unknown", r.RouteData.RoutePath);
                }

                var missingParams = new List<ParameterMetaData>();

                if (r.RouteData.RequireRouteParams)
                {
                    missingParams = (from p in r.RouteParams
                                     where r.RouteData.RoutePath.IndexOf("{" + p.Name + "}") == -1
                                     select p).ToList();
                }

                if (missingParams.Count > 0)
                {
                    var param = missingParams.First();
                    throw new MissingRouteParameterException(param.Name, r.RouteData.RoutePath);
                }

                foreach (var param in r.RouteParams)
                {
                    if (param.Data != null)
                    {
                        if (param.Data.DefaultValue != null)
                        {
                            route.Defaults.Add(param.Name, param.Data.DefaultValue);
                        }

                        if (param.Data.Constraint != null)
                        {
                            route.Constraints.Add(param.Name, param.Data.Constraint);
                        }
                    }
                }

                Routes.Add(r.RouteData.Name ?? r.RouteData.RoutePath, route);
            }

            return Routes;
        }
    }
}

Getting the Routes into the RouteTable

Slapping route attributes onto your classes and methods is all well and good but it doesn’t mean anything unless we can get those routes into the RouteTable object easliy. Originally I had the code to add the routes looking something like

var routes = Assembly.GetCurrentExecutingAssembly().GetRoutes();

routes.ForEach(r => RouteTable.Add(r));

This, although pretty easy, wasn’t as readible as I wanted. So I added some extension methods to the RouteTable class:

RouteTable.Routes.IncludeRoutesFromAssembly();

I think both of these are much clearer than doing:

RouteTable.Routes.MapRoute("Root",
    "",
    new { controller = "Test", action = "GetItem", id = 1 });

RouteTable.Routes.MapRoute("Search",
    "Search/{id}",
    new { controller = "Test", action = "Search", id = 1 });
//.. SNIP ...

Using the RouteAttribute and RouteParamAttribute

In the controller “TestController” below there are three actions: Index, FindByText, and GetItem. Using the RouteAttribute and RouteParamAttribute makes it pretty clear that the routes for FindByText and GetItem are the same but use different RouteContraints.

So a request for /Test/Search/Hello will go to FindByText while /Test/Search/1 will go to GetItem. Also notice how GetItem has a default value of 2 for the id argument.

public class TestController : Controller
{

    [Route(RoutePath = "Test")]
    public ActionResult Index()
    {

        return View();
    }

    [Route(RoutePath = "Test/Search/{query}")]
    public ActionResult FindByText(
        [RouteParam(Constraint="[a-zA-Z]{1,}")]
        string query)
    {

        return View();
    }

    [Route(RoutePath = "Test/Search/{id}")]
    public virtual ActionResult GetItem(
        [RouteParam(Constraint=@"\d{1,}", DefaultValue=2)]
        int id)
    {

        return View();
    }
}

There is support for binding multiple routes to the same action; just add another Route attribute:

[Route("Products/Search/{id}")]
[Route("Products/{id}")]
public ActionResult GetProductById(int id)
{
    return View();
}

Downsides or things I haven’t gotten to yet

Just some gotchas that I think people might raise issue with.

All of your controllers must inherit from the System.Web.Mvc.Controller class
This isn’t really a big deal because if you are using Asp.net MVC then you really should inherit from the Controller class, but for those of you using FubuMVC or another MVC framework this should be easy to change.

Attributes can be ugly
I know a few people out there are against attributes but I think that this is a more than acceptable use because it made the code much easier to understand.

Reflection can be slow
Honestly, when I first started working on this demo I was sort of turned off by the use of Reflection myself. After weighing the possible performance loss against the gains in both readability and maintenance I decided this was definitely worth it. I haven’t performance tested this code so, as always YMMV.

As always, if I screwed up or there is a better way to do this, please let me know in the comments.

Download the source code mentioned in this blog post.

asp.net · c# · code · MVC · Open Source

“Syntax Error, Line: 2, Char: 0″. How many of you out there have seen this error while working on a web project?

Usually it’s because of a forgotten semi-colon or parenthesis in some external javascript file. But sometimes it’s something more sinister… Something darker, dirtier and just a little bit more evil.

After seeing the error message, I opened up Internet Explorer’s options dialog and unchecked the following options:

• Disable script debugging (Internet Explorer)
• Disable script debugging (Other)

I then closed IE, returned to Visual Studio, stopped and re-started debugging (ctrl+shift+F5), and watched Solution Explorer as my page began to load.

Oh! That’s not good. See the WebResource.axd request that has the same icon as the Default.aspx file? That means that a bad request was sent for an embedded resource and – most likely recieved a 404 page back instead of the javascript file, which caused our syntax error.

Ok, so how do we figure out which WebResource reference caused the problem? Well, the only way that I have come up with so far, is to manually copy and paste each WebResource.axd url from the html source of the page to the address bar and navigate there. The pages that give return a file download are ok and the ones that don’t will return a 404 page in the browser.

After finishing this long process of elimination, I found the resource request that was causing my headache:

/WebResource.axd?d=MaCiPhUUtdXNj16OOucV5e5lHCBZO...SNIP...

So how do we figure out which resource has embedded this troublesome URL into our html source? I found the solution to that in Irena Kennedy’s blog post on “How to Decrypt an ASP.NET Encrypted Data”:

Please note, that the code below should not be used in production code! It’s only meant for debugging and troubleshooting, and it may break in future versions of the .NET framework if DecryptString private method changes.

1. Add a web page (e.g. DecryptData.aspx) to your web application. For the code to work, it must run in the same appdomain as the web application that created your encrypted string.
2. Add a text box where you will type in the encrypted string.
3. Add a label where you’ll display decrypted results.
4. Add a button.
5. In code-behind on button click event, add the following code:

System.Reflection.BindingFlags bf =
    System.Reflection.BindingFlags.NonPublic |
    System.Reflection.BindingFlags.Static;

System.Reflection.MethodInfo DecryptString =
    typeof(System.Web.UI.Page).GetMethod("DecryptString", bf);

DecryptedData.Text = DecryptString.Invoke(
    null,
    new object[] { EncryptedData.Text } ) as string;

After I created this page, I pasted the WebResource.axd URL (everything up to the &t=) into the DecryptedData textbox on my DecryptData.aspx page, clicked the Decrypt button, and saw that one of my custom aspx controls was responsible. I then corrected the resource path and the page loaded as it should.

See the screenshot below for an example of the DecryptData page, or download the DecryptData .ASPX and Codebehind from my box.net folder.

asp.net · c# · debugging · Programming

Long story short: I hate re-inventing the wheel. If there is a free service that does something I need I will try my hardest to get that service into whatever I am working on. I’m currently working on an Asp .Net MVC project that needs Avatars (you know, those funny little pictures next to peoples names on Twitter). Enter Gravatar.

Gravatar is an awesome service for anyone looking to add avatars to their apps. It’s free, incredibly simple to implement, and removes a lot of the hassle around getting avatar support into your web/windows app.

Adding Gravatar support to an application is pretty simple. Can you get a users email address? Can you MD5 said email address? Can you make an HTTP GET? BANG. You sir, or madam, can have Gravatars.

This week for the W.O.M.M. code sample I’d like to show how I integrated gravatar support into an Asp .Net MVC application.

How Gravatar Works In A Nutshell

Gravatar is a free service where you sign up and link images to one or more email addresses that you provide.

Once you link an image to an email address, any application that supports getting an image over the internet can show your Gravatar by making a request to a special URL. This URL is generated by combining an MD5 hash of your email address with some other parameters and the end result is a link to your Gravatar image.

IE: the link to my Gravatar on the right of this page is:

So 15559d868ec27b8583f42116a6b96c14 is the hash of my email address – don’t worry it’s a one-way hash. The “s” parameter is the size of the image that I want, in this case 140 pixels.

That is pretty much it as far as how the system works, but if you want to read more, check out Gravatar’s implementation documentation.

The Goal

What I wanted was an HtmlHelper extension method that I could use in my view pages to create an IMG tag with the correct Gravatar URL. After looking at the documentation on Gravatars “How the URL is constructed” page, I decided my helper extension should support the following:

Avatar Size (the “s” parameter)
When making a Gravatar URL you can specify a specific size for the Gravatar image. The size can be anything from 1 to 512 pixels, but the default is 80.

Default Avatars (the “d” parameter)
If the email address you are using doesn’t have any Gravatars setup, Gravatar will generate one for you by default. You can choose from 3 predefined Gravatar types or you can include a URL to a custom avatar of your own. The predefined Gravatar types are Identicon, Wavatar, and Monsterid.

Rating (the “r” parameter)
This wasn’t a requirement for what I was working on, but you can designate the maximum “rating” of the avatars that Gravatar will generate. The accepted values are “g”, “pg”, “r”, and “x” and they are inclusive, so specifying “r” will allow “g” and “pg” rated Gravatars to be generated. Gravatars that are rated “x” will be returned as one of the predefined avatars above. The default rating is “g”.

The Code

Okay, so now I know what I need to support. Now it’s just a matter of getting the code to do this. Let’s take a look at the class file I used to get this done.

namespace System.Web.Mvc
{
    using System;
    using System.Web.Routing;
    using System.Web.Security;

    public enum GravatarDefaultTypes
    {
        Identicon,
        Wavatar,
        Monsterid,
        Custom
    }

    public static class GravatarExtension
    {
		public static string Gravatar(
			this HtmlHelper hh,
			string emailAddress,
			int size,
			GravatarDefaultTypes defaultType,
			string customImageUrl,
			RouteValueDictionary htmlAttributes)
        {
            var tagBuilder = new TagBuilder("img");
            string url = "http://www.gravatar.com/avatar/{0}?d={1}&s={2}";

	    // thanks to jon galloway for this one-liner!
            // http://www.eggheadcafe.com/aspnet/how-to/141740/adding-gravatars-to-your.aspx
            string hash = FormsAuthentication
				.HashPasswordForStoringInConfigFile(emailAddress, "MD5");
            string defImg = defaultType.ToString().ToLower();

            if (defaultType == GravatarDefaultTypes.Custom)
            {
                defImg = System.Web
					.HttpUtility
					.UrlEncode(customImageUrl);
            }

            url = String.Format(
                url,
                hash.ToLower(),
                defImg,
                size.ToString());

            tagBuilder.MergeAttributes(htmlAttributes);
            tagBuilder.MergeAttribute("src", url);

            return tagBuilder.ToString(TagRenderMode.Normal);
        }
    }
}

So you can see I’m not storing the hash of the email address, instead I am going to pass in the unaltered string. I didn’t want to have another piece of data to update when the user changed their email address so the Gravatar() method takes an email address and encodes it using a call to FormsAuthentication.HashPasswordForStoringInConfigFile(), which is awesome ( Thanks Jon, you rock!).

Also, I’m not sure if this is a no-no or what, but I did put the extension class under the System.Web.Mvc namespace. This was mainly a convenience (read: laziness) thing and can be easily changed.

Alright so we have some code now, let’s take a look at how it can be used in our views.

    <%= Html.Gravatar(
        	Model.Email, // the email address
        	50, // size, in pixels of the avatar
        	GravatarDefaultTypes.Identicon,
        	null,
        	new RouteValueDictionary(new {
        		style = "vertical-align: middle;"
        	})
    )%> 
     <%= Model.UserName %> 

Let’s see how that looks.

Booyah, avatar support in 55 lines of code. As always, if I screwed up or there is a better way to do this, please let me know.

asp.net · c# · MVC · Open Source