FluentNHibernate

Built-in alteration for altering an AutoPersistenceModel with instance of IAutoMappingOverride<T>.

Provides a mechanism for altering an AutoPersistenceModel prior to the generation of mappings.

Alter the model

AutoPersistenceModel instance to alter

Constructor for AutoMappingOverrideAlteration.

Assembly to load overrides from.

Alter the model

Finds all types in the assembly (passed in the constructor) that implement IAutoMappingOverride<T>, then creates an AutoMapping<T> and applies the override to it. AutoPersistenceModel instance to alter

A mapping override for an auto mapped entity.

Entity who's auto-mapping you're overriding

Alter the automapping for this type

Automapping

Facade over an assembly for retrieving type instances.

A source for Type instances, acts as a facade for an Assembly or as an alternative Type provider.

Defines a property to be used as a key for this composite-id.

A member access lambda expression for the property The composite identity part fluent interface

Defines a property to be used as a key for this composite-id with an explicit column name.

A member access lambda expression for the property The column name in the database to use for this key, or null to use the property name The composite identity part fluent interface

Defines a property to be used as a key for this composite-id with an explicit column name.

A member access lambda expression for the property Additional settings for the key property The composite identity part fluent interface

Defines a reference to be used as a many-to-one key for this composite-id with an explicit column name.

A member access lambda expression for the property The composite identity part fluent interface

Defines a reference to be used as a many-to-one key for this composite-id with an explicit column name.

A member access lambda expression for the property A list of column names used for this key The composite identity part fluent interface

Defines a reference to be used as a many-to-one key for this composite-id with an explicit column name.

A member access lambda expression for the property A lambda expression specifying additional settings for the key reference A list of column names used for this key The composite identity part fluent interface

Specifies that this composite id is "mapped"; aka, a composite id where the properties exist in the identity class as well as in the entity itself

Specifies the unsaved value for the identity

Unsaved value

You may use a component as an identifier of an entity class. Your component class must satisfy certain requirements: * It must be Serializable. * It must re-implement Equals() and GetHashCode(), consistently with the database's notion of composite key equality. You can't use an IIdentifierGenerator to generate composite keys. Instead the application must assign its own identifiers. Since a composite identifier must be assigned to the object before saving it, we can't use unsaved-value of the identifier to distinguish between newly instantiated instances and instances saved in a previous session. You may instead implement IInterceptor.IsUnsaved() if you wish to use SaveOrUpdate() or cascading save / update. As an alternative, you may also set the unsaved-value attribute on a version or timestamp to specify a value that indicates a new transient instance. In this case, the version of the entity is used instead of the (assigned) identifier and you don't have to implement IInterceptor.IsUnsaved() yourself.

The property of component type that holds the composite identifier. Your persistent class must override Equals() and GetHashCode() to implement composite identifier equality. It must also be Serializable.

Set the access and naming strategy for this identity.

Invert the next boolean operation

Create a property mapping.

Property to map Map(x => x.Name);

Create a property mapping.

Property to map Property column name Map(x => x.Name, "person_name");

Create a reference to another entity. In database terms, this is a many-to-one relationship.

Other entity Property on the current entity References(x => x.Company);

Create a reference to another entity. In database terms, this is a many-to-one relationship.

Other entity Property on the current entity Column name References(x => x.Company, "company_id");

Create a reference to another entity. In database terms, this is a many-to-one relationship.

Other entity Property on the current entity References(x => x.Company, "company_id");

Create a reference to another entity. In database terms, this is a many-to-one relationship.

Other entity Property on the current entity Column name References(x => x.Company, "company_id");

Create a reference to any other entity. This is an "any" polymorphic relationship.

Other entity to reference Property

Create a reference to another entity based exclusively on the primary-key values. This is sometimes called a one-to-one relationship, in database terms. Generally you should use whenever possible.

Other entity Property HasOne(x => x.ExtendedInfo);

Create a reference to another entity based exclusively on the primary-key values. This is sometimes called a one-to-one relationship, in database terms. Generally you should use whenever possible.

Other entity Property HasOne(x => x.ExtendedInfo);

Create a dynamic component mapping. This is a dictionary that represents a limited number of columns in the database.

Property containing component Component setup action DynamicComponent(x => x.Data, comp => { comp.Map(x => (int)x["age"]); });

Creates a component reference. This is a place-holder for a component that is defined externally with a ; the mapping defined in said will be merged with any options you specify from this call.

Component type Property exposing the component Component reference builder

Maps a component

Type of component Component property Component mapping Component(x => x.Address, comp => { comp.Map(x => x.Street); comp.Map(x => x.City); });

Maps a component

Type of component Component property Component mapping Component(x => x.Address, comp => { comp.Map(x => x.Street); comp.Map(x => x.City); });

Allows the user to add a custom component mapping to the class mapping. Note: not a fluent method.

In some cases, our users need a way to add an instance of their own implementation of IComponentMappingProvider. For an example of where this might be necessary, see: http://codebetter.com/blogs/jeremy.miller/archive/2010/02/16/our-extension-properties-story.aspx

Maps a collection of entities as a one-to-many

Child entity type Collection property HasMany(x => x.Locations);

Maps a collection of entities as a one-to-many

Child entity type Collection property HasMany(x => x.Locations);

Maps a collection of entities as a many-to-many

Child entity type Collection property HasManyToMany(x => x.Locations);

Maps a collection of entities as a many-to-many

Child entity type Collection property HasManyToMany(x => x.Locations);

Specify an insert stored procedure

Stored procedure call

Specify an update stored procedure

Stored procedure call

Specify an delete stored procedure

Stored procedure call

Specify an delete all stored procedure

Stored procedure call

Specifies an entity-name.

See http://nhforge.org/blogs/nhibernate/archive/2008/10/21/entity-name-in-action-a-strongly-typed-entity.aspx

Inverts the next boolean

Maps to the Join element in NH 2.0

Specify the key column name

Column name

Specify the key column name

Column names

Specify the schema

Schema name

Inverse the ownership of this relationship

Specify this relationship as optional

Specify the catalog

Catalog

Specify a subselect for fetching this join

Query

Specify the table name

Table name

Specify the fetching strategy

Invert the next boolean operation

Starting point for automapping your entities.

Automatically map classes in the assembly that contains .

Class in the assembly you want to map

Automatically map classes in the assembly that contains .

Class in the assembly you want to map Automapping configuration

Automatically map the classes in .

Assembly containing the classes to map

Automatically map the classes in .

Assembly containing the classes to map Automapping configuration

Automatically map the classes in each assembly supplied.

Assemblies containing classes to map

Automatically map the classes in each assembly supplied.

Automapping configuration Assemblies containing classes to map

Automatically map the classes in each assembly supplied.

Automapping configuration Assemblies containing classes to map

Automatically map the classes exposed through the supplied .

containing classes to map

Automatically map the classes exposed through the supplied .

containing classes to map Automapping configuration

Automatically map the classes exposed through the supplied .

containing classes to map Criteria for selecting a subset of the types in the assembly for mapping

Automatically map the classes in .

Assembly containing the classes to map Criteria for selecting a subset of the types in the assembly for mapping

Automatically map classes in the assembly that contains .

Class in the assembly you want to map Criteria for selecting a subset of the types in the assembly for mapping

Defines a mapping for an entity. Derive from this class to create a mapping, and use the constructor to control how your entity is persisted.

public class PersonMap : ClassMap<Person> { public PersonMap() { Id(x => x.PersonId); Map(x => x.Name); Map(x => x.Age); } } Entity type to map

Specify the identifier for this entity.

Identity property Id(x => x.PersonId);

Specify the identifier for this entity.

Identity property Column name Id(x => x.PersonId, "id");

Create an Id that doesn't have a corresponding property in the domain object, or a column in the database. This is mainly for use with read-only access and/or views. Defaults to an int identity with an "increment" generator.

Create an Id that doesn't have a corresponding property in the domain object, or a column in the database. This is mainly for use with read-only access and/or views.

Type of the id

Create an Id that doesn't have a corresponding property in the domain object.

Type of the id Name and column name of the id

Create a natural identity. This is a secondary identifier that has "business meaning" moreso than the primary key.

NaturalId() .Property(x => x.Name);

Create a composite identity. This is an identity composed of multiple columns. Note: Prefer using a surrogate key over a composite key whenever possible.

CompositeId() .KeyProperty(x => x.FirstName) .KeyProperty(x => x.LastName);

Create a composite identity represented by an identity class. This is an identity composed of multiple columns. Note: Prefer using a surrogate key over a composite key whenever possible.

Composite id property CompositeId(x => x.Id) .KeyProperty(x => x.FirstName) .KeyProperty(x => x.LastName);

Specifies that this class should be versioned/timestamped using the given property.

Version/timestamp property Version(x => x.Timestamp);

Specify that this entity should use a discriminator with it's subclasses. This is a mapping strategy called table-per-inheritance-hierarchy; where all subclasses are stored in the same table, differenciated by a discriminator column value.

Type of the discriminator column Discriminator column name Default discriminator value

Type of the discriminator column Discriminator column name

Discriminator column name

Specifies that any subclasses of this entity should be treated as union-subclass mappings. Don't use this in combination with a discriminator, as they are mutually exclusive.

Sets the schema for this class.

Schema name

Sets the table for the class.

Table name

Sets this entity to be lazy-loaded (overrides the default lazy load configuration).

Links this entity to another table, to create a composite entity from two or more tables.

Joined table name Joined table mapping Join("another_table", join => { join.Map(x => x.Name); join.Map(x => x.Age); });

Imports an existing type for use in the mapping.

Type to import.

Set the mutability of this class, sets the mutable attribute.

Sets this entity to be dynamic update

Sets this entity to be dynamic insert

Sets the query batch size for this entity.

Batch size

Specifies a check constraint

Constraint name

Specifies a persister to be used with this entity

Persister type

Specifies a persister to be used with this entity

Persister type

Specifies a persister to be used with this entity

Persister type

Specifies a proxy class for this entity.

Proxy type

Specifies a proxy class for this entity.

Proxy type

Specifies a proxy class for this entity.

Proxy type

Specifies that a select should be performed before updating this entity

Defines a SQL 'where' clause used when retrieving objects of this type.

Sets the SQL statement used in subselect fetching.

Subselect SQL Query

Specifies an entity-name.

See http://nhforge.org/blogs/nhibernate/archive/2008/10/21/entity-name-in-action-a-strongly-typed-entity.aspx

Applies a filter to this entity given its name.

The filter's name The condition to apply

Applies a filter to this entity given its name.

The filter's name

Applies a named filter to this entity.

The condition to apply The type of a implementation defining the filter to apply.

Applies a named filter to this entity.

The type of a implementation defining the filter to apply.

Configures the tuplizer for this entity. The tuplizer defines how to transform a Property-Value to its persistent representation, and viceversa a Column-Value to its in-memory representation, and the EntityMode defines which tuplizer is in use.

Tuplizer entity-mode Tuplizer type

Specify the caching for this entity.

Cache.ReadWrite();

Specify settings for the container/hibernate-mapping for this class. Note: Avoid using this, if possible prefer using conventions.

HibernateMapping.Schema("dto");

Inverts the next boolean option

Sets the optimistic locking strategy

Sets the polymorphism behaviour

Sets the schema action behaviour

Flags a type as already mapped, stop it from being auto-mapped.

Creates an instance of an IAutoMappingAlteration from a type instance, then adds it to the alterations collection.

Type of an IAutoMappingAlteration

Creates an instance of an IAutoMappingAlteration from a generic type parameter, then adds it to the alterations collection.

Type of an IAutoMappingAlteration Container

Adds an alteration

Alteration to add Container

Adds all alterations from an assembly

Assembly to search Container

Adds all alterations from an assembly that contains T.

Type who's assembly to search Container

Apply alterations to an AutoPersisteceModel

AutoPersistenceModel instance to apply alterations to

Determines whether a member is to be automapped.

Determines whether a member is the identity of an entity.

Determines whether an abstract class is a layer supertype or part of a mapped inheritance hierarchy.

Specifies the value column used in a table of simple types.

Implement this interface to control how the automapper behaves. Typically you're better off deriving from the class, which is pre-configured with the default settings; you can then just override specific methods that you'd like to alter.

Determines whether a type should be auto-mapped. Override to restrict which types are mapped in your domain.

You normally want to override this method and restrict via something known, like Namespace. return type.Namespace.EndsWith("Domain"); Type to map Should map type

Determines whether a member of a type should be auto-mapped. Override to restrict which members are considered in automapping.

You normally want to override this method to restrict which members will be used for mapping. This method will be called for every property, field, and method on your types. // all writable public properties: return member.IsProperty && member.IsPublic && member.CanWrite; Member to map Should map member

Determines whether a member is the id of an entity.

This method is called for each member that ShouldMap(Type) returns true for. Member Member is id

Gets the access strategy to be used for a read-only property. This method is called for every setterless property and private-setter autoproperty in your domain that has been accepted through .

Member to get access strategy for Access strategy

Controls which side of a many-to-many relationship is considered the "parent".

Left side of the relationship Right side of the relationship left or right

Determines whether a type is a concrete, or instantiatable, base class. This affects how the inheritance mappings are built, specifically that any types this method returns true for will not be mapped as a subclass.

Type Base type is concrete?

Specifies that a particular type should be mapped as a component rather than an entity.

Type Type is a component?

Gets the column prefix for a component.

Member defining the component Component column prefix

Specifies whether a particular type is mapped with a discriminator. This method will be called for every type that has already been approved by .

Type to check Whether the type is to be discriminated

Gets the column name of the discriminator.

Type Discriminator column name

Specifies whether an abstract type is considered a Layer Supertype (http://martinfowler.com/eaaCatalog/layerSupertype.html). Defaults to true for all abstract classes. Override this method if you have an abstract class that you want mapping as a regular entity.

Abstract class type Whether the type is a Layer Supertype

Gets the value column for a collection of simple types.

This is the name of the <element> column. Collection property Value column name

Specifies whether the current member is a version property

Candidate member Is member a version

Gets the steps that are executed to map a type.

Collection of mapping steps

Gets or sets whether validation of mappings is performed.

Specify alterations to be used with this AutoPersisteceModel

Lambda to declare alterations AutoPersistenceModel

Use auto mapping overrides defined in the assembly of T.

Type to get assembly from AutoPersistenceModel

Use auto mapping overrides defined in the assembly of T.

Assembly to scan AutoPersistenceModel

Alter some of the configuration options that control how the automapper works. Depreciated in favour of supplying your own IAutomappingConfiguration instance to AutoMap: . Cannot be used in combination with a user-defined configuration.

Supply a criteria for which types will be mapped. Cannot be used in combination with a user-defined configuration.

Where clause

Adds all entities from a specific assembly.

Assembly to load from

Adds all entities from the .

to load from

Override the mapping of a specific entity.

This may affect subclasses, depending on the alterations you do. Entity who's mapping to override Lambda performing alterations

Override all mappings.

Currently only supports ignoring properties on all entities. Lambda performing alterations

Ignore a base type. This removes it from any mapped inheritance hierarchies, good for non-abstract layer supertypes.

Type to ignore

Ignore a base type. This removes it from any mapped inheritance hierarchies, good for non-abstract layer supertypes.

Type to ignore

Explicitly includes a type to be used as part of a mapped inheritance hierarchy.

Abstract classes are probably what you'll be using this method with. Fluent NHibernate considers abstract classes to be layer supertypes, so doesn't automatically map them as part of an inheritance hierarchy. You can use this method to override that behavior for a specific type; otherwise you should consider using the setting. Type to include

Explicitly includes a type to be used as part of a mapped inheritance hierarchy.

Alter convention discovery

Sets whether this subclass is lazy loaded

Specifies an entity-name.

See http://nhforge.org/blogs/nhibernate/archive/2008/10/21/entity-name-in-action-a-strongly-typed-entity.aspx

Inverts the next boolean

Sets the database dialect. This shouldn't be necessary if you've used one of the provided database configurations.

Configuration builder

Sets the database dialect. This shouldn't be necessary if you've used one of the provided database configurations.

Configuration builder

Sets the default database schema

Default schema name Configuration builder

Enables the outer-join option.

Configuration builder

Sets the max fetch depth.

Max fetch depth Configuration builder

Enables the reflection optimizer.

Configuration builder

Sets any query stubstitutions that NHibernate should perform.

Substitutions Configuration builder

Enables the show SQL option.

Configuration builder

Enables the format SQL option.

Configuration builder

Sets the database provider. This shouldn't be necessary if you're using one of the provided database configurations.

Provider type Configuration builder

Sets the database provider. This shouldn't be necessary if you're using one of the provided database configurations.

Provider type Configuration builder

Specify the database driver. This isn't necessary if you're using one of the provided database configurations.

Driver type Configuration builder

Specify the database driver. This isn't necessary if you're using one of the provided database configurations.

Driver type Configuration builder

Configure the connection string

ConnectionString(x => { x.Server("db_server"); x.Database("Products"); }); Closure for building the connection string Configuration builder

Set the connection string.

Connection string to use Configuration builder

Configure caching.

Cache(x => { x.UseQueryCache(); x.UseMinimalPuts(); }); Closure for configuring caching Configuration builder

Sets a raw property on the NHibernate configuration. Use this method if there isn't a specific option available in the API.

Setting key Setting value Configuration builder

Sets the collectiontype.factory_class property. NOTE: NHibernate 2.1 only

factory class Configuration

Sets the collectiontype.factory_class property. NOTE: NHibernate 2.1 only

factory class Configuration

Sets the collectiontype.factory_class property. NOTE: NHibernate 2.1 only

factory class Configuration

Sets the proxyfactory.factory_class property. NOTE: NHibernate 2.1 only

factory class Configuration

Sets the proxyfactory.factory_class property. NOTE: NHibernate 2.1 only

factory class Configuration

Sets the proxyfactory.factory_class property. NOTE: NHibernate 2.1 only

factory class Configuration

Sets the adonet.batch_size property.

Batch size Configuration

Sets the current_session_context_class property.

current session context class Configuration

Sets the current_session_context_class property.

Implementation of ICurrentSessionContext to use Configuration

Sets the connection isolation level. NHibernate setting: connection.isolation

Isolation level Configuration builder

Sets the connection isolation level. NHibernate setting: connection.isolation

Isolation level Configuration builder

Negates the next boolean option.

Provides types for mapping from multiple assemblies

Basic convention interface. Don't use directly.

Inspector instance for use in retrieving values and setting expectations Apply instance

Ignore - this is used for generic restrictions only

Apply changes to the target

Whether this convention will be applied to the target.

Instace that could be supplied Apply on this target?

Represents a string identifier for the model instance, used in conventions for a lazy shortcut. e.g. for a ColumnMapping the StringIdentifierForModel would be the Name attribute, this allows the user to find any columns with the matching name.

Diagnostic logging configuration

Conditionally enable logging

Enable logging

Disable logging

Listener

Result formatter

Output path

Result formatter Output path

Base class for attribute based conventions. Create a subclass of this to supply your own attribute based conventions.

Attribute identifier

Apply changes to a property with an attribute matching T.

Instance of attribute found on property. Property with attribute

Convention for identities, implement this interface to apply changes to identity mappings.

Version convention, implement this interface to apply changes to vesion mappings.

Property convention, implement this interface to apply changes to property mappings.

Convention for a component mapping. Implement this interface to apply changes to components.

Convention for dynamic components. Implement this member to apply changes to dynamic components.

Reference convention, implement this interface to apply changes to Reference/many-to-one relationships.

HasOne convention, used for applying changes to one-to-one relationships.

Convention for the hibernate-mapping container for a class, this can be used to set some class-wide settings such as lazy-load and access strategies.

Joined subclass convention, implement this interface to alter joined-subclass mappings.

Join convention, implement this interface to alter join mappings.

Convention for a single class mapping. Implement this interface to apply changes to class mappings.

Subclass convention, implement this interface to alter subclass mappings.

Apply changes to the target

Gets the requested value off the first column, as all columns are (currently) created equal

Applies to the joining table for this many-to-many.

generates identifiers of any integral type that are unique only when no other process is inserting data into the same table. Do not use in a cluster.

Params configuration

supports identity columns in DB2, MySQL, MS SQL Server and Sybase. The identifier returned by the database is converted to the property type using Convert.ChangeType. Any integral property type is thus supported.

Params configuration

uses a sequence in DB2, PostgreSQL, Oracle or a generator in Firebird. The identifier returned by the database is converted to the property type using Convert.ChangeType. Any integral property type is thus supported.

Params configuration

uses a hi/lo algorithm to efficiently generate identifiers of any integral type, given a table and column (by default hibernate_unique_key and next_hi respectively) as a source of hi values. The hi/lo algorithm generates identifiers that are unique only for a particular database. Do not use this generator with a user-supplied connection. requires a "special" database table to hold the next available "hi" value

The table. The column. The max lo. The where.

Params configuration

uses an Oracle-style sequence (where supported)

Params configuration

uses System.Guid and its ToString(string format) method to generate identifiers of type string. The length of the string returned depends on the configured format.

http://msdn.microsoft.com/en-us/library/97af8hh4.aspx

uses System.Guid and its ToString(string format) method to generate identifiers of type string. The length of the string returned depends on the configured format.

http://msdn.microsoft.com/en-us/library/97af8hh4.aspx Params configuration

uses a new System.Guid to create a byte[] that is converted to a string.

Params configuration

uses a new System.Guid as the identifier.

Params configuration

Recommended for Guid identifiers! uses the algorithm to generate a new System.Guid described by Jimmy Nilsson in the article http://www.informit.com/articles/article.asp?p=25862.

Params configuration

Generator that uses the RDBMS native function to generate a GUID. The behavior is similar to the “sequence” generator. When a new object is saved NH run two queries: the first to retrieve the GUID value and the second to insert the entity using the Guid retrieved from the RDBMS. Your entity Id must be System.Guid and the SQLType will depend on the dialect (RAW(16) in Oracle, UniqueIdentifier in MsSQL for example).

GuidNative(x => { x.AddParam("key", "value"); }); Parameter builder closure

A deviation of the trigger-identity. This generator works together with the feature. The difference with trigger-identity is that the POID value is retrieved by a SELECT using the natural-id fields as filter.

Select(x => { x.AddParam("key", "value"); }); Parameter builder closure

Based on sequence but works like an identity. The POID value is retrieved with an INSERT query. Your entity Id must be an integral type. "hibernate_sequence" is the default name for the sequence, unless another is provided.

Custom sequence name

Parameter builder closure

Custom sequence name Parameter builder closure

trigger-identity is a NHibernate specific feature where the POID is generated by the RDBMS with an INSERT query through a BEFORE INSERT trigger. In this case you can use any supported type, including a custom type, with the limitation of a single column usage.

Parameter builder closure

lets the application to assign an identifier to the object before Save() is called.

Params configuration

picks identity, sequence or hilo depending upon the capabilities of the underlying database.

Params configuration

picks identity, sequence or hilo depending upon the capabilities of the underlying database.

uses the identifier of another associated object. Usually used in conjunction with a one-to-one primary key association.

Params configuration

Applies to the joining table for this many-to-many.

Applies a filter to this relationship given its name.

The filter's name The condition to apply

Applies a filter to this relationship given its name.

The filter's name

Applies a named filter to this relationship.

The condition to apply The type of a implementation defining the filter to apply.

Applies a named filter to this relationship.

The type of a implementation defining the filter to apply.

Applies a filter to this entity given its name.

The filter's name The condition to apply

Applies a filter to this entity given its name.

The filter's name

Applies a named filter to this entity.

The condition to apply The type of a implementation defining the filter to apply.

Applies a named filter to this entity.

The type of a implementation defining the filter to apply.

Specify the lazy behaviour of this relationship.

Defaults to Proxy lazy-loading. Use the modifier to disable lazy-loading, and use the overload to specify alternative lazy strategies. LazyLoad(); Not.LazyLoad();

Specify the lazy behaviour of this relationship. Cannot be used with the modifier.

Laziness strategy LazyLoad(Laziness.NoProxy);

Adds a column to the index if columns have not yet been specified

The column name to add

Adds a column to the index if columns have not yet been specified

The column name to add

Specify the lazy behaviour of this relationship.

Defaults to Proxy lazy-loading. Use the modifier to disable lazy-loading, and use the overload to specify alternative lazy strategies. LazyLoad(); Not.LazyLoad();

Specify the lazy behaviour of this relationship. Cannot be used with the modifier.

Laziness strategy LazyLoad(Laziness.NoProxy);

Applies a filter to this relationship given its name.

The filter's name The condition to apply

Applies a filter to this relationship given its name.

The filter's name

Applies a named filter to this relationship.

The condition to apply The type of a implementation defining the filter to apply.

Applies a named filter to this relationship.

The type of a implementation defining the filter to apply.

(optional) Specifies the entity from which this subclass descends/extends.

Type of the entity to extend

(optional) Specifies the entity from which this subclass descends/extends.

Type of the entity to extend

Checks whether a collection contains an inspector identified by the string value.

Checks whether a collection contains an inspector identified by a predicate.

(optional) Specifies the entity from which this subclass descends/extends.

Type of the entity to extend

(optional) Specifies the entity from which this subclass descends/extends.

Type of the entity to extend

Base convention for specifying your own many-to-many table naming style. Implement the abstract members defined by this class to control how your join tables are named for uni and bi-directional many-to-many's.

Gets the name used for bi-directional many-to-many tables. Implement this member to control how your join table is named for bi-directional relationships.

This method will be called once per bi-directional relationship; once one side of the relationship has been saved, then the other side will assume that name aswell. Main collection Inverse collection Many-to-many table name

Gets the name used for uni-directional many-to-many tables. Implement this member to control how your join table is named for uni-directional relationships.

Main collection Many-to-many table name

A component that is declared external to a class mapping.

Determines the lazy-loading strategy for a collection mapping.

Collection will be eager loaded (lazy=false).

Collection will lazy loaded (lazy=true).

collection will be extra lazy loaded (lazy=extra).

"Extra" lazy collections are mostly similar to lazy=true, except certain operations on the collection will not load the whol collection but issue a smarter SQL statement. For example, invoking Count on an extra-lazy collection will issue a "SELECT COUNT(*)..." rather than selecting and loading the whole collection of entities.

This bad boy is the entry point to the visitor

Laziness strategy for relationships

No lazy loading

Proxy-based lazy-loading

No proxy lazy loading

Defines a property to be used for this natural-id.

A member access lambda expression for the property The natural id part fluent interface

Defines a property to be used for this natural-id with an explicit column name.

A member access lambda expression for the property The column name in the database to use for this natural id, or null to use the property name The natural id part fluent interface

Defines a reference to be used as a many-to-one key for this natural-id with an explicit column name.

A member access lambda expression for the property The natural ID part fluent interface

Defines a reference to be used as a many-to-one key for this natural-id with an explicit column name.

A member access lambda expression for the property The column name in the database to use for this key, or null to use the property name The natural id part fluent interface

Specifies that this id is read-only

This is the same as setting the mutable attribute to false

Inverts the next boolean operation

Sets the tuplizer type.

Type

Sets the tuplizer type.

Type

Sets the tuplizer type.

Type

Sets the tuplizer mode

Mode

Specifies an entity-name.

See http://nhforge.org/blogs/nhibernate/archive/2008/10/21/entity-name-in-action-a-strongly-typed-entity.aspx

Computes the Levenshtein Edit Distance between two enumerables.

The type of the items in the enumerables. The first enumerable. The second enumerable. The edit distance.

A reference to a component which is declared externally. Contains properties that can't be declared externally (property name, for example)

Specify the column name

Column name

Specify the column length

Column length

Specify the nullability of the column

Specify the uniquness of the column

Specify the unique key constraint name

Constraint name

Specify the SQL type for the column

SQL type

Specify the index name

Index name

Inverts the next boolean

Defines a mapping for a component. Derive from this class to create a mapping, and use the constructor to control how your component is persisted.

public class AddressMap : ComponentMap<Address> { public AddressMap() { Map(x => x.Street); Map(x => x.City); } } Component type to map

Specify a parent reference for this component

Parent property ParentReference(x => x.Parent);

Specifies that this component is read-only

This is the same as calling both Not.Insert() and Not.Update()

Specifies that this component is insertable.

Specifies that this component is updatable

Specifies the uniqueness of this component

Specify that this component should be optimistically locked on access

Set the access and naming strategy for this component.

Invert the next boolean operation

Creates a component reference. This is a place-holder for a component that is defined externally with a ; the mapping defined in said will be merged with any options you specify from this call.

Component type Property exposing the component Component reference builder

The fluent-interface part for a external component reference. These are components which have their bulk/body declared external to a class mapping and are reusable.

Component type

Sets the prefix for any columns defined within the component. To refer to the property that exposes this component use {property}.

// Entity using Address component public class Person { public Address PostalAddress { get; set; } } ColumnPrefix("{property}_") will result in any columns of Person.Address being prefixed with "PostalAddress_". Prefix for column names

Maps to the Filter element in NH 2.0

Specifies an entity-name.

See http://nhforge.org/blogs/nhibernate/archive/2008/10/21/entity-name-in-action-a-strongly-typed-entity.aspx

Inverts the next boolean

Defines how NHibernate will access the object for persisting/hydrating (Defaults to Property)

Implicit polymorphism

Explicit polymorphism

Takes a type that represents the level in the class/subclass-hiearchy that we're starting from, the parent, this can be a class or subclass; also takes a list of subclass providers. The providers are then iterated and added to a dictionary key'd by the types "distance" from the parentType; distance being the number of levels between parentType and the subclass-type. By default if the Parent type is an interface the level will always be zero. At this time there is no check for hierarchical interface inheritance.

Starting point, parent type. List of subclasses Dictionary key'd by the distance from the parentType.

The evalType starts out as the original subclass. The class hiearchy is only walked if the subclass inherits from a class that is included in the subclassProviders.

The evalType is always one class higher in the hiearchy starting from the original subclass. The class hiearchy is walked until the IsTopLevel (base class is Object) is met. The level is only incremented if the subclass inherits from a class that is also in the subclassProviders.

Defines a mapping for an entity subclass. Derive from this class to create a mapping, and use the constructor to control how your entity is persisted.

public class EmployeeMap : SubclassMap<Employee> { public EmployeeMap() { Map(x => x.Name); Map(x => x.Age); } } Entity type to map

(optional) Specifies that this subclass is abstract

Sets the dynamic insert behaviour

Sets the dynamic update behaviour

Specifies that this entity should be lazy loaded

Specify a proxy type for this entity

Proxy type

Specify a proxy type for this entity

Proxy type

Specify that a select should be performed before an update of this entity

Set the discriminator value, if this entity is in a table-per-class-hierarchy mapping strategy.

Discriminator value

Sets the table name

Table name

Sets the schema

Schema

Specifies a check constraint

Constraint name

Adds a column to the key for this subclass, if used in a table-per-subclass strategy.

Column name

Subselect query

Specifies a persister for this entity

Persister type

Specifies a persister for this entity

Persister type

Specifies a persister for this entity

Persister type

Set the query batch size

Batch size

Specifies an entity-name.

See http://nhforge.org/blogs/nhibernate/archive/2008/10/21/entity-name-in-action-a-strongly-typed-entity.aspx

Links this entity to another table, to create a composite entity from two or more tables. This only works if you're in a table-per-inheritance-hierarchy strategy.

Joined table name Joined table mapping Join("another_table", join => { join.Map(x => x.Name); join.Map(x => x.Age); });

(optional) Specifies the entity from which this subclass descends/extends.

Type of the entity to extend

(optional) Specifies the entity from which this subclass descends/extends.

Type of the entity to extend

Inverts the next boolean setting

Container for automatic mappings

Add automatic mappings

Lambda returning an auto mapping setup Auto mappings configuration

Add automatic mappings

Auto mapping setup Auto mappings configuration

Sets the export location for generated mappings

Path to folder for mappings Auto mappings configuration

Sets the text writer to write the generated mappings to.

Fluent mappings configuration

Applies any added mappings to the NHibernate Configuration

NHibernate Configuration instance

Gets whether any mappings were added

Initializes a new instance of the class using the MS Oracle Client (System.Data.OracleClient) library specifying the Oracle 9i dialect.

Initializes a new instance of the class using the MS Oracle Client (System.Data.OracleClient) library specifying the Oracle 10g dialect. This allows for ANSI join syntax.

Initializes a new instance of the class using the Oracle Data Provider (Oracle.DataAccess) library specifying the Oracle 8i dialect. The Oracle.DataAccess library must be available to the calling application/library.

Initializes a new instance of the class using the Oracle Data Provider (Oracle.DataAccess) library specifying the Oracle 9i dialect. The Oracle.DataAccess library must be available to the calling application/library.

Initializes a new instance of the class using the Oracle Data Provider (Oracle.DataAccess) library specifying the Oracle 10g dialect. The Oracle.DataAccess library must be available to the calling application/library. This allows for ANSI join syntax.

Specifies the server to connect. This can be either the DNS name of the server or the IP (as a string).

The server.

Specifies the instance (database name) to use. This can be the short name or the fully qualified name (Oracle service name).

The instance.

Specifies the name of the user account accessing the database.

The username.

Specifies the password of the user account accessing the database.

The password.

Optional. Ports the specified port the oracle database is running on. This defaults to 1521.

The port.

Enable or disable pooling connections for this data configuration.

if set to true enable pooling.

Specifies the SQL statement cache size to use for this connection.

Size of the cache.

Specifies, as a string, other Oracle options to pass to the connection.

The other options.

The type of authentication to be used. Acceptable values: SERVER SERVER_ENCRYPT DATA_ENCRYPT KERBEROS GSSPLUGIN

IfxDRDAConnectionStringBuilder object

The name of the database within the server instance.

IfxSQLIConnectionStringBuilder object

true - host variable (:param) support enabled. false (default) - host variable support disabled.

IfxSQLIConnectionStringBuilder object

Isolation level for the connection. Possible values: ReadCommitted ReadUncommitted RepeatableRead Serializable Transaction This keyword is only supported for applications participating in a distributed transaction.

IfxDRDAConnectionStringBuilder object

The maximum number of connections allowed in the pool.

IfxDRDAConnectionStringBuilder object

The minimum number of connections allowed in the pool. Default value 0.

IfxDRDAConnectionStringBuilder object

The password associated with the User ID.

IfxDRDAConnectionStringBuilder object

When set to true, the IfxConnection object is drawn from the appropriate pool, or if necessary, it is created and added to the appropriate pool. Default value 'true'.

IfxDRDAConnectionStringBuilder object

Server name with optional port number for direct connection using either IPv4 notation ([:]]]>) or IPv6 notation.

IfxDRDAConnectionStringBuilder object

The login account.

IfxDRDAConnectionStringBuilder object

Other options: Connection Lifetime, Connection Reset, Connection Timeout, CurrentSchema, Enlist, Interrupt, Persist Security Info, ResultArrayAsReturnValue, Security, TrustedContextSystemUserID, TrustedContextSystemPassword

IfxDRDAConnectionStringBuilder object

Client locale, default value is en_us.CP1252 (Windows)

IfxSQLIConnectionStringBuilder object

The name of the database within the server instance.

IfxSQLIConnectionStringBuilder object

The language locale of the database. Default value is en_US.8859-1

IfxSQLIConnectionStringBuilder object

When set to true or y for yes, any string within double quotes (") is treated as an identifier, and any string within single quotes (') is treated as a string literal. Default value 'y'.

IfxSQLIConnectionStringBuilder object

The name or IP address of the machine on which the Informix server is running. Required.

IfxSQLIConnectionStringBuilder object

The maximum number of connections allowed in the pool. Default value 100.

IfxSQLIConnectionStringBuilder object

The minimum number of connections allowed in the pool. Default value 0.

IfxSQLIConnectionStringBuilder object

The password associated with the User ID. Required if the client machine or user account is not trusted by the host. Prohibited if a User ID is not given.

IfxSQLIConnectionStringBuilder object

When set to true, the IfxConnection object is drawn from the appropriate pool, or if necessary, it is created and added to the appropriate pool. Default value 'true'.

IfxSQLIConnectionStringBuilder object

The name or alias of the instance of the Informix server to which to connect. Required.

IfxSQLIConnectionStringBuilder object

The service name or port number through which the server is listening for connection requests.

IfxSQLIConnectionStringBuilder object

The login account. Required, unless the client machine is trusted by the host machine.

IfxSQLIConnectionStringBuilder object

Other options like: Connection Lifetime, Enlist, Exclusive, Optimize OpenFetchClose, Fetch Buffer Size, Persist Security Info, Protocol, Single Threaded, Skip Parsing

IfxSQLIConnectionStringBuilder object

Fluent configuration API for NHibernate

Configure diagnostic logging

Diagnostic configuration

Apply database settings

Lambda returning database configuration Fluent configuration

Apply database settings

Database configuration instance Fluent configuration

Configure caching.

Cache(x => { x.UseQueryCache(); x.UseMinimalPuts(); }); Closure for configuring caching Configuration builder

Sets the collectiontype.factory_class property. NOTE: NHibernate 2.1 only

factory class Configuration

Sets the collectiontype.factory_class property. NOTE: NHibernate 2.1 only

factory class Configuration

Sets the collectiontype.factory_class property. NOTE: NHibernate 2.1 only

factory class Configuration

Sets the proxyfactory.factory_class property. NOTE: NHibernate 2.1 only

factory class Configuration

Sets the proxyfactory.factory_class property. NOTE: NHibernate 2.1 only

factory class Configuration

Sets the proxyfactory.factory_class property. NOTE: NHibernate 2.1 only

factory class Configuration

Sets the current_session_context_class property.

current session context class Configuration

Sets the current_session_context_class property.

Implementation of ICurrentSessionContext to use Configuration

Apply mappings to NHibernate

Lambda used to apply mappings Fluent configuration

Allows altering of the raw NHibernate Configuration object before creation

Lambda used to alter Configuration Fluent configuration

Verify's the configuration and instructs NHibernate to build a SessionFactory.

ISessionFactory from supplied settings.

Verifies the configuration and populates the NHibernate Configuration instance.

NHibernate Configuration instance

Creates an exception based on the current state of the configuration.

Inner exception FluentConfigurationException with state

Fluently configure NHibernate

Begin fluently configuring NHibernate

Fluent Configuration

Begin fluently configuring NHibernate

Instance of an NHibernate Configuration Fluent Configuration

Container for fluent mappings

Add all fluent mappings in the assembly that contains T.

Type from the assembly Fluent mappings configuration

Add all fluent mappings in the assembly

Assembly to add mappings from Fluent mappings configuration

Adds a single represented by the specified type.

Fluent mappings configuration

Adds a single represented by the specified type.

The type. Fluent mappings configuration

Sets the export location for generated mappings

Path to folder for mappings Fluent mappings configuration

Sets the text writer to write the generated mappings to.

Fluent mappings configuration

Applies any added mappings to the NHibernate Configuration

PersistenceModel to alter

Alter convention discovery

Gets whether any mappings were added

Container for Hbm mappings

Add explicit classes with Hbm mappings

List of types to map Hbm mappings configuration

Add all Hbm mappings in the assembly that contains T.

Type from the assembly Hbm mappings configuration

Add all Hbm mappings in the assembly

Assembly to add mappings from Hbm mappings configuration

Applies any added mappings to the NHibernate Configuration

NHibernate Configuration instance

Gets whether any mappings were added

Fluent mapping configuration

Applies any mappings to the NHibernate Configuration

Diagnostics logger NHibernate Configuration instance

Fluent mappings

Automatic mapping configurations

Hbm mappings

Get whether any mappings of any kind were added

Convention finder - used to search through assemblies for types that implement a specific convention interface.

Add a source to be queried.

Source to query

Add an assembly to be queried.

All convention types must have a parameterless constructor, or a single parameter of . Assembly instance to query

Adds all conventions found in the assembly that contains .

All convention types must have a parameterless constructor, or a single parameter of .

Add a single convention by type.

Type must have a parameterless constructor, or a single parameter of . Convention type

Add a single convention by type.

Types must have a parameterless constructor, or a single parameter of . Type of convention

Add an instance of a convention.

Useful for supplying conventions that require extra constructor parameters. Convention type Instance of convention

Find any conventions implementing T.

Convention interface type IEnumerable of T

Default convention finder - doesn't do anything special.

Find any conventions implementing T.

Convention interface type IEnumerable of T

Add an assembly to be queried.

All convention types must have a parameterless constructor, or a single parameter of IConventionFinder. Assembly instance to query

Adds all conventions found in the assembly that contains T.

All convention types must have a parameterless constructor, or a single parameter of IConventionFinder.

Add a single convention by type.

Type must have a parameterless constructor, or a single parameter of IConventionFinder. Convention type

Add a single convention by type.

Types must have a parameterless constructor, or a single parameter of . Type of convention

Add an instance of a convention.

Useful for supplying conventions that require extra constructor parameters. Convention type Instance of convention

Indicates whether the current is equal to another .

true if the current object is equal to the parameter; otherwise, false. An Entity to compare with this object.

Determines whether the specified is equal to the current .

true if the specified is equal to the current ; otherwise, false. The to compare with the current . The parameter is null.2

Serves as a hash function for a Entity.

A hash code for the current . 2

Set which type this subclass extends. Note: This doesn't actually get output into the XML, it's instead used as a marker for the to pair things up.

Represents the "Any" mapping in NHibernate. It is impossible to specify a foreign key constraint for this kind of association. For more information please reference chapter 5.2.4 in the NHibernate online documentation

Sets the meta-type value for this any mapping.

Meta type

Sets the meta-type value for this any mapping.

Meta type

Sets the meta-type value for this any mapping.

Meta type

Defines how NHibernate will access the object for persisting/hydrating (Defaults to Property)

Cascade style (Defaults to none)

Access strategy mapping builder.

Sets the access-strategy to property.

Sets the access-strategy to field.

Sets the access-strategy to use the backing-field of an auto-property.

Sets the access-strategy to readonly.

Sets the access-strategy to field and the naming-strategy to camelcase (field.camelcase).

Sets the access-strategy to field and the naming-strategy to camelcase, with the specified prefix.

Naming-strategy prefix

Sets the access-strategy to field and the naming-strategy to lowercase.

Sets the access-strategy to field and the naming-strategy to lowercase, with the specified prefix.

Naming-strategy prefix

Sets the access-strategy to field and the naming-strategy to pascalcase, with the specified prefix.

Naming-strategy prefix

Sets the access-strategy to read-only property (nosetter) and the naming-strategy to camelcase.

Sets the access-strategy to read-only property (nosetter) and the naming-strategy to camelcase, with the specified prefix.

Naming-strategy prefix

Sets the access-strategy to read-only property (nosetter) and the naming-strategy to lowercase.

Naming-strategy prefix

Sets the access-strategy to read-only property (nosetter) and the naming-strategy to pascalcase, with the specified prefix.

Naming-strategy prefix

Sets the access-strategy to use the type referenced.

Assembly qualified name of the type to use as the access-strategy

Sets the access-strategy to use the type referenced.

Type to use as the access-strategy

Sets the access-strategy to use the type referenced.

Type to use as the access-strategy

Force NHibernate to always select using the discriminator value, even when selecting all subclasses. This can be useful when your table contains more discriminator values than you have classes (legacy).

Sets the "force" attribute.

Set this discriminator as read-only. Call this if your discriminator column is also part of a mapped composite identifier.

Sets the "insert" attribute.

An arbitrary SQL expression that is executed when a type has to be evaluated. Allows content-based discrimination.

SQL expression

Sets the precision for decimals

Decimal precision

Specifies the scale for decimals

Decimal scale

Specify the column length

Column length

Specify the nullability of this column

Specifies the uniqueness of this column

Specifies the unique key constraint name

Constraint columns

Specifies the index name

Index name

Specifies a check constraint name

Constraint name

Specifies the default value for the discriminator

Default value

Specifies a custom type for the discriminator

This is often used with Custom type

Specifies a custom type for the discriminator

This is often used with Custom type

Specifies a custom type for the discriminator

This is often used with Custom type

Specifies a custom SQL type for the discriminator.

Custom SQL type.

Invert the next boolean operation

Pre-defined discriminator values

Null discriminator value

Non-null discriminator value

Specify the element column name

Column name

Specify the element type

Element type

Specify the element column length

Column length

Specify the element column formula

Formula

Modify the columns for this element

Sets caching to read-write

Sets caching to non-strict read-write

Sets caching to read-only

Sets caching to transactional

Specifies a custom cache behaviour

Custom behaviour

Specifies the cache region

Include all properties for caching

Include only non-lazy properties for caching

Specify a custom property inclusion strategy

Inclusion strategy

Base class for user type conventions. Create a subclass of this to automatically map all properties that the user type can be used against. Override Accept or Apply to alter the behavior.

IUserType implementation

Base class for attribute based conventions. Create a subclass of this to supply your own attribute based conventions.

Attribute identifier

Apply changes to a property with an attribute matching T.

Instance of attribute found on property. Property with attribute

Cascade all actions

Cascade no actions

Cascade saves and updates

Cascade deletes

Cascade all actions, deleting any orphaned records

Cascade deletes, deleting any orphaned records

Map a property

Dictionary key Map("Age");

Map a property

Dictionary key Property type Map<int>("Age");

Join fetching

Select fetching

Subselect/subquery fetching

Specifies an entity-name.

See http://nhforge.org/blogs/nhibernate/archive/2008/10/21/entity-name-in-action-a-strongly-typed-entity.aspx

Thrown when a prefix is specified for an access-strategy that isn't supported.

Naming strategy prefix.

Property is never database generated

Property is only generated on insert

Property is always database generated

Checks a list of components for validity.

Entity type Type of list element Persistence specification Property Value to save Equality comparer

Converts an expression to a best guess SQL string

Converts a Func expression to a best guess SQL string

Converts a boolean Func expression to a best guess SQL string

Gets the value of a method call.

Method call expression

Specify an alternative name for the type

Alternative name

Used to set the Not-Found attribute to ignore. This tells NHibernate to return a null object rather then throw an exception when the join fails

Used to set the Not-Found attribute to exception (Nhibernate default). This tells NHibernate to throw an exception when the join fails

Specifies the child class

Child

Specifies the child class

Child

Specifies that this relationship should be created with a default-named foreign-key

Specify the foreign-key constraint name

Foreign-key constraint

Sets the property reference

Property

Sets the property reference

Property

Specifies that this relationship is constrained

Specify the lazy behaviour of this relationship.

Defaults to Proxy lazy-loading. Use the modifier to disable lazy-loading, and use the overload to specify alternative lazy strategies. LazyLoad(); Not.LazyLoad();

Specify the lazy behaviour of this relationship. Cannot be used with the modifier.

Laziness strategy LazyLoad(Laziness.NoProxy);

Specifies an entity-name.

See http://nhforge.org/blogs/nhibernate/archive/2008/10/21/entity-name-in-action-a-strongly-typed-entity.aspx

Sets the fetch behaviour for this relationship

Fetch.Select();

Sets the cascade behaviour for this relationship

Cascade.All();

Specifies the access strategy for this relationship

Access.Field();

Inverts the next boolean operation

No optimistic locking

Version locking

Dirty locking

Lock on everything

Use no locking strategy

Use version locking

Use dirty locking

Use all locking

This method is used to set a different key column in this table to be used for joins. The output is set as the property-ref attribute in the "key" subelement of the collection

The name of the column in this table which is linked to the foreign key OneToManyPart

Specify the lazy-load behaviour

Specify extra lazy loading

Inverse the ownership of this entity. Make the other side of the relationship responsible for saving.

Use a set collection

Sorting

Use a set collection

Item comparer

Use a bag collection

Use a list collection

Use a list collection with an index

Index mapping

Use a map collection

Index type Index property

Use a map collection

Index type Index property Sorting

Use a map collection

Index column name

Use a map collection

Index column name Sorting

Use a map collection

Index type Index column name

Use a map collection

Index type Index column name Sorting

Use a map collection

Index type Comparer Index column name

Use a map collection

Index type Index property Index mapping

Use a map collection

Index type Index property Index mapping Sorting

Use a map collection

Index type Index mapping Element mapping

Use an array

Index type Index property

Use an array

Index type Index property Index mapping

Make this collection indexed

Index type Index property Index mapping

Make this collection index

Index type Index column Index mapping

Map an element/value type

Column name

Map an element/value type

Column name Custom mapping

Maps this collection as a collection of components.

Component mapping

Sets the table name for this one-to-many.

Table name

Specify that the deletes should be cascaded

Specify a custom persister

Persister

Specify a check constraint

Constraint name

Specify that this collection is generic (optional)

Sets the where clause for this one-to-many relationship. Note: This only supports simple cases, use the string overload for more complex clauses.

Sets the where clause for this one-to-many relationship.

Specify the select batch size

Batch size

Sets a custom collection type

Specify the table schema

Schema name

Specifies an entity-name.

See http://nhforge.org/blogs/nhibernate/archive/2008/10/21/entity-name-in-action-a-strongly-typed-entity.aspx Applies a filter to this entity given it's name.

Applies a filter to this entity given it's name.

The filter's name The condition to apply Applies a filter to this entity given it's name.

Applies a filter to this entity given it's name.

The filter's name Applies a named filter to this one-to-many.

Applies a named filter to this one-to-many.

The condition to apply The type of a implementation defining the filter to apply.

Applies a named filter to this one-to-many.

The type of a implementation defining the filter to apply.

Specify caching for this entity.

Specify the cascade behaviour

Specify the fetching behaviour

Set the access and naming strategy for this one-to-many.

Specify the optimistic locking behaviour

Inverts the next boolean operation

Access strategy mapping builder.

Mapping part to be applied to

Access strategy mapping builder.

Instance of the parent mapping part. Setter for altering the model

Sets the access-strategy to property.

Sets the access-strategy to field.

Sets the access-strategy to use the backing-field of an auto-property.

Sets the access-strategy to readonly.

Sets the access-strategy to field and the naming-strategy to camelcase (field.camelcase).

Sets the access-strategy to field and the naming-strategy to camelcase, with the specified prefix.

Naming-strategy prefix

Sets the access-strategy to field and the naming-strategy to lowercase.

Sets the access-strategy to field and the naming-strategy to lowercase, with the specified prefix.

Naming-strategy prefix

Sets the access-strategy to field and the naming-strategy to pascalcase, with the specified prefix.

Naming-strategy prefix

Sets the access-strategy to read-only property (nosetter) and the naming-strategy to camelcase.

Sets the access-strategy to read-only property (nosetter) and the naming-strategy to camelcase, with the specified prefix.

Naming-strategy prefix

Sets the access-strategy to read-only property (nosetter) and the naming-strategy to lowercase.

Naming-strategy prefix

Sets the access-strategy to read-only property (nosetter) and the naming-strategy to pascalcase, with the specified prefix.

Naming-strategy prefix

Sets the access-strategy to use the type referenced.

Assembly qualified name of the type to use as the access-strategy

Sets the access-strategy to use the type referenced.

Type to use as the access-strategy

Sets the access-strategy to use the type referenced.

Type to use as the access-strategy

Specify the lazy-load behaviour

Component-element for component HasMany's.

Component type

Map a property

Property Map(x => x.Age);

Map a property

Property Column name Map(x => x.Age, "person_age");

Create a reference to another entity. In database terms, this is a many-to-one relationship.

Other entity Property on the current entity References(x => x.Company);

Create a reference to another entity. In database terms, this is a many-to-one relationship.

Other entity Property on the current entity Column name References(x => x.Company, "person_company_id");

Maps a property of the component class as a reference back to the containing entity

Parent reference property Component being mapped

Create a nested component mapping.

Component property Action for creating the component HasMany(x => x.Locations) .Component(c => { c.Map(x => x.Name); c.Component(x => x.Address, addr => { addr.Map(x => x.Street); addr.Map(x => x.PostCode); }); });

generates identifiers of any integral type that are unique only when no other process is inserting data into the same table. Do not use in a cluster.

Params configuration

The table. The column. The max lo. The where.

Params configuration

uses an Oracle-style sequence (where supported)

Params configuration

uses System.Guid and its ToString(string format) method to generate identifiers of type string. The length of the string returned depends on the configured format.

http://msdn.microsoft.com/en-us/library/97af8hh4.aspx

uses System.Guid and its ToString(string format) method to generate identifiers of type string. The length of the string returned depends on the configured format.

http://msdn.microsoft.com/en-us/library/97af8hh4.aspx Params configuration

uses a new System.Guid to create a byte[] that is converted to a string.

Params configuration

uses a new System.Guid as the identifier.

Params configuration

Recommended for Guid identifiers! uses the algorithm to generate a new System.Guid described by Jimmy Nilsson in the article http://www.informit.com/articles/article.asp?p=25862.

Params configuration

lets the application to assign an identifier to the object before Save() is called.

Params configuration

picks identity, sequence or hilo depending upon the capabilities of the underlying database.

Params configuration

picks identity, sequence or hilo depending upon the capabilities of the underlying database.

uses the identifier of another associated object. Usually used in conjunction with a one-to-one primary key association.

Params configuration

GuidNative(x => { x.AddParam("key", "value"); }); Parameter builder closure

Select(x => { x.AddParam("key", "value"); }); Parameter builder closure

Custom sequence name

Parameter builder closure

Custom sequence name Parameter builder closure

Parameter builder closure

Sets the unsaved-value of the identity.

Value that represents an unsaved value.

Sets the column name for the identity field.

Column name

Specify the identity column length

Column length

Specify the decimal precision

Decimal precision

Specify the decimal scale

Decimal scale

Specify the nullability of the identity column

Specify the uniqueness of the identity column

Specify a unique key constraint

Constraint columns

Specify a custom SQL type

SQL type

Specify an index name

Index name

Specify a check constraint

Constraint name

Specify a default value

Default value

Specify a custom type

This is usually used with an Custom type

Specify a custom type

This is usually used with an Custom type

Specify a custom type

This is usually used with an Custom type

Specify the generator

Id(x => x.PersonId) .GeneratedBy.Assigned();

Set the access and naming strategy for this identity.

Invert the next boolean operation

Sets a single child key column. If there are multiple columns, use ChildKeyColumns.Add

Sets a single parent key column. If there are multiple columns, use ParentKeyColumns.Add

Sets the order-by clause on the collection element.

Sets the order-by clause on the many-to-many element.

Applies a filter to the child element of this entity given it's name.

The filter's name The condition to apply Applies a filter to the child element of this entity given it's name.

Applies a filter to the child element of this entity given it's name.

The filter's name Applies a named filter to the child element of this many-to-many.

Applies a named filter to the child element of this many-to-many.

The condition to apply The type of a implementation defining the filter to apply.

Applies a named filter to the child element of this many-to-many.

The type of a implementation defining the filter to apply.

Sets the where clause for this relationship, on the many-to-many element.

Sets whether this relationship is unique

Unique(); Not.Unique();

Specifies the name of a multi-column unique constraint.

Name of constraint

Specifies the index name

Index name

Specifies the child class of this relationship

Child

Specifies the child class of this relationship

Child

Sets this relationship to read-only

This is the same as calling both Not.Insert() and Not.Update() ReadOnly(); Not.ReadOnly();

Specify the lazy behaviour of this relationship.

Defaults to Proxy lazy-loading. Use the modifier to disable lazy-loading, and use the overload to specify alternative lazy strategies. LazyLoad(); Not.LazyLoad();

Specify the lazy behaviour of this relationship. Cannot be used with the modifier.

Laziness strategy LazyLoad(Laziness.NoProxy);

Specifies this relationship should be created with a default-named foreign key.

Specifies the foreign-key constraint name

Constraint name

Specifies that this relationship is insertable

Specifies that this relationship is updatable

Sets the single column used in this relationship. Use if you need to specify more than one column.

Column name

Specifies the columns used in this relationship

Columns

Specifies the columns used in this relationship

Columns

Specifies the sql formula used for this relationship

Formula

Specifies the property reference

Property

Specifies the property reference

Property

Sets this relationship to nullable

Nullable(); Not.Nullable();

Specifies an entity-name.

See http://nhforge.org/blogs/nhibernate/archive/2008/10/21/entity-name-in-action-a-strongly-typed-entity.aspx

Set the fetching strategy

Fetch.Select();

Set the behaviour for when this relationship is null in the database

NotFound.Exception();

Specifies the cascade behaviour for this relationship

Cascade.All();

Specifies the access strategy for this relationship

Access.Field();

Inverts the next boolean

Specify that this is a ternary association

Index column

Specify this as an entity map

Index column

Specify the key column name

Column name

Specify a foreign key constraint

Constraint name

Sets the order-by clause for this one-to-many relationship.

Specify that this collection is read-only

Specify a sub-select query for fetching this collection

Query

Specify that the key is updatable

Specify that the key is nullable

Specifies the behaviour for if this collection is not found

Specify the cascade behaviour

Modify the key columns collection

Specify the property column name

Column name

Specify that this property is insertable

Specify that this property is updatable

Specify the column length

Column length

Specify the nullability of this property

Specify that this property is read-only

Specify the property formula

Formula

Specify the lazy-loading behaviour

Specify an index name

Index name

Specifies that a custom type (an implementation of ) should be used for this property for mapping it to/from one or more database columns whose format or type doesn't match this .NET property.

A type which implements . This property mapping to continue the method chain

Specifies that a custom type (an implementation of ) should be used for this property for mapping it to/from one or more database columns whose format or type doesn't match this .NET property.

A type which implements . This property mapping to continue the method chain

Specifies that a custom type (an implementation of ) should be used for this property for mapping it to/from one or more database columns whose format or type doesn't match this .NET property.

A type which implements . This property mapping to continue the method chain

Specifies that a custom type (an implementation of ) should be used for this property for mapping it to/from one or more database columns whose format or type doesn't match this .NET property.

A function which returns a type which implements . The argument of the function is the mapped property type This property mapping to continue the method chain

Specify a custom SQL type

SQL type

Specify that this property has a unique constranit

Specify decimal precision

Decimal precision

Specify decimal scale

Decimal scale

Specify a default value

Default value

Specifies the name of a multi-column unique constraint.

Name of constraint

Specify that this property is optimistically locked

Specify a check constraint

Constraint name

Specify if this property is database generated

Generated.Insert();

Modify the columns collection

Set the access and naming strategy for this property.

Inverts the next boolean

Specify the column name

Column name

Specify the unsaved value

Unsaved value

Specify the column length

Column length

Specify decimal precision

Decimal precision

Specify decimal scale

Decimal scale

Specify the nullability of the column

Specify the uniqueness of the column

Specify a unique key constraint

Constraint columns

Specify an index name

Index name

Specify a check constraint

Constraint name

Specify a default value

Default value

Specify a custom type

Usually used with an Custom type

Specify a custom type

Usually used with an Custom type

Specify a custom type

Usually used with an Custom type

Specify a custom SQL type

SQL type

Specify if this version is database generated

Specify the access strategy

Invert the next boolean operation

Returns whether the user has set a value for a property.

Returns whether a property has any value, default or user specified.

Reveals a hidden property or field for use instead of expressions.

Entity type Name of property or field Expression for the hidden property or field

Reveals a hidden property or field with a specific return type for use instead of expressions.

Entity type Property or field return type Name of property or field Expression for the hidden property or field

Visitor that performs validation against the mapping model.

Gets or sets whether validation is performed.