Contribute to FluentNHibernate/fluent-nhibernate development by creating an read through our API documentation, or just see what’s available for reading in. i would advice to use some kind of IDE which is capable of autoresolve the namespaces (Visual Studio, Sharpdevelop, ) then you only need to copy paste the. Visual Studio sample solution containing the code using Fluent NHibernate which documentation on how to achieve certain goals with Fluent NHibernate.

Author: Tauran Yozshule
Country: China
Language: English (Spanish)
Genre: History
Published (Last): 4 January 2006
Pages: 189
PDF File Size: 15.84 Mb
ePub File Size: 5.55 Mb
ISBN: 181-8-21672-258-9
Downloads: 86311
Price: Free* [*Free Regsitration Required]
Uploader: Maushura

Mapping contains classes used to create Fluent Mappings. I have been using Reflector to find things and it works, but it is not ideal. HasOne is usually reserved for a special case, generally you’d use a References in most situations see: Cfg fluently configuring the NHibernate. For example if you wanted to specify the cascade strategy you’d use the Cascade property.

We’ll go into each in more detail next. Retrieved from ” http: Firo 28k 4 45 A reference is to a single instance of an entity, if you’re mapping a collection then you need either HasMany or an HasManyToMany which can be viewed as the “other side” of the References relationship. There are a few different types of collections you can use, and they’re all available under the HasMany call. The Component method takes two parameters, rather than just one like the rest of the methods you’ve seen so far.

Every mapping requires an Id of some kind, these are mapped using the Id method; this method takes a lambda expression of the property you want to use as your Id. Fluent NHibernate knows what the return type of your property is, and assumes that the column it’s mapping against will have the same name as the property itself.

The first column holds the type of the associated entity. There are a few different types of collections you can use, and they’re all available under the HasManyToMany call. You should use this only in very special cases eg. Property mappings make up a large amount of any mapped domain, so it’s best that you know how to map them. Automapping all you need to automaticly create mappings for classes. The remaining columns hold the identifier.


As you can see, the first parameter references the Address property on our entity, which is the property that holds our component. Depending on the return type of the property you supply, Fluent NHibernate will make some assumptions about documentstion kind of identifier you’re using.

Fluent NHibernate API documentation – Stack Overflow

For example, if we were to need to change what column the property maps to we could use the Column method, or for explicitly specifying the identity generator you could use the GeneratedBy property.

For example, if you’re generating your schema you may want to specify whether the column itself is nullable, you can do that by using the Nullable method and optionally the Not operator property. My biggest obstacle to getting the hang of Fluent NHibernate so far has been finding the namespaces for the classes that I need to work through samples I find blog posts, SO questions, etc.

Subclasses work in a very similar way to ClassMap’sin that you create a derived class docuentation you put your mappings in; it’s just you use SubclassMap instead of ClassMap. Table-per-subclass is the default mapping for subclasses, so unless you say otherwise you’ll have a separate table per-subclass.

To quote the NHibernate documentation:.

Fluent NHibernate – The official website

In database terms that would be a book table with a foreign key column referencing the primary key of a author table. Conventions Interfaces to define Conventions used for Auto and Fluent mappings. The second property is where we define what makes up the component. It is impossible to specify a foreign key constraint for this kind of association, so this is most certainly not meant as the usual way of mapping polymorphic associations.

Stack Overflow works best with JavaScript enabled. Customisations can be done by chaining methods off the Id call. If you really do want a one-to-one, then you can use the HasOne method. It’s a fluent interface that allows you to map your entities completely in code, with all the compile-time safety and refactorability that brings. They’re just as simple as identities, except we use the Map method.


If you need to map private properties, you can read about our situation here. The first parameter is a property accessor lambda, like all the other methods, and the second one is another lambda quite often referred to as a nested-closure in these situations that defines a new scope for defining the mappings of that particular sub-part in this case the component.

You’ll quickly get used to these lambdas, as they’re used everywhere in Fluent NHibernate. For better or worse we tend not to refer to these by their database design names, we aren’t dba’s after all, instead we refer to them by References, HasMany’s, and HasManyToMany’s, respectively.

Any really only should be used if you know what you’re doing. The main ones you’ll normally use are many-to-one’s, one-to-many’s, and many-to-many’s. Once you’ve read that then you should be able to find a bit more detail here. In this case we’ve mapped a component stored in the Address propertythat’s made up of three properties Number, Street, and PostCode ; these properties are stored in the same table as the parent entity in a normalized fashion.

There are several methods available that map your properties in different ways, and each one of those is a method chain that you can use to customise the individual mapping.

This type of mapping always requires more than one column.

In this example we’re specifying that the Id property is mapped to a PersonId column in the database, and it’s using an assigned generator.

Author: admin