In short, never ever never use Regexes or anything else to parse HTML. To do so is to descend into madness. HTML is not simple text, it has structure. Even simple fragments have structure to them that cannot be identified simply through token parsing.

Always always always use an HTML parser, such as the Html Agility Pack. That is what I did. The parser created the document and tokenized everything for me and from there I was able to parse and manipulate the node tree to match the requirements we had.

Never use anything else if you can avoid it.

This project was a pretty good one.  Even though we put the application into production, the customer didn’t have enough money to keep me on long enough to finish the project in a state I would have been more happier with.  There were a few reasons for this I think: 1) the customer did not have a clear enough spec, in his mind, before I started, 2) the customer was too busy with other projects to give me enough attention and direction with the design, 3) the customer was too busy to help me get the application into a User Acceptance test site earlier than two days before the contract expired.  If we had a little more time, maybe one more month I think we could have turned the application into something excellent, and I could have seen it in use long enough to know if my design assumptions were good ones.

That said, I did spend a lot of time with one of the Users who was a database modelling expert.  I did learn a lot from him, and he really helped me understand more about what they were expecting as a customer.  Unfortunately he worked in another building, so access to him was severely limited too.

Another success was that this was my first ASP.NET MVC project to be deployed.  It was also my first use of NHibernate, which I also thought was very successful.  I also used jQuery and jQuery UI extensively for Web 2.0 stuff like dialogs (death to window.open!) and AJAX.  Those things were a lot of fun.

I also got to use a of new architectural planning and design (Domain Driven Design) pattern that I learned from a talk given by Donald Belcham (aka The Igloo Coder).  I’ve been reading the book by Eric Evans as well.  This definitely seems like the new way to go.  DDD is about modelling your application and also about understanding the client’s needs.  I’m really impressed and eager to use it in future projects and products as well.

I was using some cool features of jQuery to do AJAX instead of using UpdatePanels, but when The Intern wanted to do some AJAX he got totally lost. In the end I taught him to use both jQuery and (despite how dangerous it is), Ihow to use UpdatePanels.  In the end I encouraged him to use the UpdatePanel with his pages, read on to find out why.

1.  Updating the DOM using jQuery and Web Services is an Advanced Skill

Oh yes, both you and I can look at the code and figure out exactly what is happening.  We see the JS file linked in the ScriptManagerProxy control, we can follow the JavaScript code to the webservice call, and even more, but it is a very advanced skill.

2.  Updating the DOM using jQuery and Web Services Reduced Maintainability

Even with all of my knowledge, it’s still a long, messy trail of code until you get to the end (the web service). You’re crossing several files, including C#, ASPX, JavaScript, and ASMX files.  In my opinion this drastically decreases maintainability and makes the code much less readable and obvious to other .NET developers, even those who have read Encosia’s article.

3.  Using UpdatePanels Doesn’t Change the ASP.NET PostBack Model

The UpdatePanel is just another ASP.NET tag.  The PostBack model is retained, you still have Button OnClick events, you still have TextBox.Text, Page_Load etc. All of the code is still retained within one ASPX/ASPX.CS file pair. Almost any .NET developer, no matter how junior, should be able to follow this code. That makes the code maintainable.

In the end, even though jQuery will be shipping with future versions of ASP.NET, the .NET Framework, and Visual Studio, it’s still a relatively new concept. We need to proceed with it, but this is new ground so we have to blaze a trail that the slower movings guys can follow.

One of the big benefits we have as .NET developers is the MSDN Library. I like to use MSDN as a scale for maintainability. If it is in MSDN then I consider it general knowledge that a new developer should know or be able to find easily. Otherwise I have to document it really well so that at least a mid-level developer should be able to figure out my application.

We have to be careful that the people maintaining the code behind us know what we’ve done, otherwise our awesome code gets rewritten by newb developers who can’t figure it out. If we can write maintainable code then hopefully the developers behind us will learn something and eventually become more advanced in their skills too.

It’s just a quick article on how to enable Intellisense for jQuery in Visual Studio.

1. Custom jQuery Selector

One of the best parts of jQuery is it’s robost CSS style element selector. However, ASP.NET screws up our element IDs.  John Sheehan did some cool research and created a custom selector to select items based on the end of of the item ID.

• http://john-sheehan.com/blog/index.php/custom-jquery-selector-for-aspnet-webforms/

2. The jQuery UI Widgets

jQuery UI comes with some great UI widgets, especially in the development bundle.  See the download builder for all of the utilities.

• http://ui.jquery.com/
• http://ui.jquery.com/download_builder/

Also, check out the UI Theme Roller to build custom themes.

• http://ui.jquery.com/themeroller

3. The Date Picker Plugin

I can’t remember the last app I’ve developed without a Date Picker.

• http://plugins.jquery.com/project/datepicker

4. The Form Plugin

The Form plugin has some good tools, including a form data serializer (often handy when calling webservices).

• http://malsup.com/jquery/form/

5.  The bgiframe Plugin

The bgIframe plugin is good for fixing Z-Index issues in popups on Internet Exploder.

• http://plugins.jquery.com/project/bgiframe

6. The BlockUI Plugin

BlockUI is handy for preventing extra button clicks on elements you’re updating with a web service or even inside an UpdatePanel if you’re still into that kind of thing…  :)

• http://malsup.com/jquery/block/

In the .NET world there are two powerful ORM tools out there, NHibernate and SubSonic.  NHibernate is based on the successful and popular Java EE ORM Hibernate.  SubSonic is an entirely new ORM developed in the Ruby on Rails ActiveRecord development model, with some nice .NET 2.0 features like Controllers that you can use with ObjectDataSource controls.

For a recent project I quickly evaluated both software tools, and I’m publishing what I learned here.

Setting up NHibernate:

The NHibernate Object/Relational Mapping is setup using XML files.  If you’re using the 3.5 Framework you can use a fluent interface instead (i.e. code the mapping in C# instead of XML).  I didn’t find a tool that generated the XML or interface automatically for you, but there must be one out there.

Changes to the database require changing the mappings, which means digging through XML.

Setting up SubSonic:

SubSonic mappings are generated via an external tool called SubCommander run from the tools menu.  Any changes to the database require regenerating these mapped classes.  SubCommander connects to your database, reads the Schema and generates O/R classes.  The O/R classes are Partial classes in C# so that you can create methods for the classes that won’t get overwritten by the tool each time you write it.

Changes to the database require re-running SubCommander (which can be done via the IDE).

The SubSonic team has also come up with some great videos to help you get started.

Migrations

The big thing that sold me on SubSonic was the new Migrations feature.  It uses a Ruby on Rails style migrations tool to help keep your database versioned.  It’s really excellent for a first generation tool.  It’s missing a few things, like it’s hard to set Unique Keys, but otherwise it is excellent.  This is also the first .NET Migrations utility I’ve found.

Migrations are one of the easiest ways to keep your database versioned, which has always been a problem for me when updating Test and Production databases.

Conclusion

I ended up selecting SubSonic for the following reasons:

1. No XML configuration files (running a tool is much easier, IMHO)
2. Migrations
3. Their excellent video tutorials and directions on their website

Okay, UpdatePanels aren’t dangerous, but they do use more bandwidth and server CPU than a simple web service call.  I figure a web developer ought to know what is being sent behind the scenes, but I can understand that a lot of people don’t.  UpdatePanels require sending the ViewState and building the control structure behind the scenes, as well as doing a subset of the ASP.NET Page event model, which means more data being POSTed behind the scenes and it takes a little longer to do all that processing.

UpdatePanels are easy though, and for some things in ASP.NET it is so much easier to use.  But Encosia does give us an awesome was to still use ASP.NET User Controls within web services and jQuery gives us some awesome tools to build pages dynamically without using UpdatePanels here: http://encosia.com/2008/02/05/boost-aspnet-performance-with-deferred-content-loading/.  It’s not quite as easy to maintain as UpdatePanels, but it’s still very easy to use, and also very very fast.

I’m finding CodeIgniter a little frustrating right now.  I really wanted to use an MVC tool, but CI is not playing well with IIS.  Also, the documentation really isn’t that great, even for an open-source project.

Alas, like most PHP projects it just wasn’t designed or tested with IIS in mind.  Fortunately I’m discovering this relatively early in the project, but I’m a little frustrated that some of these things are coming up now.

I think given the choice, since the IIS setup was decided for me before, I might have push ASP.NET Forms (vs MVC) instead.  Something I’ll keep in mind for next time.

Of course, CodeIgniter does work much better on my local Apache development environment.  I don’t want to come down too hard on it.  I’m just not impressed with how it works on IIS.

But it’s not ready to use yet so I’m going to use CodeIgniter.  Sure people are out there coding with the beta, or I could even use plain ol’ Web Forms, but long story short: it isn’t ready.  It’s going to be awesome when it’s done, it’s awesome now, but every new beta brings out breaking changes.

So even though it makes me sad to leave my beloved C# for one site, I’m gonna have to stick with PHP for this one.

I spent a few hours trying to find out where on the client the exception was occurring before tracking it to the web service.  I figured nothing was happening on the server since Application_Error didn’t log the error for me.

So, unless you know something I don’t know, make sure you add your own error handling to your Web Services.