I have made this available on code plex at http://xmldatamapper.codeplex.com/

It uses simple Xml Files to do the mapping, hope this helps.

I prefer implicit (reflection and convention) as the default behaviour with the option of explicit overrides (attributes as I hate programming in XML).

Realistically you should have a unit test that’s checking your serializations in other areas so you should be covering this serialization with a unit test as well. This coverage solves the refactoring requirements.

I was also bored to write mapping code between object (what we can call Object/object mapping, and not object/relational mapping like NHibernate). But in fact it is very related issues.

I look at “the other side” (i.e. Java), and it exists a framework named Dozer. It makes implicit mapping as you explain, but for more complicated mapping, you make the mapping in XML files like (N)Hibernate does.

I heard you thinking about your three requirements, but unfortunately, I think there is no solution that combine these three requirements, and the same problem exists with ORM.
Personaly, I prefer configuration over code generation (hence I prefer NHibernate or IBatis than generated DAO).
So, on the first requirement, configuration approach fails more or less, because in fact, you will unit test your classes that makes use of the mapper (and not make unit tests for string inspection, that have no value as you said).
On the second requirement, it is the one I prefer (because I am bored to write mapping code, and implicit mapping simplify it. There is a difference between mapping code and configuration complexity because in mapping code, you have to create object instances, to recurse on collections, to handle inheritance mapping (and that code is very boring), whereas with configuration, I just declare mapping between types and fields and I have implicit mapping.
On the third requirement, I think configuration is simpler than code, even if it needs to understand mapping framework. But it is another discussion…

Clément

This post has kind-of stemmed from using NHibernate. There are some situations where you can’t pass the POCOs around (for example, Web-services) due to them being unserializable. I think you should be using DTOs in these situations anyway, but then you’re back to the problem of mapping between them in an effortless way.

Good blog, by the way James, give is afew years and you will be a celebrity dev.