26

鉴于以下场景，我想使用 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类是抽象的。

数据库模式

+------------+ +----------------+ +----------------+
| 项目 | | 混凝土项目X | | 具体项目Y |
+==========+ +================+ +===============+
| 项目 ID | | 项目 ID | | 项目 ID |
| 项目类型 | | 场C | | 字段D |
| 字段A | +---------------+ +----------------+
| 字段B |
+----------+

看图片

该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未映射。

问题

如何使用 Fluent NHibernate 映射类的FieldB属性？SubItem

有什么方法可以利用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

4 回答 4

27

我知道这真的很老了，但现在设置 fluent 以生成您最初想要的精确映射非常简单。由于我在寻找答案时遇到了这篇文章，所以我想我会发布它。

您只需为基类创建 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")
        });
    }
}

希望这可以帮助其他人使用流利的方式寻找这种类型的映射。

于 2010-11-24T18:13:44.913 回答
1

这就是我解决继承问题的方法：

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();
    }


}
于 2010-01-13T20:42:47.323 回答
1

好吧，我不确定它是否完全正确，但它可能会起作用......如果有人可以更干净地做到这一点，我很乐意看到它（说真的，我会的；这是一个有趣的问题）。

使用您提供的确切类定义，以下是映射：

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>

它很丑，但看起来它可能会生成一个可用的映射文件，而且它很流畅！:/ 你也许可以进一步调整这个想法，以获得你想要的。

于 2009-03-18T15:00:17.890 回答
1

这行代码：if (part.GetType().BaseType.Name == "JoinedSubClassPart1") 可以改写如下：

part.GetType().BaseType.IsGenericType && part.GetType().BaseType.GetGenericTypeDefinition() == typeof(JoinedSubClassPart<>)
于 2009-05-07T12:13:22.547 回答