[Study Note] NHibernate In Action 20100521

NHibernate In Action

Part 1 Discovering ORM with NHibernate

1 Object/relational persistence in .NET

ORM object/relational mapping

1.1 What is persistence?

1.1.1 Relational database 1.1.2 Understanding SQL SQL Tuning by Dan Tow [Tow 2003]
SQL Cookbook by Anthony Molinaro [Mol 2005]
An Introduction to Database Systems [Date 2004]

1.1.3 Using SQL in .NET application Patterns of Enterprise Application Architecture by Martin Fowler [Fowler 2003]

1.1.4 Persistence in object-oriented applications persistent object
transient object

[GOF 1995]

1.1.5 Persistence and the layered architecture Presentation layer
Business layer
Persistence layer
Database
Helper/utility classes

1.2 Approaches to persistence in .NET

1.2.1 Choice of persistence layer (p9 2010-05-20 17:15)

hand-coded persistence layer
dataset-based persistence layer
NHibernate persistence layer
LINQ to SQL-based persistence layer
ADO.NET Entity Framework

1.2.2 Implementing the entities hand-coded entities
entities in a dataset
entities and NHibernate
entities and LINQ to SQL

paradigm mismatch / object/relational impedance mismatch

1.2.3 Displaying entities in the user interface Dataset-based persentation layer
Persentation layer and entities

ObjectViews

1.2.4 Implementing CRUD operations hand-coded CRUD operations
CRUD operations with datasets
CRUD operations using NHibernate
LINQ to SQL CRUD operations

table adapters

1.3 Why do we need NHibernate ?

productivity, maintainability and performance

1.3.1 The paradigm mismatch The problem of granularity
The problem of inheritance and polymorphism
The problem of identity
problem relating to associations

primary key / surrogate key

1.3.2 Units of work and conversations conversation / business transactions / application transactions

The Unit of Work Pattern
The Identity Map pattern
Transparent persistence and lazy loading
Caching

1.3.3 Complex queries and the ADO.NET Entity Framework Implementing a query engine

HQL - Hibernate Query Language
QBC - Query by Criteria API

ADO.NET Entity Framework

1.4 object/relation mapping

1.4.1 what is ORM object/relational mapping is the automated (and possibly transparent) persistence of objects in an application to the tables in a relational database, using metadata that describes the mapping between the objects and the database.

ORM, in essence, works by transforming data from one representation to another.

entity-relationship modeling, ERM
object role modeling, ORM

1.4.2 why ORM ? modeling mismatch
productivity and maintainability
performance
database independence

(p24 2010-05-20 18:20)

2 Hello NHibernate

2.1 "Hello World" with NHibernate

2.1.1 Installing NHibernate 2.1.2 Create a new Visual Studio project 2.1.3 Creating the Employee class 2.1.4 Setting up the database 2.1.5 Creating an Employee and saving to the database 2.1.6 Loading an Employee from the database 2.1.7 Creating a mapping file 2.1.8 Configuring your application 2.1.9 Updating an Employee 2.1.10 Running the program The persistent class can be used with or without NHibernate

Enbedded Resource

automatic dirty checking
cascading save
transactional write-behind

2.2 Understanding the architecture

2.2.1 The core interface ISession interface
ISessionFactory interface
Configuration interface
ITransaction interface
IQuery and ICriteria interface

An instance of ISession is lightweight and is inexpensive to create and destroy.

2.2.2 Callback interface Callback interfaces allow the application to receive a notification when something interesting happens to an object.

ILifecycle interface
IValidatable interface

persistence lifecycle

2.2.3 Types An NHibernate Type object maps a .NET type to a database column type (the type may span multiple columns).

custom types

IUserType, ICompositeUserType, IParameterizedType, IUserCollectionType

2.2.4 Extension interface Primary-key generation (IIdentifierGenerator interface)
SQL dialect support (Dialect abstract class)
Caching strategies (ICache and ICacheProvider interface)
ADO.NET connection management (IConnectionProvider interface)
Transaction management (ITransactionFactory and ITransaction interface)
ORM strategies (IClassPersister interface hierarchy)
Property-access strategies (IPropertyAccessor interface)
Proxy creation (IProxyFactory interface)

2.3 Basic configuration

2.3.1 Creating a SessionFactory Method chaining

Method chaining is a programming style supported by many NHibernate interfaces (they're also called fluent interfaces).

If you use the coding style of Method chaining, it's better to write each method invocation on a different line.

one mapping file per class

working with mapping files

Multiple database and session factories

Configuration techniques

2.3.2 Configuring the ADO.NET database access Configuring NHibernate using hibernate.cfg.xml

connection.provider
dialect
connection.driver_class
connection.connection_string
Starting NHibernate

If your database's ADO.NET data provider isn't ye installed, download and install it.
Add log4net.dll as reference to your project.
Decide which database-access properties NHibernate will need.
Let the Configuration know about these properties by placing them in a hibernate.cfg.xml file in the current directory.
Create an instance of Configuration in your application, call the Configure() method; load the mapped class ( with .NET attributes ) using HbmSerializer.Default.Serialize() and AddInputStream(); and load the XML mapping files using either AddAssembly(), AddClass(), or AddXmlFile(). Build an ISessionFactory instance from the Configruation by calling BuildSessionFactory().
Remember to close the instance of ISessionFactory( using MySessionFactory.Close() ) when you're done using NHibernate.

2.4 Advanced configuration settings

2.4.1 Using the application configuration file When configure() is called, NHibernate first searches for the information in the application configuration file and then in a file named hibernate.cfg.xml in the current directory.

<session-factory name="MySessionFactory">

NHibernate.Impl.SessionFactoryObjectFactory.GetNamedInstance()

2.4.2 Loging write-behind