Christopher Bennage : MVC

Things I’d Like To Present

Christopher Bennage — Fri, 08 Jan 2010 11:32:00 GMT

In case you are not familiar with MIX, it is a conference from Microsoft focusing on the collaboration of design and development. Admittedly, the sessions tend to favor the developer, but there is always excellent design and UX content.

There was an open call for presentations this year and the community gets to choose which of the proposals will be selected. There are a number of excellent proposals and I encourage you to go check out the list and vote for the sessions that you are genuinely interested in. (Even if you won’t be attending, the sessions will be broadcast.)

Here are some sessions that I proposed for MIX10:

Cross Compiling Games for Silverlight & XNA

Our friend and Silverlight MVP, Bill Reiss, has created an incredible library that enables you to cross compile XNA games for Silverlight. The library is called SilverSprite and we feature it on Silver Arcade. (Wow, that’s a lot of ‘silvers’ in one paragraph.)

In this session, we’d write a simple game for XNA (discussing some of the basic of game dev along the way) and then port the game over to Silverlight.

This is an area where I wish I could spend more time. I love game development, but it’s always taking a back burner to other projects.
[vote for this]

LinqToSQL and EntityFramework Profilers: Case Study

If you aren’t already familiar with the UberProf suite of ORM profilers, you can read tales of the development on Ayende’s blog. Rob and I built the UI side of the application, and we learned a lot in the process. I’d like to do a talk were we discuss the challenges of the project, how we solved them, and what we did wrong.

Yes, NHProf will be included too. (I submitted a case study for it last year, and it didn’t get picked. I have to sneak it in).

A few interesting aspects:

we built this using MVVM, but well before Caliburn reached maturity.
the four separate apps (NHProf, EFProf, L2SProf, HProf) all use a single code base.
we’re about to port the project from WPF to Silverlight.

[vote for this]

Silver Arcade: Case Study

This is a presentation that Rob and I have made a couple of times. Most recently at the Orlando .NET Users Group. We walk through the actual code for Silver Arcade explaining the philosophy, design choices and mistakes we made along the way.

For MIX, we would focus more design and UX choices, such as the separation of the behaviors from the views. However, we like to have a lot of audience interaction and tend to follow where ever the questions led (especially those leading questions that Scott Densmore tends to ask).

Silver Arcade is also interesting because we deliberately used a number of newer hipper technologies; including Azure, ASP.NET MVC, jQuery, MEF, NHibernate and so on.
[vote for this]

Thanks!

thinking out loud: asp.net mvc & nhaml

Christopher Bennage — Fri, 02 Oct 2009 20:48:00 GMT

I’ve been playing around with the view engine nhaml and asp.net mvc. At the same time, I’m playing around with some architectural ideas in hope to benefit future projects.

I’m not doing any fancy yet, but I thought that it might be interesting to show you a couple of things to see what you think. Bear in mind, this is my sandbox code. I also suspect that I’m reinventing some wheels.

The context here is a page that allows a user to register for an account on the site.

First, the view looks like this:

%h2 Create Account

%form{method="post"}
  = Html.FormField<OpenAccount>(x=>x.AccountName)
  = Html.FormField<OpenAccount>(x=>x.EmailAddress)
  = Html.FormField<OpenAccount>(x=>x.Password)
  
  %input {type="submit" value="Save"}
  %button {onclick="javascript:history.back()" type="button"} Cancel

OpenAccount is my view model. (I hate how we’ve overloaded these terms.)

I really like the succinctness of the nhaml, though I’m not ready to commit to it 100%. Spark is very attractive to me as well.

Html.FormField is an extension method I wrote. I’m toying with the idea of having it emit a <lablel /> paired with the <input />. Part of my motivation here is standardizing all of the label/inputs in my forms as well as a few experimental ideas about localization.

It’s rather naive at the moment, but here is the helper:

public static string FormField<T>(this HtmlHelper helper, Expression<Func<T, string>> property)
    where T : class, ICommand
{
    var model = helper.ViewData.Model as T;
    if (helper.ViewData.Model != null && model == null) throw new InvalidOperationException();

    var expression = (MemberExpression)property.Body;
    var name = expression.Member.Name;

    var value = (model == null)
                    ? null
                    : property.Compile().Invoke(model);

    return helper.TextBox(name, value);
}

Yeah, I hardcoded to a textbox for the moment. As I said, this is just a sandbox spike.

Finally, the associated controller action looks like this:

[AcceptVerbs(HttpVerbs.Post)]
public ActionResult Create(OpenAccount form)
{
    var result = _backend.Execute(form);

    return result.Success
               ? (ActionResult) RedirectToAction("WhateverIsNext")
               : View(result);
}

I’m treating the incoming form as a command. The _backend is responsible for processing the command. The command is just information necessary to execute the command, not the logic to execute it. The result I’m getting back is actually an instance of the same command with information attached by the backend (e.g., did the command execute correctly, what were the validation errors). It’s not exactly SRP, however I’m influenced by the simplicity of RoR here.

One more interesting bit. I really don’t like having actions in my controller that do nothing other than render the view. For example:

[AcceptVerbs(HttpVerbs.Get)]
public ActionResult Create()
{
    return View();
}

So instead, I created a base controller that does this:

public class ControllerBase : Controller
{
    protected override void HandleUnknownAction(string actionName)
    {
        try
        {
            View(actionName).ExecuteResult(ControllerContext);
        }
        catch (InvalidOperationException e)
        {
            //show the error or something
        }
    }
}

The Influence of MVC on my WPF

Christopher Bennage — Wed, 06 May 2009 19:48:01 GMT

I was introduced to MVC as a pattern for Web development through Castle MonoRail. From there I studied a bit of Ruby on Rails (not enough) as well as the general philosophy of 37signals.

As I mentioned before, I thought I was moving away from Web development. However, the dive into ASP.NET MVC that Silver Arcade brought about has roped me back in.

My work during the day (and some nights too) is still WPF though. I’ve discovered that MVC thinking has seeped into my WPF development.

Convention Over Configuration

A characteristic of most MVC frameworks is Convention Over Configuration. In short, it means that your “environment” makes assumptions about what you want and that you only need to be explicit about the exceptions.

A practical example of this is the way that the View for an Action is inferred from the name of the Controller and Action. After creating your Action, you create a folder for the controller and and view that matches the name of the action. It just works. If you need to make exception, you can.

An Example in WPF

In our WPF development we employ a number of Separated Presentation patterns. One of the more common patterns we use is MVP (in particular, the flavor of MVP implemented in Caliburn, which is really Supervising Controller).

Imagine a simple contact manager application. We can add new contacts, view a list of all contacts, and open individual contacts for viewing or editing. We can open as many individual contacts as we like.

Let’s say that there are buttons to open up the “Add New” view and “All Contacts” view. We can open an existing contact by double-clicking on them in the “All Contacts” view.

My solution setup for this imaginary (and highly contrived) application might look like this.

ApplicationPresenter would be the root object of my UI. It would have an ObservableCollection of IPresenter that would be bound to a TabControl in Shell.xaml. Likewise, ApplicationPresenter will have a CurrentPresenter of IPresenter that will be bound to the SelectedItem on the TabControl.

Shell.xaml is my only window in this example. All of the other views are user controls. I named it “shell” because I think of it as the outermost level of the views. Shell’s data context is set to ApplicationPresenter.

I’m not going to dive too much deeper into this, because I want to get to my real point.

My presenters don’t know anything about their views. It’s up to data binding to render each presenter with the correct view. This means that I need to create data templates for each of the presenters. Not such a big deal in a small application, but it can get tedious as the application grows.

Hmmm… This structure is beginning to look a lot like an MVC app. Perhaps I can have it automatically infer my data templates for me?

Some Code

Yes we can. Here’s a very naiveté bit of code that will do just that. It makes some big assumptions:

all of your presenters implement IPresenter
all of your presenters are in a namespace containing “.Presenters”
all of your views are in an analogous namespace containing in “.Views”

Again, this is not production ready code, just my spike to prove the idea works. Please feel free to make suggestions.

public static class MvpConfiguration
{
    /// <summary>
    /// Creates a set of data templates pair to presenter classes based on naming conventions.
    /// </summary>
    /// <remarks>If a data template is already present in the resources, then it is skipped.</remarks>
    /// <param name="resources">The ResourceDictionary that the data templates for the views will be added to.</param>
    public static void InferViewsFromPresenters(ResourceDictionary resources)
    {
        var lookup = MatchPresentersToViews();

        foreach (var pair in lookup)
        {
            var template = CreateDataTemplate(pair.Value, pair.Key);
            if (resources.Contains(template.DataTemplateKey)) continue;
            resources.Add(template.DataTemplateKey, template);
        }
    }

    private static Dictionary<Type, Type> MatchPresentersToViews()
    {
        var presenters = from type in Assembly.GetExecutingAssembly().GetTypes()
                         where typeof (IPresenter).IsAssignableFrom(type)
                         select type;

        var first = presenters.FirstOrDefault();
        if (first == null) throw new Exception("I expected to find at least one presenters!");

        string viewNamespace = first.Namespace
            .Replace(".Presenters", ".Views");
        viewNamespace = viewNamespace.Substring(0, viewNamespace.IndexOf(".Views")+6);
        //yeah, that was hackish

        var views = from view in Assembly.GetExecutingAssembly().GetTypes()
                    where !string.IsNullOrEmpty(view.Namespace)
                          && view.Namespace.StartsWith(viewNamespace)
                    select view;

        var table = new Dictionary<Type, Type>();

        foreach (var view in views)
        {
            var presenter = GetPresenterForView(view, presenters);
            if(presenter == null) continue;

            table.Add(presenter,view);
        }

        return table;
    }

    private static Type GetPresenterForView(Type type, IEnumerable<Type> presenters)
    {
        string name = type.Name.Replace("View", "Presenter");
        var presenter =
            presenters.Where(p => p.Name == name).FirstOrDefault();
        return presenter;
    }

    private static DataTemplate CreateDataTemplate(Type viewType, Type dataType)
    {
        var template = new DataTemplate(dataType);

        var factory = new FrameworkElementFactory(viewType);
        template.VisualTree = factory;
        return template;
    }
}

To use this, in your App.xaml.cs within OnStartup() add:

MvpConfiguration.InferViewsFromPresenters(Resources);

What do you think? Am I totally nuts?

Oh, and I should also point out that FrameworkElementFactory is actually deprecated. :-( Caveat emptor.

Shared Hosting & The Bleeding Edge

Christopher Bennage — Thu, 25 Sep 2008 15:58:56 GMT

So we've been working on a web project for a friend's startup company (I don't like doing work for my friends, but that's a different matter). Since he has no technological preference and since we are such bleeding edge kinda guys (the Achilles' Heel of ALT.NET?), we decided to build the site with the following:

ASP.NET MVC
MVC Contrib
Castle Windsor
NHibernate
Fluent NHibernate (this rocks)
NHibernate.Linq (part of NHibernate Contrib) (this rocks as well)

Castle and NHibernate (as you likely know) are mature products. So in keeping with our bleeding theme, we decided to use the trunk for these instead of the most recent release.

Despite all the blood, the development process was pretty smooth. I had a minor learning curve with MVC and a slightly less minor curve with some of the other bits, but all in all, it went well. (I am omitting a lengthy struggle writing a query because it is embarrassing how my ~~SQL~~ query writing skills have atrophied.)

Ok, well, the time to deploy to the production site comes. Remember I said that this was a friend's startup and there is little money to go around, so the production site is going be hosted at CrystalTech. I deploy the site, and -- nothing. It doesn't work in the shared hosting environment.

We're not used to having our applications run in a shared environment; most of our clients have dedicated hardware. If I had spent any amount of time thinking about it, I would have realized the forthcoming pain.

Unfortunately, I will not be able to present you with a step-by-step way to make the pieces fit, the pain has blurred my memory. However, I will give you a general outline that I believe you will find helpful.

Windows 2008, IIS 7, and Routing

Most shared hosting environments are not running on Windows 2008 and that means no IIS 7. If you are using routing with MVC to get your Rails-style urls (and who isn't?), routing is not going to work without IIS7. You can still get your MVC app to run, but you have to call the view explicitly (something like \root\views\home\index.aspx).

I didn't really think about this because the web server built-in to Visual Studio handles the routing correctly. (Even though I've run into a similar problem using MonoRail years ago).

CrystalTech (at the time of writing) only has one server running IIS 7 and only one plan available for that server. I didn't think about this when my buddy signed up for the account, and I had to ask them to relocated the site to the 2008 server.

Drew suggested that I ask the host to do a wildcard mapping instead of moving the site over to IIS 7. This would work, but CrystalTech won't to do it. I had actually tried to get them to do this a while back when I first started learning MonoRail.

Partial Trust

Shared hosting environment have to restrict security. If not, you could write your application to do bad things to their server. Limited trust can prevent you from using lots nifty tricks that you may be used to. For example, application running under Medium Trust cannot use reflection. Luckily, many hosts don't lock you down that tight.

The real problem is that by default strongly named assemblies cannot be called by assemblies executing under less than Full Trust. For example, the Castle assemblies are strongly-named and thus they are not callable by your application in most typical shared environments.

The solution, if you have access to the source, is to use AllowPartiallyTrustedCallersAttribute. Just slap that bad boy into your AssemblyInfo.cs and your strongly named assembly can then be called.

Fortunately, Castle makes this easy. You execute the build script with something like this:

nant -t:net-2.0 -D:assembly.allow-partially-trusted-callers=true release

I believe NHibernate has the attribute by default, but any other assembly that is strongly-named will need this attribute, and then you will want to recompile all the dependencies after adding the attribute.

The Nutshell

If you have to use a shared hosting environment, talk to the host. Tell them what you are planning on doing. Secondly, visit the forums for the host and search them to see if someone is doing what you plan to do.