Update: It appears that I am wrong, and NHibernate can support this functionality by eagerly loading the association at load time. You can do by specifying lazy="false" (and optionally, outer-join="true") on the many to one association.
Yesterday I presented an interesting problem that pop up with any OR/M that supports inheritance and lazy loading.
Let us say that we have the following entity model:
Backed by the following data model:
As you can see, we map the Animal hierarchy to the Animals table, and we have a polymorphic association between Animal Lover and his/her animal. Where does the problem starts?
Well, let us say that we want to load the animal lover. We do that using the following SQL:
WHERE Id = 1 /* @p0 */
And now we have an animal lover instance:
var animalLover = GetAnimalLoverById(1);
var isDog = animalLover.Animal is Dog;
var isCat = animalLover.Animal is Cat;
Can you guess what would be the result of this code?
The answer is that both isDog nor isCat would be… false.
But how is that?
To answer that question, let us take a look at the SQL that was used to load the animal lover, and let us take a look at a typical example of hydrating entities. I am using Davy’s DAL here to show off the problem, because the code is simple and it demonstrate that the problem is not unique to a particular OR/M, but is shared among all of them (Davy’s DAL doesn’t even support inheritance, for example).
private void SetReferenceProperties<TEntity>(
IDictionary<string, object> values)
foreach (var referenceInfo in tableInfo.References)
if (referenceInfo.PropertyInfo.CanWrite == false)
object foreignKeyValue = values[referenceInfo.Name];
if (foreignKeyValue is DBNull)
referenceInfo.PropertyInfo.SetValue(entity, null, null);
var referencedEntity = sessionLevelCache.TryToFind(
if(referencedEntity == null)
referencedEntity = CreateProxy(tableInfo, referenceInfo, foreignKeyValue);
referenceInfo.PropertyInfo.SetValue(entity, referencedEntity, null);
Take a look at what the code is doing, we are currently processing the Aminal property on the AnimalLover class. And we try to find an Animal that was loaded with a primary key matching to the value of the Animal column in the AnimalLovers table.
When we can’t find it, we have to create a lazy loading proxy for the referenced entity. And here is where the conundrum kicks into play. When we have inheritance, we have a real problem here. What is the type of the referenced entity?
From the model, we know that it must be a derivation of Animal of some sort, and we have its PK, but we have no way of knowing which without going to the database for it.
So what are we going to do? Because we don’t have enough information to create a lazy loading proxy of the appropriate type, we actually generate a lazy loading proxy of the type that we do know about, Animal.
But what about when it is being loaded?
Well, that is where the lack of #become in .NET becomes painful, we already have an instance, and we can’t change its types. And we can’t replace the reference on the AnimalLover because someone might have grab a reference to the animal before the lazy load.
The way to handle it is by turning the lazy loading proxy into a real one. We load a new instance that represent the entity, now with the correct type, since we query the DB to find out what it is (along with the rest of the entity’s data).
And the lazy loading proxy that we originally used is now loaded, and any call made on it will be forwarded to the new instance that was loaded.
animalLover.Animal stays an AnimalProxy, and cannot be cast to a Dog or a Cat, even if the actual row it is pointing to is a Dog or a Cat.