Fabrice's weblog

My latest article is now available in English: "Choosing an object-relational mapping tool".

In case you are unemployed or searching for some side revenues, I think I have a new job for you: AdSenser.

It seems this will be confirmed...

I'm pleased to introduce sharpUrls, the first product proposed by metaSapiens.

sharpUrls enables well-defined URLs for your ASP.NET sites and applications.
Linking to a web page is very easy, both in simple HTML and in ASP.NET. Linking to a page that really exists, passing the right parameters, and parsing these parameters, is a bit different.
sharpUrls takes care of your URLs. It proposes a solution to define structured URLs for each of your pages, as well as a clean and simple way to call them.
The idea is based on strict page inputs and declarative parameter binding. With sharpUrls, each page exposes a set of methods that represent the different ways to call the page. All you have to do to start benefiting from sharp URLs is to add methods to your pages, and mark these methods with attributes provided by sharpUrls.

Features include:

• Object-oriented approach for hyperlinks
• No concatenations of strings required anymore
• Strongly typed parameters
• Automated parameter handling
• Parameter validation
• Compile-time checks
• Code completion
• Integrated with Visual Studio .NET

A new meme is starting to make some buzzing noise.
Paul Wilson started to talk about UI Mapping in July, and lately more and more people are talking about this concept.
Mats Helander has a complete series on various mappings (1, 2, 3, and up to 6). Roger Johansson is also talking about the concept and even has a prototype implementation (1, 2, 3).
Roughly, the idea is to use more mappings than just object-relational mapping, which is used to map your domain objects to a relational database. The first new mapping is between your domain objects and the presentation layer. This means we would have Relational Model <-> Domain Model <-> Presentation Model.
But I won't try to explain the concept, Roger Johansson and Mats Helander do this very well on their weblogs.

This goes towards a more declarative approach, and I think we need it because GUI code is the next pain in the neck after data access - a lot of code for nothing.
No need to say I'll follow this closely and even use it if possible.

The best solution I've seen for logging unhandled exceptions in ASP.NET is ELMAH (Error Logging Modules And Handlers).
It is easy to use, the code is clean and well documented.
But that's not all! The author published with Scott Mitchell an article about ELMAH on MSDN. This article is very good and detailed (as usual with Scott). It's also an occasion to see a good way to make use of HTTP Handlers and Modules.

Some things need to be repeated from time to time, again and again: "The data in a record depends on The Key to the record, The Whole Key, and Nothing But The Key, so help me Codd."

By default ASP.NET 1.x downgrades its reponses to lower-level HTML with web browsers other than Internet Explorer 5+.
The result is that browsers like Mozilla, Firefox, Opera or Safari get a different HTML than IE 6, while they could handle it. As a developer this is a nightmare because when you develop a page with IE, and then test it with Firefox, it looks all broken and you start cursing the Mozilla team and the consortiums in charge of the standards. You end up having to do the work twice, once for IE, once for the other browsers.