Mapping Serializable types using Fluent NHibernate

Noah — Wed, 20 Jan 2010 16:35:25 GMT

Yesterday I posted a question to StackOverflow (http://stackoverflow.com/questions/2097364/mapping-to-serializabletype-in-fluent-nhibernate) asking whether anyone could tell me how to map a Serializable type using Fluent NHibernate. The outcome was disappointing to say the least. In 24 hours there have been less than 20 views. It was voted up twice, but no comments or answers were posted.

Even worse, there’s another post on StackOverflow (http://stackoverflow.com/questions/2000798/map-to-serializable-in-fluent-nhibernate) that asks this same question and has an answer that’s incorrect (it compiles but throws an exception at runtime).

Serializable types in NHibernate (XML)

Before I continue, I’ll give a little background. Feel free to skip this part. Suppose you want to map the following object (contrived, I know):

        1: public class Person

       2: {

       3:     public virtual string FirstName { get; set; }

       4:     public virtual string LastName { get; set; }

       5:     public virtual BirthCertificate BirthCertificate { get; set; }

       6: }

       1: public class BirthCertificate

       2: {

       3:     public virtual DateTime DOB { get; set;}

       4:     public virtual string BirthCity { get; set; }

       5:     public virtual string BirthState { get; set; }

       6:     public virtual string HospitalName { get; set;}

       7: }

Imagine, however, that you don’t want to map the BirthCertificate fields to a table. Imagine you want to serialize the BirthCertificate object and store it in a single column in the Person table.

NHibernate makes this really easy. When mapping the BirthCertificate property on Person, you would write something like this:

       1: <property name="BirthCertificate" column="BirthCertificate" type="Serializable"  />

and of course you would have to add a [Serializable] attribute to the BirthCertificate class like so:

       1: [Serializable]

       2: public class BirthCertificate

       3: {

       4: .......

Mapping Serializable using Fluent NHibernate

This is actually surprisingly easy.

The Fluent interface provides a CustomType method that allows you to map your entity to a custom, IUserType. The incorrect answer that was posted on the old StackOverflow post (link above) mentioned combining this CustomType method with the SerializableType type, like this:

       1: CustomType<NHibernate.Type.SerializableType>();

That will build, but it throws an Exception at runtime:

An invalid or incomplete configuration was used while creating a SessionFactory. Check PotentialReasons collection, and InnerException for more detail.

InnerException:

Could not instantiate IType SerializableType: System.MissingMethodException: No parameterless constructor defined for this object.
   at System.RuntimeTypeHandle.CreateInstance(RuntimeType type, Boolean publicOnly, Boolean noCheck, Boolean& canBeCached, RuntimeMethodHandle& ctor, Boolean& bNeedSecurityCheck)
   at System.RuntimeType.CreateInstanceSlow(Boolean publicOnly, Boolean fillCache)
   at System.RuntimeType.CreateInstanceImpl(Boolean publicOnly, Boolean skipVisibilityChecks, Boolean fillCache)
   at System.Activator.CreateInstance(Type type, Boolean nonPublic)
   at System.Activator.CreateInstance(Type type)
   at NHibernate.Bytecode.ActivatorObjectsFactory.CreateInstance(Type type)
   at NHibernate.Type.TypeFactory.HeuristicType(String typeName, IDictionary`2 parameters)

I’m not a contributor to the Fluent NHibernate project (though I’m considering it after some other things calm down and I have more time), so I wasn’t particularly familiar with the codebase. In order to find the solution, I downloaded the latest code and stepped through it to see how it works.

Basically, the fluent interface collects all your mapping settings and then outputs the appropriate hbm’s at configure-time. Using the incorrect answer above resulted in the following mapping for the BirthCertificate property:

       1: <property name="BirthCertificate" 

       2: type="NHibernate.Type.SerializableType, NHibernate, 

       3: Version=2.1.2.4000, Culture=neutral, PublicKeyToken=aa95f207798dfdb4">

       4:   <column name="`BirthCertificate`" /> 

       5: </property>

Hey – that should read type=”Serializable”! We don’t want the whole Type info there!

Turns out one of the overloads of the CustomType method takes….. you guessed it (!)…. a String!

The following is the correct way of mapping a Serializable type in Fluent NHibernate

       1: CustomType("Serializable");

Yes I feel stupid for not figuring this out from the start! One comfort though is that it doesn’t seem that many people know this, even though it seems so obvious.

Stupid as I feel, I also feel like I gained a lot from the hour I spent on this; I finally got to delve into the Fluent NHibernate code.

NHibernate Generic Dictionary Mapping

Noah — Wed, 14 Jan 2009 21:42:00 GMT

"NHibernate: have I told you today how much I love you?"

The other day I had a good reason to use a generic dictionary and I though hey, I wonder how I'll get that working with NHibernate... It's very simple to persist Generic Dictionarys with NHibernate as I found out. Let's see an example...

.NET PSEUDO CODE

Take a person and his favorite or least favorite deserts:

First we have a Person object

class Person
-----------
int PersonId
string FirstName
string LastName

And a desert object

class Desert
------------
int DesertId
string Name

Now we want to associate a Person with all the deserts and rate how much he likes them (I know, it's contrived, but it's simpler than the business case I did this with yesterday). So first we might create an enum for storing how one feels about a particular dessert (we'll call it Rating):

enum Rating
-----------------------
Love,
Like,
Impartial,
Dislike,
Disdain

And then we might add a generic dictionary to the Person object like so:

class Person
-----------
string FirstName
string LastName
Dictionary<Desert, Rating> DesertRatings

Looks good. Now how would we use NHibernate to persist this? First off, let's make a slight change to the Person object because NHibernate actually uses IDictionary, so that last line of the Person object would look more like:

IDictionary<Desert, Rating> DesertRatings

DATABASE TABLES

To persist this data we first create the tables in our database. Assuming we used the code above, I would probably create 3 different tables: 1 to store the Persons, 1 to store Deserts, and 1 to store the association between Persons and their Desert ratings. The tables might look like this:

PEOPLE
PersonId, int
FirstName, varchar
LastName, varchar

DESERTS
DesertId, int
Name, varchar

PEOPLEDESERTRATINGS (PersonId and DesertId will be the primary keys since 1 person can only have 1 rating for a specific desert)
PersonId, int
DesertId, int
Rating, int (this will store the integer representation of the enum)

NHibernate Mappings

Now behold the magic of NHibernate. Let's take a look at what the Person.hbm.xml file might look like:

<?xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" assembly="MyAssembly" namespace=MyNamespace">
<class name="Person" table="People">
<id name="PersonId" column="PersonId" type="Int32" unsaved-value="0">
<generator class="native"></generator>
</id>
<property name="FirstName" column="FirstName" type="String" not-null="true" />
<property name="LastName" column="LastName" type="String" not-null="true" />
<map name="DesertRatings" table="PeopleDesertRatings">
<key column="PersonId" />
<index-many-to-many class="Desert" column="DesertId" />
<element column="Rating" type="MyNamespace.Rating" not-null="true" />
</map>
</class>
</hibernate-mapping>

That's all there is too it. There's a lot that I didn't cover here, and this is NOT meant to be a tutorial on how to design your objects or tables. However, I think I've shown how amazingly easy it is to persist this kind of thing using NHibernate. I didn't find anything online about this before I tried it and it worked the first time, but I would have felt more comfortable trying it had I seen someone else do it first. So hopefully this post helps someone feel comfortable diving right in.