<hibernate-mapping                                   
     schema="schemaName"                   (1) 
     default-cascade="none|save-update"    (2)
     auto-import="true|false"              (3)
     assembly="Eg"                         (4)
    namespace="Eg"                         (5)
 />            

　　各选项说明：

(1)	schema (optional): 数据库schema名称。
(2)	default-cascade (可选 - 默认为 none): 默认的级联风格。
(3)	auto-import (optional - defaults to true): 指定我们在使用查询语句的时候是否可以使用非全限定名。
(4)(5)	assembly and namespace(可选): 指定映射文件中的类的应用程序集名称和其所在的名称空间名，用来生成类的非全限定名。

　　如果没有设置assembly何namespace标签，我们不得不使用类的非全限定名 (namespace.类名,assembly）.

　　假若你有两个持久化类，它们的非全限定名是一样的，你应该设置auto-import="false"。 假若说你把一个“import过”的名字同时对应两个类， NHibernate会抛出一个异常。

二. class

 你可以使用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)
/>

 各选项说明：

　　若指明的持久化类实际上是一个接口，这也是完全可以接受的。 之后你可以用元素 <subclass>来指定该接口的实际实现类。 你可以持久化任何static（静态的）内部类。 你应该使用标准的类名格式来指定类名，比如：Eg.Foo+Bar, Eg。由于HQL解析器的限制NHibernate 1.0 无法在查询里使用内部类。

　　不可变类 mutable="false"不可以被应用程序更新或者删除。 这可以让NHibernate做一些小小的性能优化。

　　可选的proxy属性允许延迟加载类的持久化实例。 NHibernate开始会返回实现了这个命名接口的代理类。当代理的某个方法被实际调用的时候， 真实的持久化对象才会被装载。参见下面的“用于延迟装载的代理”。

　　Implicit (隐式)的多态是指，如果查询时给出的是任何超类、该类实现的接口或者该类的 名字，都会返回这个类的实例；如果查询中给出的是子类的名字，则会返回子类的实例。 Explicit （显式）的多态是指，只有在查询时给出明确的该类名字时才会返回这个类的实例； 同时只有在这个<class>的定义中作为<subclass>或者<joined-subclass>出现的子类，才会可能返回。 在大多数情况下，默认的polymorphism="implicit"都是合适的。 显式的多态在有两个不同的类映射到同一个表的时候很有用。（允许一个“轻型”的类，只包含部分表字段）。

　　persister属性可以让你定制这个类使用的持久化策略。 你可以指定你自己实现 NHibernate.Persister.EntityPersister的子类，你甚至可以完全从头开始编写一个 NHibernate.Persister.IClassPersister接口的实现， 比如是用储存过程调用、序列化到文件或者LDAP数据库来实现。 参阅NHibernate.DomainModel.CustomPersister，这是一个简单的例子 （“持久化”Hashtable）。

　　请注意dynamic-updatee和dynamic-insert的设置并不会继承到子类， 所以在<subclass>或者<joined-subclass>元素中可能 需要再次设置。这些设置是否能够提高效率要视情形而定。请用你的智慧决定是否使用。

　　使用select-before-update通常会降低性能。如果你重新连接一个脱管（detache）对象实例 到一个Session中时，它可以防止数据库不必要的触发update。 这就很有用了。

如果你打开了dynamic-update，你可以选择几种乐观锁定的策略：

　　我们非常强烈建议你在NHibernate中使用version/timestamp字段来进行乐观锁定。 对性能来说，这是最好的选择，并且这也是唯一能够处理在session外进行操作的策略（例如： 在使用ISession.Update()的时候）。注意version或者是timestamp属性不能为null，不管是否使用了unsaved-value策略，或者是实例被作为是瞬态。

　　从NHibernate 1.2.0开始，版本号从1开始（以前的版本从0开始），这样允许把version的属性的unsaved-value设置为0。

三、 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>

　　说明：

　　如果name属性不存在，会认为这个类没有标识属性。

<id name="Id" type="Int64" column="uid" unsaved-value="0">
    <generator class="NHibernate.Id.TableHiLoGenerator">
        <param name="table">uid_table</param>
        <param name="column">next_hi_value_column</param>
    </generator>
</id>

　　高/低位算法（Hi/Lo Algorithm）

　　hilo 和 seqhilo生成器给出了两种hi/lo算法的实现， 这是一种很令人满意的标识符生成算法。 第一种实现需要一个“特殊”的数据库表来保存下一个可用的“hi”值。 第二种实现使用一个Oracle风格的序列（在被支持的情况下）。

<id name="Id" type="Int64" column="cat_id">
        <generator class="hilo">
                <param name="table">hi_value</param>
                <param name="column">next_value</param>
                <param name="max_lo">100</param>
        </generator>
</id>
<id name="Id" type="Int64" column="cat_id">
        <generator class="seqhilo">
                <param name="sequence">hi_value</param>
                <param name="max_lo">100</param>
        </generator>
</id>

　　很不幸，你在为NHibernate自行提供IDbConnection时无法使用hilo。 NHibernate必须能够在一个事务里获取"hi"值。

<id name="Id" type="String" column="cat_id">
        <generator class="uuid.hex">
            <param name="format">format_value</param>
            <param name="seperator">seperator_value</param>
        </generator>
</id>

　　标识字段和序列（Identity columns and Sequences）

　　对于内部支持标识字段的数据库(DB2,MySQL,Sybase,MS SQL)，你可以使用identity关键字生成。 对于内部支持序列的数据库（DB2,Oracle, PostgreSQL, Interbase, McKoi,SAP DB), 你可以使用sequence风格的关键字生成。 这两种方式对于插入一个新的对象都需要两次SQL查询。

<id name="Id" type="Int64" column="uid">
        <generator class="sequence">
                <param name="sequence">uid_sequence</param>
        </generator>
</id>
<id name="Id" type="Int64" column="uid" unsaved-value="0">
        <generator class="identity"/>
</id>

　　对于跨平台开发，native策略会从identity, sequence 和hilo中进行选择，选择哪一个，这取决于底层数据库的支持能力。

五、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>

　　你的持久化类必须重载 Equals()和GetHashCode()方法，来实现组合的标识符判断等价.也必须实现可序列化。

　　不幸的是，这种组合关键字的方法意味着一个持久化类是它自己的标识。除了对象自己之外， 没有什么方便的“把手”可用。你必须自己初始化持久化类的实例，在使用组合关键字load()持久化状态之前， 必须填充他的联合属性。我们会在 7.4. 组件作为联合标识符(Components as composite identifiers)第 7.4 节 “组件作为联合标识符(Components as composite identifiers)”章中说明一种更加方便的方法， 把联合标识实现为一个独立的类，下面描述的属性只对这种备用方法有效:

六、鉴别器

 　　在"一棵对象继承树对应一个表"的策略中,<discriminator>元素是必需的, 它定义了表的鉴别器字段。 鉴别器字段包含标志值，用于告知持久化层应该为某个特定的行创建哪一个子类的实例。 如下这些受到限制的类型可以使用： String, Char, Int32, Byte, Short, Boolean , YesNo, TrueFalse。

<discriminator
        column="discriminator_column" 　　　　　　 (1)
        type="discriminator_type"      　　　　　　(2)
        force="true|false"             　　　　　　(3)
        insert="true|false"            　　　　　　(4)
        formula="arbitrary SQL expression"    　　(5)
/>

　　说明：

　　鉴别器字段的实际值是根据discriminator-value 和<class> and <subclass>元素中 的discriminator-value属性得来的。

　　force属性仅仅在这种情况下有用的：表中包含没有被映射到持久化类的附加辨别器值。 这种情况不会经常遇到。

　　使用formula属性你可以定义一个SQL表达式，用来判断一个行数据的类型。

<discriminator formula="case when CLASS_TYPE in (‘a‘, ‘b‘, ‘c‘) then 0 else 1 end" type="Int32"/>

七、版本（version）(可选)

　　<version>元素是可选的，表明表中包含附带版本信息的数据。 这在你准备使用 长事务（long transactions）的时候特别有用。

<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)
/>

　　说明：

版本号必须是以下类型：Int64, Int32, Int16, Ticks,或者 Timestamp, TimeSpan。

八、timestamp (可选)

　　可选的<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)
/>

　　说明：

　　注意<timestamp>等价于 <version type="timestamp">。

　　<property>元素为类定义了一个持久化类的属性。

<property
        name="propertyName"                 (1)
        column="column_name"                (2)
        type="typename"                     (3)
        update="true|false"                 (4)
        insert="true|false"                 (4)
        formula="arbitrary SQL expression"  (5)
        access="field|property|ClassName"   (6)
        optimistic-lock="true|false"        (7)
        generated="never|insert|always"     (8)
/>

　　说明：

　　typename可以是如下几种

　　注意你必须为所有类型（除了NHibernate基础类型）指定完整的应用程序集权限定名 （或者是在<hibernate-mapping>里面配置了assembly和namespace属性）。

　　NHibernate支持.NET 2.0的可空类型，这些类型和对应的非可空类型处理方式是一致的， 例如：Nullable<Int32>可以对应type="Int32"或者是type="System.Int32"。

　　如果你没有指定类型，NHibernate会使用反射来得到这个名字的属性， 以此来猜测正确的NHibernate类型。NHibernate会对属性读取器(getter方法）的返回类进行解释， 按照规则2,3,4的顺序。然而，这并不足够。 在某些情况下你仍然需要type属性。 （比如，为了区别NHibernateUtil.DateTime和NHibernateUtil.Timestamp,或者为了指定一个自定义类型。）

　　access属性用来让你控制NHibernate如何在运行时访问属性。 在默认情况下， NHibernate会按照access-strategy.naming-strategy来格式化属性名 .naming-strategy不是必填项。

　　命名策略（Naming Strategy）

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

 　　通过 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)
/>

　　说明：

　　cascade属性允许下列值：: all, save-update, delete, none. 设置除了none以外的其它值会传播特定的操作到关联的（子）对象中。参见后面的“Lifecycle Objects(自动管理生命周期的对象）”。

　　fetch参数允许下列两个不同值:

　　一个典型的简单many-to-one 定义例子：

<many-to-one name="product" class="Product" column="PRODUCT_ID"/>

　　property-ref属性只应该用来对付老旧的数据库系统， 可能有外键指向对方关联表的是个非主键字段（但是应该是一个惟一关键字）的情况下。 这是一种十分丑陋的关系模型。比如说，假设Product类有一个惟一的序列号， 它并不是主键。（unique属性控制NHibernate通过SchemaExport工具生成DDL的过程。）

<property name="serialNumber" unique="true" type="string" column="SERIAL_NUMBER"/>

　　那么关于OrderItem 的映射可能是：

<many-to-one name="product" property-ref="serialNumber" column="PRODUCT_SERIAL_NUMBER"/>

　　当然，我们决不鼓励这种用法。

十一、一对一

 　　持久化对象之间一对一的关联关系是通过 one-to-one元素定义的。

<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)
/>

　　说明：

　　有两种不同的一对一关联：

　　主键关联不需要额外的表字段；如果两行是通过这种一对一关系相关联的，那么这两行就共享同样的主关键字值。所以如果你希望两个对象通过主键一对一关联，你必须确认它们被赋予同样的标识值！

　　比如说，对下面的Employee和Person进行主键一对一关联:

<one-to-one name="Person" class="Person"/>
<one-to-one name="Employee" class="Employee" constrained="true"/>

　　现在我们必须确保PERSON和EMPLOYEE中相关的字段是相等的。我们使用一个被成为foreign的特殊的现在我们必须确保PERSON和EMPLOYEE中相关的字段是相等的。我们使用一个被成为foreign的特殊的hibernate标识符生成策略：标识符生成策略： foreign:

<class name="Person" table="PERSON">
    <id name="Id" column="PERSON_ID">
        <generator class="foreign">
            <param name="property">Employee</param>
        </generator>
    </id>
    ...
    <one-to-one name="Employee"
        class="Employee"
        constrained="true"/>
</class>

　　一个刚刚保存的Person实例被赋予和该Person的employee属性所指向的Employee实例同样的关键字值。

另一种方式是一个外键和一个惟一关键字对应，上面的Employee和Person的例子，如果使用这种关联方式，可以表达成：

<many-to-one name="Person" class="Person" column="PERSON_ID" unique="true"/>

　　如果在Person的映射加入下面几句，这种关联就是双向的：

<one-to-one name="Employee" class="Employee" property-ref="Person"/>

　　<component>元素把子对象的一些元素与父类对应的表的一些字段映射起来。 然后组件可以定义它们自己的属性、组件或者集合。

<component 
        name="PropertyName"                               (1)
        class="ClassName"                                  (2)
        insert="true|false"                                (3)
        upate="true|false"                                 (4)
        access="field|property|nosetter|ClassName"         (5)
        optimistic-lock="true|false"                       (6)
>
        <property ...../>
        <many-to-one .... />
        ........
</component>

　　说明：

　　其<property>子标签为子类的一些属性与表字段之间建立映射。

　　<component>元素允许加入一个 <parent>子元素，在组件类内部就可以有一个指向其容器的实体的反向引用。

　　<dynamic-component>元素允许把一个 IDictionaryp映射为组件，其属性名对应键值。 参见第 8.5 节 “动态组件 （Dynamic components）”.

十三、子类(subclass)

 　　最后，多态持久化需要为父类的每个子类都进行定义。 对于“每一棵类继承树对应一个表”的策略来说，就需要使用<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>

　　说明：

　　每个子类都应该定义它自己的持久化属性和子类。 <version> 和<id>属性可以从根父类继承下来。 在一棵继承树上的每个子类都必须定义一个唯一的discriminator-value。如果没有指定，就会使用.NET类的全限定名。

十四、连接的子类(joined-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>

　　说明：

　　这种映射策略不需要指定辨别标志(discriminator)字段。但是，每一个子类都必须使用 <key>元素指定一个表字段来持有对象的标识符。本章开始的映射可以被用如下方式重写：

<?xml version="1.0"?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" assembly="Eg"
    namespace="Eg">

        <class name="Cat" table="CATS">
                <id name="Id" column="uid" type="Int64">
                        <generator class="hilo"/>
                </id>
                <property name="BirthDate" type="Date"/>
                <property name="Color" not-null="true"/>
                <property name="Sex" not-null="true"/>
                <property name="Weight"/>
                <many-to-one name="Mate"/>
                <set name="Kittens">
                        <key column="MOTHER"/>
                        <one-to-many class="Cat"/>
                </set>
                <joined-subclass name="DomesticCat" table="DOMESTIC_CATS">
                    <key column="CAT"/>
                        <property name="Name" type="String"/>
                </joined-subclass>
        </class>

        <class name="Dog">
                <!-- mapping for Dog could go here -->
        </class>

</hibernate-mapping>

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

 　　第三种选择是仅仅映射类继承树中具体类部分到表中(每个具体类一张表的策略)。 其中，每张表定义了类的所有持久化状态，包括继承的状态。 在 NHibernate 中，并不需要完全显式地映射这样的继承树。 你可以简单地使用单独的<class>定义映射每个类。 然而，如果你想使用多态关联(例如，一个对类继承树中超类的关联)，你需要使用<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>

　　说明：

这种映射策略不需要指定辨别标志(discriminator)字段。

十六、连接(join)

 　　使用 <join> 元素，可以将一个类的属性映射到多张表中。 当表之间存在一对一关系的时候使用。

<join
        table="tablename"                        (1)
        schema="owner"                           (2)
        fetch="join|select"                      (3)
        inverse="true|false"                     (4)
        optional="true|false">                   (5)

        <key ... />

        <property ... />
        ...
</join>

　　说明：

　　例如，一个人(person)的地址(address)信息可以被映射到单独的表中(并保留所有属性的值类型语义)：

<class name="Person"
    table="PERSON">

    <id name="id" column="PERSON_ID">...</id>

    <join table="ADDRESS">
        <key column="ADDRESS_ID"/>
        <property name="address"/>
        <property name="zip"/>
        <property name="country"/>
    </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来映射是不错的选择，虽然他可以很容易地被映射成组件。这样做的动机之一是抽象。使用自定义类型，以后假若你改变表示金额的方法时，它可以保证映射文件不需要修改。