Around 30 Minutes in when discussing SEO Optimizations, they show a great tip how to enforce canonical URLs. Unfortunately, they do it by modifying the Response object directly. Basically the code looks like

// This snippet doesn't make much sense if you haven't
// watched the Episode, sorry.
public ViewResult Details(int id)
{
    //snipped some parts
    EnforceCanonicalUrl(jobAd.DetailsRouteValues());
    return View(jobAd);
}

private void EnforceCanonicalUrl(RouteValueDictionary routeValues)
{
    if(someCheckFails){
        Response.RedirectLocation = someLocation;
        Response.StatusCode = (int)HttpStatusCode.MovedPermanently;
        Response.End();
    }
}

This doesn't follow the MVC pattern, and the speaker even acknowledges it in the video as it makes unit testing hard. The proper way is to return an ActionResult from the ControllerAction instead. As I happen to have already written a PermanentRedirectResult, my suggestion to improve this code is this:

public ActionResult Details(int id)
{
    //snipped some parts
    var enforcedResult = EnforceCanonicalUrl(jobAd.DetailsRouteValues());
    // As View and enforcedResult have different types, I cannot use the ?? operator
    if(enforcedResult != null) return enforcedResult;
    return View(jobAd);
}

private PermanentRedirectResult EnforceCanonicalUrl(RouteValueDictionary routeValues)
{
    if(someCheckFails){
        return new PermanentRedirectResult(canonicalPathAndQuery);
    } else {
       return null;
    }
}

So I changed the return type of the controller action to ActionResult instead of ViewResult, and I gave EnforceCanonicalUrl a return type. This function now either returns null or a PermanentRedirectResult, and the controller action now checks for it. There are of course more ways to refine it, but it is in line with the ASP.net MVC pattern of having Controller Actions return ActionResults instead of modifying the Response directly.

Are you an Open Source Developer, working on a WebForms project? Did you ever ask yourself "Is this really the best way to do this"? Or were you ever curious about ASP.net MVC and just never got around to do it? Or would you just like to compare ASP.net MVC to what you know about WebForms?

I'm giving away one (1) coupon for TekPub's ASP.net MVC 2 video series - a US$ 28.00 value! What I want in return? Not much - I just want to see that you are an Open Source developer working on a WebForms project. I don't care if you use SourceForge, CodePlex, GitHub, Google Code or your own website. I don't care if it's MS-PL, GPL, MIT. I don't care if you have 1 or 1 Million users. I don't care if it's for pharmaceutical project management or tracking water quality in New Zealand. Update: TekPub decided to throw in four (4) additional coupons. Thanks guys!

Criteria

• ASP.net WebForms project - any version of .net from 1.0 to 4.0 or Mono
• Open Source under an OSI License
• Code must be downloadable freely and without sign up (having to use a Source Control Client is acceptable)
• Project must be working - it doesn't need to be mature, finished and polished, but it needs to be something one could download and actually run
• Project Owner or Contributor must add a link and a valid e-Mail to the comments of this article
• Only one Entry per project - multiple entries will be filtered to only count once
• Deadline: Friday, January 15 2010, 8 pm PST

What does "Code must be downloadable" mean?
An open source project needs source code - there are a few projects out there that are in a "Preview" state where the demo-app and project site is up, but the source code is listed as "coming soon"... Your code needs to be downloadable, without having to sign up for any site. It's okay if it's read-only and it's okay if I have to use a source control client to download it (e.g., svn export, git clone...) and it's okay if it's .rar, .tar.bz2, .zip, as a bunch of single files or in any other common format.

What is a "working project"?
This is kind of a fuzzy and unspecific point, I agree. Working does not mean it has to be fully functional, mature and finished. It just means that it's core functionality should be implemented to a point one can actually use your project - for example, a project management system should be able to manage a project, but if e-Mail notification doesn't work and if your CSS is still a "High Contrast Hot Dog Stand to see which Elements actually apply", that's fine.

I mainly have that rule because I want to reach out to people who really use WebForms.

No Obligations from your side
Should you win, you have no obligation towards me to actually to anything with ASP.net MVC. You do not have to change your existing project and you do not have to create a new (Open or Closed Source) MVC Project. This is not a Crusade initiated by me, I just want to give a WebForms developer a chance to take a deep dive into MVC - you draw your own conclusions and make your own decisions after that.

Fine Print
Disclaimer: I'm not affiliated with TekPub, Microsoft or anyone else - I'm just doing this as an experiment and because I'm curious if there's OSS WebForms Projects whose contributors are interested in ASP.net MVC. Your e-Mail address will only to pick a winner and (that's how WordPress work) to resolve a Gravatar. It will not be published or shared with anyone else, except with TekPub if you win one of the 4 coupons they give away. You will need to create a free account with TekPub if you win. No purchase necessary. I reserve the right to end this Giveaway early or without selecting a winner.

<myApp injectModule="MyApp.MyAppTestNinjectModule">

The reason I am doing that is because I use Ninject 2 to do dependency injection on my ASP.net MVC 2 app.. Basically I have multiple database backends for my application and the TestNinjectModule implements an in-memory List so that I can develop the application without caring about data persistence yet.

Ninject uses so called Modules that specify the bindings. I have two modules, and my Test Module looks like this:

public class MyAppTestNinjectModule : NinjectModule
{
    public override void Load()
    {
        // As the Test Repositories usually use internal Lists, they need to be Singleton
        Bind<IProjectRepository>().To<TestProjectRepository>().InSingletonScope();
        Bind<INoteRepository>().To<TestNoteRepository>().InSingletonScope();
    }
}

So everytime Ninject sees IProjectRepository, it knows that it should give me the class TestProjectRepository. (Bonus Tip: When using List<T> as data storage, use InSingletonScope to make sure one instance is shared throughout the entire Application) My second Ninject module looks identical, except that I use MSSqlProjectRepository.

I wanted to have this configurable so that I can easily change between them or add more. Previously, creation of the Kernel (CreateKernel in global.asax) looked like this:

protected override IKernel CreateKernel()
{
    return new StandardKernel(new MyAppTestNinjectModule());
}

See that call to new MyAppTestNinjectModule()? If I want to change it, I need to recompile and redeploy the App.

The change itself is straight-forward if you know a bit of reflection. Here is what we need to do:

1. Get the name of the Class as a string
2. Find the Type that has this name
3. Instantiate it
4. Pass the instance to the StandardKernel constructor

Here is the overly commented code to do that:

protected override IKernel CreateKernel()
{
    // MyAppSettings is the class that reads the setting from
    // web.config
    string moduleName = MyAppSettings.InjectModule;

    // Type.GetType takes a string and tries to find a Type with
    // the *fully qualified name* - which includes the Namespace
    // and possibly also the Assembly if it's in another assembly
    Type moduleType = Type.GetType(moduleName);

    // If Type.GetType can't find the type, it returns Null
    NinjectModule module;
    if (moduleType != null)
    {
        // Activator.CreateInstance calls the parameterless constructor
        // of the given Type to create an instace. As this returns object
        // you need to cast it to the desired type, NinjectModule
        module = Activator.CreateInstance(moduleType) as NinjectModule;
    }
    else
    {
        // If the Type was not found, you need to handle that. You could instead
        // initialize Module through some default type, for example
        // module = new MyAppDefaultNinjectModule();
        // or error out - whatever suits your needs
        throw new MyAppConfigException(
             string.Format("Could not find Type: '{0}'", moduleName),
             "injectModule");
    }

    // As module is an instance of a NinjectModule (or derived) class, we
    // can use it to create Ninject's StandardKernel
    return new StandardKernel(module);
}

<myApp injectModule="MyApp.MyAppTestNinjectModule">
  <localeSettings longDateFormat="MM/dd/yyyy HH:mm:ss" />
</myApp>

So I have "myApp" as my main element, with an attribute "injectModule" and a child element "localeSettings". Child Elements allow me to group my settings even more, as I could have in theory dozens of settings, and having them all as attributes to the main myApp-element is messy.

Now, in order to use the myApp element, I need to tell .net about it in the <configSections> section of the web.config. There are two options: section and sectionGroup. I thought that sectionGroup is the correct one, but sectionGroups cannot have attributes, only child Elements. So they are just containers. On the other hand, sections can have attributes and child elements. I don't exactly know why one would use sectionGroup, but I haven't investigated on this too much as it was unsuitable.

So we need to create a section by adding this to the configSections xml element:

<section name="myApp" type="MyApp.MyAppConfigurationSection"/>

What does this do? It tells ASP.net that we will have an xml Element called myApp, and that this is handled though the MyApp.MyAppConfigurationSection Class. How does this class look like?

public class MyAppConfigurationSection : ConfigurationSection
{
    private static ConfigurationPropertyCollection _properties;
    private static ConfigurationProperty _propInjectModule;

    static MyAppConfigurationSection()
    {
        _propInjectModule = new ConfigurationProperty("injectModule", typeof (string),
                                                      "MyApp.MyAppNinjectModule",
                                                      ConfigurationPropertyOptions.None);
        _properties = new ConfigurationPropertyCollection { _propInjectModule };
    }

    protected override ConfigurationPropertyCollection Properties
    {
        get
        {
            return _properties;
        }
    }

    public string InjectModule
    {
        get { return this[_propInjectModule] as string; }
        set { this[_propInjectModule] = value; }
    }
}

Whoa, scary... But let's look at this piece by piece. First of all, your class inherits from ConfigurationSection. This is the base class in the .net Framework to represent a section.

We start by defining a ConfigurationProperty named _propInjectModule and initializing it in the static constructor. The four parameters to the new ConfigurationProperty constructor are:

1. The name of the attribute/property as it appears in the web.config later
2. The Type of the property
3. The default value - this is important if the parameter is not set in the web.config
4. Options for this Attribute. I have not checked what IsKey and IsDefaultCollection do, but if IsRequired is set then it has to be set in the web.config

So in a nutshell, _propInjectModule is a string that defaults to MyApp.MyAppNinjectModule and is represented in the web.config as injectModule.

The ConfigurationPropertyCollection is needed by .net for some internal plumbing I guess - I haven't checked on it's exact purpose.

Finally, we have the public string InjectModule Property. This is used to access the actual value of the Property. If it's not set in the web.config, the Default value is returned instead. As this is using the Indexer, I'm guessing that this is why the _properties is important.

So, how do we use it? There are multiple options, but I found having a static function most useful:

public static MyAppConfigurationSection GetMyAppConfig()
{
    var result = WebConfigurationManager.GetWebApplicationSection("myApp") as MyAppConfigurationSection;
    return result ?? new MyAppConfigurationSection();
}

This will try to get the myApp Section of the web.config. If this returns null (i.e. if there is none), then it will just initialize a new instance of the class so that we get it in any case. This works because we have default values for all Properties (Well, there is only one for now). If you want to have required Properties, you possibly need to do something harsh on that.

Okay, so try accessing MyAppConfigurationSection.GetMyAppConfig().InjectModule and you should get either the Default Value of "MyApp.MyAppNinjectModule" or whatever you have specified in the <myApp injectModule="MyApp.MyAppTestNinjectModule"> element of your web.config.

So far, so good. But what about the nested localeSettings element? If you just add it to the web.config, you should get an error message explaining that it couldn't parse this element. Let's wire it up.

If you want child elements to a ConfigurationSection, you have to use a ConfigurationElement. I do not exactly know what the real difference between a Section and an Element is and why we need three different layers of nesting (sectionGroup - section - element), but I'm sure the Framework designers had something in mind here.

Let us first implement the .net Class for the ConfigurationElement:

public class MyAppLocaleSettingsElement : ConfigurationElement
{
    private readonly static ConfigurationPropertyCollection _properties;
    private readonly static ConfigurationProperty _propLongDateFormat;

    protected override ConfigurationPropertyCollection Properties
    {
        get
        {
            return _properties;
        }
    }

    static MyAppLocaleSettingsElement()
    {
        _propLongDateFormat = new ConfigurationProperty("longDateFormat", typeof (string),
                                                        "ddd, MMM dd, yyyy HH:mm",
                                                        ConfigurationPropertyOptions.None);
        _properties = new ConfigurationPropertyCollection { _propLongDateFormat };
    }

    public string LongDateFormat
    {
        get { return this[_propLongDateFormat] as string; }
        set { this[_propLongDateFormat] = value; }
    }
}

As you see, this works exactly the same as a ConfigurationSection: We have a string property with a Default Value and a public Property.

What we need to do now is to wire it into the MyAppConfigurationSection class. Here are the changes to the class:

public class MyAppConfigurationSection : ConfigurationSection
{
    private readonly static ConfigurationProperty _propLocaleSettings;
    static MyAppConfigurationSection()
    {
        _propLocaleSettings = new ConfigurationProperty("localeSettings", typeof(MyAppLocaleSettingsElement),
                                                        new MyAppLocaleSettingsElement(),
                                                        ConfigurationPropertyOptions.None);
        _properties = new ConfigurationPropertyCollection { _propInjectModule, _propLocaleSettings };
    }
    public MyAppLocaleSettingsElement LocaleSettings
    {
        get { return this[_propLocaleSettings] as MyAppLocaleSettingsElement; }
    }
}

We created a new property that is represented through the "localeSettings" element in the xml. For the default value, I am returning a new instance - again, this works because I specified default Values. Finally, I have a new Property LocaleSettings which exposes the child element through the getter.

To access this, we can do MyAppConfigurationSection.GetMyAppConfig().LocaleSettings.LongDateFormat and either retrieve the default value or the one specified in the web.config.

Here is a recommendation though: I would recommend adding a separate Settings class that your application uses. This class sits between the MyAppConfigurationSection class and your application (it serves as a Facade). Why? To make sure that you can change your configuration structure without making too many breaking changes. Maybe I decide that "injectModule" shouldn't be an attribute to the myApp element and instead I want to add a child Element? Or maybe I don't want to use web.config at all and instead use a SQL Server database or a Web Service? Or maybe all of a sudden I decided that injectModule is a required Parameter, which means I now need to handle the case where the user hasn't added a myApp element to his web.config?

Here is one example of Settings class:

public static class MyAppSettings
{
    private static readonly MyAppConfigurationSection Config;

    static MyAppSettings()
    {
        Config = MyAppConfigurationSection.GetMyAppConfig();
    }

    public static class LocaleSettings
    {
        public static string LongDateFormat
        {
            get
            {
                return Config.LocaleSettings.LongDateFormat;
            }
        }
    }

    public static string InjectModule
    {
        get { return Config.InjectModule; }
    }
}

I'm using nested classes to group it, but I can now change the MyAppConfigurationSection class (or completely remove it) and only need to do changes in the MyAppSettings Facade-class without affecting the rest of my application.

If you really want to dig deep into this, check out these three links (thanks to marc_s):

• Unraveling the mysteries of .NET 2.0 configuration
• Decoding the mysteries of .NET 2.0 configuration
• Cracking the mysteries of .NET 2.0 configuration

It has improved. But not that much. Software like WordPress is still miles ahead, and I am not even talking that much about functionality here. I'm talking about some fundamental things like ease of installation. Or about the fact that Settings in the WordPress Control Panel are actually *explained*. Or the fact that I can put in RAW HTML into my postings WITHOUT WordPress destroying it. Sure, if I switch between WYSIWYG and HTML View, there may be a breaking conversations when using funky HTML, but if I stay in HTML, it just works. If I put in Garbage, then WP will output garbage.

I'm not even talking about the Theme and Plugin momentum that WordPress has. I am really just talking about a Software that is easy to install, runs on my hosted server and allows pushing of some Content. Is that asked too much? Sadly, yes. I don't want to be too harsh, hence I will not name the tools I've tried (there were 4). I don't want to blame developers who are really trying to do something for issues that lie within the framework. The ASP.net infrastructure has a lot of advantages over PHP, but as good as stuff like Web.config, Medium Trust and SQL Connection Strings is, it's adding more complexity that developers seem to not try to take away from the end user.

I don't know if this is the fault of the ASP.net Webforms model or if the .net OSS Community is smaller or whatever. I've now decided to tackle something that I have on my ToDo-List since writing that post in November 2007, I've decided to write my own blog software. I want to encounter the problems that the people who are creating it have, I want to run it in a production environment (Dogfooding, so to say). The recent release of ASP.net MVC was the final bit that removed all excuses for not doing it.

I will run into a lot of issues. I want to learn and use TDD, DI and ORM, and I have experience in none. I will do a lot of refactoring, and a lot of breaking changes and braindead mistakes. But I don't want to be a complainer anymore when I have the opportunity to change it.

I don't want to announce too much because it's still in the early stages, but it will be open source (Ms-PL) and hosted on Codeplex.

In Version 02 of Rick, I have added a custom ActionResult to perform a HTTP 301 redirect instead of the default HTTP 302 one. You can get the Source Code on http://www.codeplex.com/rick, and you can watch the tutorial video on Vimeo. Topics include a short overview of HTTP 301 vs. 302 and how to actually create a custom ActionResult.

Rick Version 02 - Building a custom ActionResult to perform a HTTP 301 redirect from Michael Stum on Vimeo.

I wanted to kill three birds with one stone, so I decided to make this a standalone project. The three birds are 1. the actual URL shortening Service, 2. a project where I can play with all the newest technologies, 3. a project that allows me to create some tutorial videos.

The name of the Project is "Rick", and it's source code is hosted on CodePlex, at http://www.codeplex.com/rick

Version 01 was just released, and it actually fully works already: You can put in a long URL, get a short URL back, put that short URL in a browser, and get redirected to the original URL. And the best of all: I have created a Tutorial video for that, which you can watch online or download (download requires free registration with Vimeo). Granted, Version 01 is ugly, has no error handling and lacks a lot of features, but I am actually going to improve it over the next few weeks, making it more robust and I also plan to add more technologies to it, for example Windows Azure or Silverlight.

For your convenience, here is the video:

Rick Version 01 - Building a URL Shortening Service in ASP.net MVC from Michael Stum on Vimeo.

Please let me know what you think and what you would like to see in the future.

So here is my little PermanentRedirectResult:

public class PermanentRedirectResult : ActionResult
{
    public string Url { get; set; }

    public PermanentRedirectResult(string url)
    {
        if (string.IsNullOrEmpty(url))
        {
            throw new ArgumentException("url is null or empty", "url");
        }
        this.Url = url;
    }

    public override void ExecuteResult(ControllerContext context)
    {
        if (context == null)
        {
            throw new ArgumentNullException("context");
        }
        context.HttpContext.Response.StatusCode = 301;
        context.HttpContext.Response.RedirectLocation = Url;
    }
}