I’ve been very quiet recently. (I’m trying to not be so loud, Scott. ) You see, I’ve been writing a lot of ASP.Net code for a site I’m working on. And, to be honest, I’ve been having a lot of trouble. The source code for .Net has been very helpful, and I’ve learnt a lot about what’s going on under the covers of ASP.Net because of it.

(Note: I won’t comment here on the quality of the code I’ve found – I’ll leave that up to you to judge. But in any case, I’ve been trying to build on top of it.)

One thing I’ve found to be important is the reliance on Web Controls. (It’s got something to do with javascript libraries, but that’s another story.) Getting away from the "standard" way to do ASP.Net isn’t easy though. Even the ninjas on the ASP.Net MVC team seem to be having trouble. However, with the magic of lambdas and extension methods in C#, I think I might have just about managed to get something usable. I thought I’d publish my work here, and see what comments I got.

I think it’s best to start with what my ASP.Net code looks like once I’ve got everything working. (Notice I still have some Web Controls in there, but that’s because I’ve not worked out how to do sorting of data without web controls yet.)

The inspiration for this was taken from the improvements made to NVelocity by the gurus on the Castle Project. I thought it looked great, and I’d like something similar, but I didn’t really want to learn a whole new scripting language and integrate it into my working environment just for rendering a bit of HTML. So I built some C# classes to do a similar thing for me instead. It’s not as nice as NVelocity, but it’s okay for now.

Warning: The following code may contain statements of a disturbing nature to more sensitive readers. We cannot be held responsible for any confusion, delusion or mental illness caused by this code.

It starts by taking a collection of Task objects, and calling the extension method "ForEach" on them:

<% Tasks.ForEach(sections => {
   sections.NoData = tasks => {
%>
   <p>
   Hey, you've got nothing to do.</p>
   <p>
<%
   };
   sections.BeforeAll = tasks => {
   %>
  <table class="task-list">
    <tr class="task-list-header">
      <th>
        <asp:LinkButton runat="server" CommandName="Sort" CommandArgument="StartDate"
          Text="Started" />
      </th>
      <th>
        <asp:LinkButton runat="server" CommandName="Sort" CommandArgument="DueOn"
          Text="Due" />
      </th>
      <th>
        <asp:LinkButton runat="server" CommandName="Sort" CommandArgument="Priority"
          Text="Priority" />
      </th>
      <th>
        <asp:LinkButton CssClass="task-description" CommandName="Sort" CommandArgument="Title"
          Text="Description" runat="server" />
      </th>      <th>
      </th>
    </tr>
   <%
   };
     sections.Before = task => {
    %>
    <tr class="<%= this.tableCssClasses.Next() %>">
    <%
   };
   sections.Each = task => {
    %>
    <td>
      <div class='calendar calendar-icon-<%= task.StartMonth %>'>
        <div class="calendar-day">
          <%= task.StartDayOfMonth %></div>
      </div>
    </td>
    <td>
      <div class='calendar calendar-icon-<%= task.DueMonth %>'>
        <div class="calendar-day">
          <%= task.DueDayOfMonth %></div>
      </div>
    </td>
    <td>
      <%= task.Priority %>
    </td>
    <td class="task-title">
      <a href='<%= Href.For("~/Tasks/{0}/Show.aspx", task.ID) %>'><%= task.Title %></a>
    </td>
    <td>
      <asp:Button ID="Button1" runat="server" CssClass="button" CommandName="Delete" Text="Mark Done" />
    </td>
    <%
   };

   sections.After = task => {
    %>
    </tr>
    <%
   };

   sections.AfterAll = task => {
    %>
    </table>
    <%
   };
 });
%>

It might take a while to grasp what’s going on here. The code actually starts using an Extension method to IEnumerable that looks like this:

public static void ForEach<T>(this IEnumerable<T> enumerable, ForeachSectionSetter<T> sectionSetter) {
  if (enumerable != null) {

    if (sectionSetter != null) {
      ForeachSections<T> sections = new ForeachSections<T>();
      sectionSetter(sections);

      if (enumerable.Count() == 0) {
        if (sections.NoData != null)
          sections.NoData(enumerable);
        return;
      }

      if (sections.BeforeAll != null)
        sections.BeforeAll(enumerable);

      int itemIndex = 0;
      T previousItem = default(T);

      foreach (T item in enumerable) {
        if (sections.Before != null)
          sections.Before(item);
        if (itemIndex % 2 == 1 && sections.Odd != null)
          sections.Odd(item);
        if (itemIndex % 2 == 0 && sections.Even != null)
          sections.Even(item);
        if (itemIndex > 0 && sections.Between != null)
          sections.Between(previousItem, item);
        if (sections.Each != null)
          sections.Each(item);
        if (sections.After != null)
          sections.After(item);
        itemIndex++;
        previousItem = item;
      }
      if (sections.AfterAll != null)
        sections.AfterAll(enumerable);
    }
  }
}

The delegate ForEachSectionSetter is used by the calling method with a lambda expression. As a parameter it receives an ForeachSections object, which looks like this:

public class ForeachSections<T> {
  public Action<T> Each { get; set; }
  public Action<IEnumerable<T>> BeforeAll { get; set; }
  public Action<T> Before { get; set; }
  public Action<T,T> Between { get; set; }
  public Action<T> Odd { get; set; }
  public Action<T> Even { get; set; }
  public Action<T> After { get; set; }
  public Action<IEnumerable<T>> AfterAll { get; set; }
  public Action<IEnumerable<T>> NoData { get; set; }
}

The calling method gets the chance to set the properties of this class before it is returned to the constructor of the ForEach method for processing. And because each property is already preset to a default value (Null in this case), the constructor can use the ForeachSections object just like a set of default or optional parameters. The caller can simply set values to the properties it needs, and ignore the rest.

If I had tried this another way, using overloadable constructors, it would have led to multiple constructors with indistinguishable signatures. If I’d have used property initializers, I wouldn’t have been able to run the whole routine without requiring a second call to the object, which actually wasn’t possible.

Basically, I couldn’t think of another way to do it.

The properties of the ForeachSections object are all delegates too. That means that we can use them with lambdas, which gives us lambdas inside of a lambda. (Hmm, very confusing!)

So what do you think? Could you use something like this? Can you make it simpler? Leave me a comment if you can.

Since the source code to ASP.Net was made available, I’ve been using it extensively. Here’s a great example of why it’s so valuable.

I’ve been trying to integrate the Enterprise Library 3.1 Exception Handling Block into my application. My application is split into a core and web UI specific components, so I’ve defined errors in my code to be thrown when a resource is not available. The web application configuration file specifies that if a specific exception, e.g. a ResourceNotFoundException, is thrown, the Exception Handling Block should replace that exception with a 404 Resource Not Found error using Http. That should in turn use the CustomErrors feature to redirect to a 404 not found page.

Makes sense, and sounds simple, don’t you think?

Nothing in the docs says that it shouldn’t work.

But it doesn’t. It simply won’t work. Why? Well, there’s nothing on the web. But after spending some serious hours digging through the source code, I can finally see why.

Here’s a lovely little hidden-to-the-world snippet of the code I got inside of Visual Studio:

code = HttpException.GetHttpCodeForException(e);

// Don't raise event for 404.  See VSWhidbey 124147.
if (code != 404) {
  WebBaseEvent.RaiseRuntimeError(e, this);
}

So it would never work!

Nice of them to let me know.

One of my favorite bloggers is Matt Berseth. Nearly once a week he comes up with a post where he does something amazing with the standard ASP.Net controls. I usually read his posts in awe. He’s really good.

But he’s not only is a good developer, he’s a great writer. Even though his posts are concise and straight to the point, most of them are pages long. You can really learn a lot from following his instructions.

He’s so good, in fact, that he regularly gets a mention on Scott Guthrie’s posts.

One of my favorite posts of his was where he used LINQ-to-SQL, a LinqDataSource control, and an ASP.Net ListView control – all new in .Net 3.5 – and made a grid with grouping functionality. He did it all in a standard way, and didn’t use any funny tricks.

Here’s a link to the article:

Building a Grouping Grid with the ASP.NET 3.5 LinqDataSource and ListView Controls

Enjoy!

Now this is exciting. (Well, if you’re a geek.)

Silverlight 2.0 is on its way, and Scott Guthrie has posted 8 tutorials about using it.

I’m off to read them now…

So, I did it! I finally did it!

I wanted to publish my ideas for a framework, and I did. You can find it on CodePlex at http://www.codeplex.com/aspnetmvp.

Go have a look. I really want to know what you think.

Now, I know there are a million and one frameworks for the web, so I don’t intend on trying to make anything big out of this. But I also know that my customers, usually decent developers with basic ASP.Net knowledge, are constantly asking me for guidance for creating ASP.Net projects. To avoid repeating myself over and over, this project gives them a good starting point. When something better comes along, I can point them to that instead.

I can also use the project as a place for creating new ideas, like

• WF integration and reusable workflows, like shopping carts or the “hub and spoke UI pattern”.
• plug-ins and skins, like Dotnetnuke

I definitely do not want to reinvent the wheel. But I believe that there are currently loads of great ideas which could be used in a framework, but just require a little bit of effort to make them simple to use (e.g. UrlRewriting). Most of the developers I know want those extra features without having to spend a lot of time learning a new technology. This framework should be for them.

Instead of totally turning the heads of such developers around, asking them to use a completely new system (e.g. the ASP.Net MVC framework), this framework is meant to provide helpful stuff without stopping you from doing things the way you want (favicons and robots.txt files, for example). It gives you guidance on where to put your CSS files, master pages, scripts, and images. It also provides a way to do testing and project management in a sensible and flexible way. It uses the MVP pattern, but that isn’t mandatory. You can still write code in webforms if you really want to, and then you can refactor them out quite easily later.

I based my MVP implementation on some of the code from the Microsoft Patterns and Practices Web Client Software Factory. However, they made extensive use of the ObjectBuilder and attributes, which I found to be overengineering and too complex. So, as an alternative, I recreated the ideas using generics. I found it works well, and doesn’t have the performance overhead or the learning curve required with WCS.

The code currently uses the AdventureWorks Database, which you will need to install first before using the code. You can find the database on CodePlex here.

I’m currently working on another top-secret project, so I won’t really be spending much time on this. If you’re interested in discussing ideas or doing something with the project, let me know. I’d love to hear what you have to offer.

Otherwise, head on over to the ASP.Net MVP Framework site, and check out the code.

Oh, and until the lawyers call and ask me to change the name, let’s just leave it as it is.

P.S. I forgot to mention a “feature”. The Yahoo UI Framework has some great stuff for CSS, including grid layouts and css reset files. I integrated that too. I put it in the default theme. It means you don’t have to do much work to get your stylesheets to lay out your webpages well.

More to come on that later.

Dude! I got quoted! And by none other than Rob Conery of SubSonic fame.

It seems like my last post caused quite an unexpected stir. Thanks to both Rob and Scott for taking the time to answer me. I really appreciate it.

A Word of Appreciation

Let’s get something in perspective. Rob has actually produced something of immense value with SubSonic. I have just complained about it. Rob could very easily have just hammered me down, but he didn’t. Thanks, Rob.

Scott too.

In the last episode of his most excellent podcast, Scott said to his Dad that he likes to stir things up. “Presenting options” was the phrase I think he used. In that case, we are two peas in a pod. I always like to ask questions. If my question uncovers an unjustified assumption, things usually get better. If I’m wrong, then at least I come out knowing why I was wrong and understand the problem better.

While studying for my physics degree, I was asked to give feedback for a course on “Cosmic Dust”. I commented that it was just a completely pointless course. I mean, why waste 12 weeks of lectures studying the invisible dust floating around in space? Instead of numbing our brains with such useless information, we could have been learning something much more relevant. That particular comment, although made privately, really stirred up the lecturer. He got quite mad actually. He even wrote a long letter to the students with his reasoning for why cosmic dust was so important. That itself was unprecedented. No lecturer had ever given us feedback to our feedback before.

Not much changed in the end, but at least I came out of it understanding more about what I’d been doing. Maybe that will happen with ASP.Net MVC.

So thanks to both of you for taking me seriously.

How Dare They!

Last month I watched a documentary about J.K. Rowling. It followed her as she completed and published the 7th and final Harry Potter book. It was the fasting selling book of all time. Truly amazing. But what amazed me most about the whole documentary was a comment made by two girls who had been queuing all night to get their copy of the book:

“Finally! We’ve been waiting 10 years for this!”

The remark was made with a tinge of disgust. It was as if the author had no right to take such a long time writing the book. How dare Mrs Rowling take so much time to finish her book while they had to suffer while sitting around waiting for it. How inconvenient for them! How inconsiderate of Mrs Rowling!

I thought, “if you wanted the book so much, why didn’t you write your own?”

In that spirit, I’m going to try to do something about the ASP.Net MVC thing myself. I don’t want to be that kind of person that complains but does nothing.

Wait! There’s a baby in that bath-water!

I read Rob’s readers’ comments, and I think that it doesn’t require a full rewrite of ASP.Net to do what they want. In fact, I already wrote a bit of code, modeled loosely on Django templates, which allows an ASP.Net developer to control the page output pretty much the same way as MVC promises to do. I’ll have to dig the code out of its hiding place, but then I plan to integrate it with a small Model-View-Presenter framework (a couple of generic base-classes for a Page and Presenter) which will enable a much better way for writing pages than the normal ASP.Net pages do. It also allows full testing of the controlling code.

And better yet, the MVP stuff is based on a refactored and simplified version of some Patterns and Practices code. (Yaaay, we can all be happy together!)

I’ve used this pattern, and each Presenter class is usually a few lines long. My ASP.Net page only contains presentation logic, i.e. stuff to render the page and retrieve input. I don’t need a controller nor a completely new framework to do it. In fact, a Controller class would be much worse, IMHO, because Controllers contain the code for more than one concern – a list page, an edit page, a delete page, etc. (I think that those things could be pragmatically abstracted and made easier anyhow, but that’s another story.) I personally prefer to keep my concerns separate.

And I’m not the only one who likes MVP. Craig Shoemaker does too.

So here’s my plan: I’ll try to publish some ideas and persuade you all to use them. Then I’ll get Microsoft to take Routes, Controllers, and whatever other goodies they’ve got in ASP.Net MVC, and put them in the next full-blown version of ASP.Net. Then everyone can use them and we can carry on with life as normal. I won’t have to use UrlRewriter to do my Routing any more and Microsoft can go back and finish off Workflow Foundation, ASP.Net Ajax, and Patterns and Practices.

Well, that’s the plan, anyway.

(I’ve just got to tidy up some of my code before I publish it. Give me a moment…)

Scott Guthrie has just announced that the source code for the .Net framework has just been made available for reference use.

It will be particularly useful to see how the controls in ASP.Net and Windows Forms have been done.

Detailed instructions for how to set it up are here.

One caveat: it’s not available for the Express editions of Visual Studio. Shame! I was just starting to have some fun with them too.