Отображение наследования с помощью Fluent NHibernate
Учитывая следующий сценарий, я хочу сопоставить иерархию типов со схемой базы данных, используя Fluent NHibernate.
Я использую NHibernate 2.0
Тип иерархии
public abstract class Item
{
public virtual int ItemId { get; set; }
public virtual string ItemType { get; set; }
public virtual string FieldA { get; set; }
}
public abstract class SubItem : Item
{
public virtual string FieldB { get; set; }
}
public class ConcreteItemX : SubItem
{
public virtual string FieldC { get; set; }
}
public class ConcreteItemY : Item
{
public virtual string FieldD { get; set; }
}
Item а также SubItem классы абстрактные.
Схема базы данных
+ ---------- + + --------------- + + --------------- + | Пункт | | ConcreteItemX | | ConcreteItemY | +==========+ +===============+ +===============+ | ItemId | | ItemId | | ItemId | | ItemType | | FieldC | | FieldD | | FieldA | +---------------+ +---------------+ | FieldB | +----------+
ItemType поле определяет конкретный тип.
Каждая запись в ConcreteItemX таблица имеет одну соответствующую запись в Item Таблица; аналогично для ConcreteItemY Таблица.
FieldB всегда нулевой, если тип элемента ConcreteItemY,
Картирование (пока)
public class ItemMap : ClassMap<Item>
{
public ItemMap()
{
WithTable("Item");
Id(x => x.ItemId, "ItemId");
Map(x => x.FieldA, "FieldA");
JoinedSubClass<ConcreteItemX>("ItemId", MapConcreteItemX);
JoinedSubClass<ConcreteItemY>("ItemId", MapConcreteItemY);
}
private static void MapConcreteItemX(JoinedSubClassPart<ConcreteItemX> part)
{
part.WithTableName("ConcreteItemX");
part.Map(x => x.FieldC, "FieldC");
}
private static void MapConcreteItemY(JoinedSubClassPart<ConcreteItemY> part)
{
part.WithTableName("ConcreteItemX");
part.Map(x => x.FieldD, "FieldD");
}
}
FieldB не отображается.
Вопрос
Как мне сопоставить FieldB собственность SubItem класс, использующий Fluent NHibernate?
Есть ли способ, которым я могу использовать DiscriminateSubClassesOnColumn с использованием ItemType поле?
добавление
Я могу достичь желаемого результата, используя файл hbm.xml:
<class name="Item" table="Item">
<id name="ItemId" type="Int32" column="ItemId">
<generator class="native"/>
</id>
<discriminator column="ItemType" type="string"/>
<property name="FieldA" column="FieldA"/>
<subclass name="ConcreteItemX" discriminator-value="ConcreteItemX">
<!-- Note the FieldB mapping here -->
<property name="FieldB" column="FieldB"/>
<join table="ConcreteItemX">
<key column="ItemId"/>
<property name="FieldC" column="FieldC"/>
</join>
</subclass>
<subclass name="ConcreteItemY" discriminator-value="ConcreteItemY">
<join table="ConcreteItemY">
<key column="ItemId"/>
<property name="FieldD" column="FieldD"/>
</join>
</subclass>
</class>
Как выполнить приведенное выше сопоставление с помощью Fluent NHibernate?
Можно ли смешать таблицу на иерархию классов с таблицей на подкласс, используя Fluent NHibernate?
4 ответа
Я знаю, что это действительно старо, но теперь довольно просто настроить беглость, чтобы генерировать точное отображение, которое вы изначально хотели. Так как я наткнулся на это сообщение при поиске ответа, я решил опубликовать его.
Вы просто создаете свой ClassMap для базового класса без каких-либо ссылок на ваши подклассы:
public class ItemMap : ClassMap<Item>
{
public ItemMap()
{
this.Table("Item");
this.DiscriminateSubClassesOnColumn("ItemType");
this.Id(x => x.ItemId, "ItemId");
this.Map(x => x.FieldA, "FieldA");
}
}
Затем сопоставьте ваш абстрактный подкласс следующим образом:
public class SubItemMap: SubclassMap<SubItemMap>
{
public SubItemMap()
{
this.Map(x => x.FieldB);
}
}
Затем отобразите ваши конкретные подклассы так:
public class ConcreteItemXMap : SubclassMap<ConcreteItemX>
{
public ConcretItemXMap()
{
this.Join("ConcreteItemX", x =>
{
x.KeyColumn("ItemID");
x.Map("FieldC")
});
}
}
Надеюсь, это поможет кому-то еще, ищущему этот тип карт с беглым знаком.
Вот как я решил свою проблему наследования:
public static class DataObjectBaseExtension
{
public static void DefaultMap<T>(this ClassMap<T> DDL) where T : IUserAuditable
{
DDL.Map(p => p.AddedUser).Column("AddedUser");
DDL.Map(p => p.UpdatedUser).Column("UpdatedUser");
}
}
Затем вы можете добавить это в свой конструктор карты суперкласса:
internal class PatientMap : ClassMap<Patient>
{
public PatientMap()
{
Id(p => p.GUID).Column("GUID");
Map(p => p.LocalIdentifier).Not.Nullable();
Map(p => p.DateOfBirth).Not.Nullable();
References(p => p.Sex).Column("RVSexGUID");
References(p => p.Ethnicity).Column("RVEthnicityGUID");
this.DefaultMap();
}
}
Строка кода: if (part.GetType().BaseType.Name == "JoinedSubClassPart1")можно переписать следующим образом:
part.GetType().BaseType.IsGenericType && part.GetType().BaseType.GetGenericTypeDefinition() == typeof(JoinedSubClassPart<>)
Ну, я не уверен, что это совершенно правильно, но это может сработать... Если кто-то может сделать это более аккуратно, я бы хотел увидеть это (серьезно, я бы; это интересная проблема).
Используя точные определения классов, которые вы дали, вот сопоставления:
public class ItemMap : ClassMap<Item>
{
public ItemMap()
{
Id(x => x.ItemId);
Map(x => x.ItemType);
Map(x => x.FieldA);
AddPart(new ConcreteItemYMap());
}
}
public class SubItemMap : ClassMap<SubItem>
{
public SubItemMap()
{
WithTable("Item");
// Get the base map and "inherit" the mapping parts
ItemMap baseMap = new ItemMap();
foreach (IMappingPart part in baseMap.Parts)
{
// Skip any sub class parts... yes this is ugly
// Side note to anyone reading this that might know:
// Can you use GetType().IsSubClassOf($GenericClass$)
// without actually specifying the generic argument such
// that it will return true for all subclasses, regardless
// of the generic type?
if (part.GetType().BaseType.Name == "JoinedSubClassPart`1")
continue;
AddPart(part);
}
Map(x => x.FieldB);
AddPart(new ConcreteItemXMap());
}
}
public class ConcreteItemXMap : JoinedSubClassPart<ConcreteItemX>
{
public ConcreteItemXMap()
: base("ItemId")
{
WithTableName("ConcreteItemX");
Map(x => x.FieldC);
}
}
public class ConcreteItemYMap : JoinedSubClassPart<ConcreteItemY>
{
public ConcreteItemYMap()
: base("ItemId")
{
WithTableName("ConcreteItemY");
Map(x => x.FieldD);
}
}
Эти сопоставления создают два файла hbm.xml примерно так (некоторые посторонние данные удалены для ясности):
<class name="Item" table="`Item`">
<id name="ItemId" column="ItemId" type="Int32">
<generator class="identity" />
</id>
<property name="FieldA" type="String">
<column name="FieldA" />
</property>
<property name="ItemType" type="String">
<column name="ItemType" />
</property>
<joined-subclass name="ConcreteItemY" table="ConcreteItemY">
<key column="ItemId" />
<property name="FieldD">
<column name="FieldD" />
</property>
</joined-subclass>
</class>
<class name="SubItem" table="Item">
<id name="ItemId" column="ItemId" type="Int32">
<generator class="identity" />
</id>
<property name="FieldB" type="String">
<column name="FieldB" />
</property>
<property name="ItemType" type="String">
<column name="ItemType" />
</property>
<property name="FieldA" type="String">
<column name="FieldA" />
</property>
<joined-subclass name="ConcreteItemX" table="ConcreteItemX">
<key column="ItemId" />
<property name="FieldC">
<column name="FieldC" />
</property>
</joined-subclass>
</class>
Это некрасиво, но похоже, что оно может сгенерировать пригодный для использования файл сопоставления, и это свободно!:/ Возможно, вам удастся немного изменить идею, чтобы получить именно то, что вы хотите.