二. class

<class

    name="ClassName"                             (1)

    table="tableName"                            (2)

    discriminator-value="discriminator_value"    (3)

    mutable="true|false"                         (4)

    schema="owner"                               (5)

    proxy="ProxyInterface"                       (6)

    dynamic-update="true|false"                  (7)

    dynamic-insert="true|false"                  (8)

    select-before-update="true|false"            (9)

    polymorphism="implicit|explicit"             (10)

    where="arbitrary sql where condition"        (11)

    persister="PersisterClass"                   (12)

    batch-size="N"                               (13)

    optimistic-lock="none|version|dirty|all"     (14)

    lazy="true|false"                            (15)

    abstract="true|false"　　　　　　　　　　　　　　(16)

/>

三、 id

<id

        name="PropertyName"                    　　　　(1)

        type="typename"                         　 　　(2)

        column="column_name"                      　　 (3)

        unsaved-value="any|none|null|id_value"     　　(4)

        access="field|property|nosetter|ClassName">   (5)
　　　　 <generator class="generatorClass"/>
</id>

五、composite-id 联合ID

<composite-id

    name="PropertyName"

    class="ClassName"

    unsaved-value="any|none"

    access="field|property|nosetter|ClassName">

    <key-property name="PropertyName" type="typename" column="column_name"/>

    <key-many-to-one name="PropertyName class="ClassName" column="column_name"/></composite-id>

　　如果表使用联合主键，你可以把类的多个属性组合成为标识符属性。<composite-id> 元素接受<key-property>属性映射和 <key-many-to-one>属性映射作为子元素。

<composite-id>

    <key-property name="MedicareNumber"/>

    <key-property name="Dependent"/>

</composite-id>

六、鉴别器

<discriminator

        column="discriminator_column" 　　　　　　 (1)

        type="discriminator_type"      　　　　　　(2)

        force="true|false"             　　　　　　(3)

        insert="true|false"            　　　　　　(4)

        formula="arbitrary SQL expression"    　　(5)

/>

<version

        column="version_column"                            (1)

        name="PropertyName"                                (2)

        type="typename"                                    (3)

        access="field|property|nosetter|ClassName"         (4)

        unsaved-value="null|negative|undefined|value"      (5)

        generated="never|always"                           (6)

/>

八、timestamp (可选)

<timestamp

        column="timestamp_column"          　　　　　　 (1)

        name="PropertyName"                   　　　　 (2)

        access="field|property|nosetter|ClassName"    (3)

        unsaved-value="null|undefined|value"　　　　　  (4)

        generated="never|always"            　　　　　　(5)

/>

九、property

十、多对一（many-to-one）

<many-to-one

        name="PropertyName"                                (1)

        column="column_name"                               (2)

        class="ClassName"                                  (3)

        cascade="all|none|save-update|delete"              (4)

        fetch="join|select"                                (5)

        update="true|false"                                (6)

        insert="true|false"                                (6)

        property-ref="PropertyNameFromAssociatedClass"     (7)

        access="field|property|nosetter|ClassName"         (8)

        unique="true|false"                                (9)

        optimistic-lock="true|false"                       (10)

        not-found="ignore|exception"                       (11)

/>

十一、一对一

<one-to-one

        name="PropertyName"                                (1)

        class="ClassName"                                  (2)

        cascade="all|none|save-update|delete"              (3)

        constrained="true|false"                           (4)

        fetch="join|select"                                (5)

        property-ref="PropertyNameFromAssociatedClass"     (6)

        access="field|property|nosetter|ClassName"         (7)

/>

十二、组件(component), 动态组件(dynamic-component)

十三、子类(subclass)

<subclass

        name="ClassName"                              (1)

        discriminator-value="discriminator_value"     (2)

        proxy="ProxyInterface"                        (3)

        lazy="true|false"                             (4)

        dynamic-update="true|false"

        dynamic-insert="true|false">

        <property .... />

        .....

</subclass>

十四、连接的子类(joined-subclass)

<joined-subclass

        name="ClassName"                    (1)

        proxy="ProxyInterface"              (2)

        lazy="true|false"                   (3)

        dynamic-update="true|false"

        dynamic-insert="true|false">

        <key .... >

        <property .... />

        .....

</joined-subclass>

十五、联合子类(union-subclass)

<union-subclass

        name="ClassName"                    (1)

        table="tablename"                   (2)

        proxy="ProxyInterface"              (3)

        lazy="true|false"                   (4)

        dynamic-update="true|false"

        dynamic-insert="true|false"

        schema="schema"

        catalog="catalog"

        extends="SuperclassName"

        abstract="true|false"

        persister="ClassName"

        subselect="SQL expression"

        entity-name="EntityName"

        node="element-name">

        <property .... />

        .....

</union-subclass>

十六、连接(join)

<join

        table="tablename"                        (1)

        schema="owner"                           (2)

        fetch="join|select"                      (3)

        inverse="true|false"                     (4)

        optional="true|false">                   (5)

        <key ... />

        <property ... />

        ...

</join>

十七、引用

　　实体entity独立于任何持有实体引用的对象。与通常的.Net模型相比， 不再被引用的对象会被当作垃圾收集掉。实体必须被显式的保存和删除(除非保存和删除是从父实体向子实体引发的级联)。 这和ODMG模型中关于对象通过可触及保持持久性有一些不同——比较起来更加接近应用程序对象通常在一个大系统中的使用方法。 实体支持循环引用和交叉引用，它们也可以加上版本信息。

　　一个实体的持久状态包含指向其他实体和值类型实例的引用。值可以是原始类型，集合(不是集合中的对象)， 组件或者特定的不可变对象。与实体不同，值(特别是集合和组件)是通过可触及性来进行持久化和删除的。 因为值对象(和原始类型数据)是随着包含他们的实体而被持久化和删除的，他们不能被独立的加上版本信息。 值没有独立的标识，所以他们不能被两个实体或者集合共享。

　　所有的NHibernate类型（如果.NET可空）除了集合类都支持null语义（继承System.ValueType）。

　　直到现在，我们都一直使用术语“持久类”(persistent class)来代表实体。我们仍然会这么做。 然而严格说来，不是所有的用户自定义的，带有持久化状态的类都是实体。组件就是用户自定义类，却是值语义的。

　　NHibernate为了兼容Hibernate也支持也一些额外的Java类型名（主要是方便能够使用Hibernate代码生成的映射文件）， tt class="literal">type="integer"被映射为Int32 NHibernateType,type="short" 被映射为Int16 NHibernateType 。你可以通过查看NHibernate.Type.TypeFactory类的静态构造函数的代码查看到所有的上述所有的类型转换。

要实现一个自定义类型，可以实现NHibernate.UserTypes.IUserType或NHibernate.UserTypes.ICompositeUserType中的任一个， 并且使用类型的全限定类名来定义属性。请查看 NHibernate.DomainModel.DoubleStringType这个例子，看看它是怎么做的。

<property name="TwoStrings" type="NHibernate.DomainModel.DoubleStringType, NHibernate.DomainModel">

    <column name="first_string"/>

    <column name="second_string"/>

</property>

　　注意使用<column>标签来把一个属性映射到多个字段的做法。

　　ICompositeUserType, IEnhancedUserType, INullableUserType, IUserCollectionType, 和 IUserVersionType接口为更特殊的使用方式提供支持。

　　你甚至可以在一个映射文件中提供参数给一个IUserType。 为了这样做， 你的UserType必须实现NHibernate.UserTypes.IParameterizedType接口。为了给自定义类型提供参数，你可以在映射文件中使用<type>元素。

<property name="priority">

    <type name="MyCompany.UserTypes.DefaultValueIntegerType">

        <param name="default">0</param>

    </type>

</property>

　　现在，IUserType 可以从传入的IDictionary对象中得到default 参数的值。

　　尽管 NHibernate 内建的丰富的类型和对组件的支持意味着你可能很少 需要使用自定义类型。不过， 为那些在你的应用中经常出现的(非实体)类使用自定义类型也是一个好方法。例如， 一个MonetaryAmount类使用ICompositeUserType来映射是不错的选择，虽然他可以很容易地被映射成组件。这样做的动机之一是抽象。使用自定义类型，以后假若你改变表示金额的方法时，它可以保证映射文件不需要修改。

　　meta-type属性使得应用程序能指定一个将数据库字段的值映射到持久化类的自定义类型。 这个持久化类包含有用id-type指定的标识符属性。 你必须指定从meta-type的值到类名的映射。

 <any name="being" id-type="Int64" meta-type="string">

    <meta-value value="TBL_ANIMAL" class="Animal"/>

    <meta-value value="TBL_HUMAN" class="Human"/>

    <meta-value value="TBL_ALIEN" class="Alien"/>

    <column name="table_name"/>

    <column name="id"/>

 </any>

　　NHibernate也支持meta-type="class"标签，这个例子里meta-value不是必须的， 因为 meta-value就是持久化类名(persistentClass.FullName)。

 <any name="being" id-type="Int64" meta-type="class">

    <column name="table_name"/>

    <column name="id"/>

  </any>

　　但你使用meta-type="class"在查询语句里设置参数时，你必须使用下面的代码：

SetParameter("paramName", typeof(YourClass).FullName, NHibernateUtil.ClassMetaType)

　　映射文件部分：

<any

        name="propertyName"                     (1)

        id-type="idtypename"                     (2)

        meta-type="metatypename"                 (3)

        cascade="cascade_style"                  (4)

        access="field|property|ClassName"        (5)

        optimistic-lock="true|false"             (6)

>

        <meta-value ... />

        <meta-value ... />

        .....

        <column .... />

        <column .... />

        .....

</any>

<class name="LineItem" table="`Line Item`">

    <id name="Id" column="`Item Id`"/><generator class="assigned"/></id>

    <property name="ItemNumber" column="`Item #`"/>

    ...

</class>

<hibernate-mapping>

        <subclass name="Eg.Subclass.DomesticCat, Eg"

            extends="Eg.Cat, Eg" discriminator-value="D">

             <property name="name" type="string"/>

        </subclass>

</hibernate-mapping>

<nhibernate-mapping>

    ...

    <database-object>

        <create>CREATE TRIGGER my_trigger ...</create>

        <drop>DROP TRIGGER my_trigger</drop>

    </database-object>

</nhibernate-mapping>

<hibernate-mapping>

    ...

    <database-object>

        <definition class="MyTriggerDefinition, MyAssembly"/>

    </database-object>

</hibernate-mapping>

<hibernate-mapping>

    ...

    <database-object>

        <definition class="MyTriggerDefinition, MyAssembly">

            <param name="parameterName">parameterValue</param>

        </definition>

    </database-object>

</hibernate-mapping>

<hibernate-mapping>

    ...

    <database-object>

        <definition class="MyTriggerDefinition"/>

        <dialect-scope name="NHibernate.Dialect.Oracle9Dialect"/>

        <dialect-scope name="NHibernate.Dialect.OracleDialect"/>

    </database-object>

</hibernate-mapping>