I am evaluating NHibernate for use in my current project, and first I must determine the ease with which I can map the domain model. The domain model consists of concrete classes each of which inherits from between zero and two interfaces. The interfaces have associations between each other. I designed the domain model with the assumption that I could map the underlying data source to the interfaces’ properties giving somewhat the effect of multiple inheritance. I want to use NHiberate’s table-per-subclass mapping strategy, but I haven’t figured out the XML syntax for a “joined-subclass” that inherits from multiple interfaces. In terms of the relational model, the subclass’s table would simply have one foreign key per parent interface. Does NHibernate support multiple inheritance in this way? If not then how else could I achieve the same result?

---
If NHibernate does not support multiple inheritance in the way I described above, then my second question is: does it support user-defined parameterized types (generics)? I suppose I could remove multiple inheritance from my domain model as follows. In cases which lead to multiple inheritance, instead of having an interface with multiple implementing concrete classes, change the interface into a parameterized concrete class with a property of the parameter type that represents the former subclasses. That way the link between the former interface and former subclasses is still maintained with the same cardinality, and each of the former subclasses can still inherit from one other interface.

So does NHibernate support user-defined generics to make this approach possible? I think this could be possible on the relational side as follows. Each table corresponding to a type that’s used as a type parameter must include a foreign key pointing to the parameterized type’s table. This foreign key will be null in cases where the instance does not belong to an instance of the parameterized type.

I don't really understand what you're trying to do from an object oriented point of view. So here's a well-regarded suggestion for designing your domain model "do it exactly as you would if Hibernate didn't exist".

When you say does it support multiple inheritance in this way... I don't know if there's an answer to this, because what you've talked about is not multiple inheritance. Multiple inheritance is not supported in C# and interfaces are implemented.

That sounds like generally good advice, but actually I didn’t know anything about Hibernate in particular when designing the domain model. Rather, I just had some vague sense there would be a relational database as the underlying data structure.


I used the term “multiple inheritance” because some people see implementing interfaces as a scaled-down form of inheritance. I can instead call it “implementing multiple interfaces” if that’s more kosher. But in fact, the effect I am talking about achieving is more than just implementing an interface. I am talking about the data structure being “inherited”, which I think is conceivable in an O/R mapping scenario since the underlying data structure sits outside of the CLR.


I’m a bit confused by what you say here. In the NHibernate documentation, “Chapter 8: Inheritance Mapping”, the example of table-per-subclass mapping uses exactly that: an interface that’s mapped to a table in the database. And I never said I don’t have subclasses. Quite the contrary, I said my domain model consists of concrete classes that each implement zero to two interfaces.

I hope that’s helped somewhat clarify my question in regards to implementing multiple interfaces. Again, if that’s not possible, then what about user-defined parameterized types?

NHibernate 1.2 does not support multiple interface inheritance in the way you described. Using the current SVN trunk version you could probably use <join> element in the class mapping to join the interface tables with the class table.

NHibernate 1.2 doesn't support generic entities either (mainly because of the HQL parser limitations), so the second approach wouldn't work. The generic entities support isn't implemented in the trunk neither.

Sorry I'm just wrong. I didn't even know you could do it - and I have 2 books which don't mention it. You can take what sergey says and probably ignore me.

Thank you sergey for that helpful information, and thank you PandaWood for challenging me to clarify my question. I’ve determined it is possible to adjust my data model to work with NHibernate by using the Bridge design pattern. This breaks each problem interface into an “Abstraction” and an “Implementor”. After that, the only remaining issue is mapping a field of type “IImplementor” in the Abstraction sealed concrete class, where IImplementor is an interface that’s not explicitly mapped. It seems the XML ‘any’ tag is for addressing just such a need.

The problem interface was a problem for NHibernate because it participated in a many-to-many relationship. And thus it needed to be explicitly mapped and it’s implementing classes also needed to inherit that data-structure from it. That was impossible since those implementing classes were already mapped as subclasses of other interfaces. Now the Abstraction class participates in the many-to-many relation, and the implementing classes derive from IImplementor.

I would like to share an observation I’ve made during this exercise. If the method of “multiple (data-structure) inheritance” that I originally described was to be supported by NHibernate, then the ‘any’ tag (which is far from ideal) wouldn’t be needed – when using the table-per-subclass mapping strategy anyway. It would also allow for a more conceptual sort of modelling. So, depending on how well it meshes with NHibernate’s current architecture, I would like to suggest adding it.