NHibernate 3 Beginner's Guide

Table of Contents

• Preface

• Chapter 1: First Look
• What is NHibernate
• What is new in NHibernate 3.0
• Why would I use it
• Where do I get it
• Is there documentation available
• Can I get help using NHibernate
• Is there commercial support available
• Who uses it
• Summary

• Chapter 2: A First Complete Sample
• Prepare our development environment
• Defining a model
• Time for action – Creating the product inventory model
• Mapping our model
• Time for action – Creating the mapping classes
• Creating the database schema
• Time for action – Creating the database
• Creating a session factory
• Time for action – Creating a session factory
• Opening a session
• Time for action – Opening a session to the database
• Persisting objects to the database
• Time for action – Adding a new category to the database
• Reading from the database
• Time for action – Loading the list of all categories from the database
• Doing the same without NHibernate – using ADO.NET only
• Summary

• Chapter 3: Creating a Model
• What is a model
• Model first versus data first
• Elements of a model
• Entity
• Value object
• Time for action – Creating a Name value object
• Creating an entity
• Time for action – Creating a base entity
• Time for action – Creating a Customer entity
• Defining relations between entities
• Owns or contains
• One-to-many
• One-to-one
• Many-to-many
• The order entry model
• Time for action – Implementing an order entry model
• Summary

• Chapter 4: Defining the Database Schema
• What is a database schema
• Who owns the database
• Time for action – Creating the OrderingSystem database
• Laying the foundation – table layouts
• Time for action – Creating the Categories table
• Time for action – Defining a script to create the Products table
• Table columns
• Data types of table columns
• Relations, constraints, and indices
• Relations
• Constraints
• Time for action – Adding a constraint to the Product table
• Time for action – Creating a script to add a check constraint
• Indices
• Time for action – Adding an index using the designer
• Time for action – Creating a script to add an index
• Normal form
• Putting it all together
• Time for action – Creating a schema for the order entry system
• Do not use database-generated IDs
• Views
• What about stored procedures and triggers
• Summary

• Chapter 5: Mapping the Model to the Database
• What is mapping?
• Types of mapping
• XML-based mapping
• Attribute-based mapping
• Fluent mapping
• Mapping by convention
• A word about lazy loading
• Loading data on demand
• Proxies
• Virtual properties and methods
• Creating database schema creation scripts
• Fluent mapping
• Expression trees – please explain
• Getting started
• Classes
• Entity level settings
• ID columns
• Properties
• References
• Collections
• Mapping many-to-many relations
• Mapping value objects
• Time for action – Mapping our domain
• Use mapping conventions
• ID conventions
• Property conventions
• Foreign key conventions
• No mapping; is that possible?
• Auto-mapping with Fluent NHibernate
• Time for action – Using auto-mapping
• Using ConfORM
• Time for action – Using ConfORM to map our domain
• XML mapping
• Getting started
• Classes
• Properties
• ID columns
• One-to-many relations
• Many-to-many relations
• Mapping value objects
• Time for action – Mapping a simple domain using XML
• Summary

• Chapter 6: Sessions and Transactions
• What are sessions and transactions
• Session
• Transaction
• The session factory
• Creating your first session
• Why do we call Commit?
• Adding new data to the database
• Reading data from the database
• Get versus Load
• Updating existing data
• Deleting data
• First level cache or identity map
• Clearing the cache
• Refreshing entities in the cache
• No database operation without a transaction
• Should I use transactions when querying data?
• NHibernate session versus database session
• Time for action – Creating a session and doing some CRUD
• Session management
• Web-based applications
• Time for action –Implementing session management for a web application
• WinForm or WPF applications
• Windows services
• Unit of Work
• Handling exception
• Second level cache
• Cache regions
• Second level cache implementations
• Time for action – Using a second level cache
• Summary

• Chapter 7: Testing, Profiling, Monitoring, and Logging
• Why do we need tests?
• What should we test?
• What about the database?
• Download SQLite
• Preparing our environment for testing
• Testing the mapping
• Testing the mapping with Fluent NHibernate
• Time for action – Creating the base for testing
• Time for action – Using SQLite in our tests
• Testing queries
• Logging
• Why do we need to log?
• Logging with Log4Net
• Time for action – Adding logging to our application
• Setting up logging for NHibernate
• Time for action – Enable logging in NHibernate
• Monitoring and profiling
• Analyzing log files
• Using SQL Server Profiler
• Monitoring and profiling with NHibernate Profiler
• Time for action – Adding NHibernate Profiler support
• Summary

• Chapter 8: Configuration
• Why do we need a configuration?
• Elements of the configuration
• Which database do we want to use?
• What byte code provider and proxy factory?
• Where are our mappings?
• Do we use second level caching?
• Do we want to extend NHibernate?
• XML configuration
• Time for action – Configuring NHibernate using XML
• Configuring NHibernate in code
• Time for action – Configuring NHibernate in code
• Fluent configuration
• Configuring NHibernate with Loquacious
• Time for action – Using Loquacious to configure NHibernate
• Configuring NHibernate with Fluent NHibernate
• Convention over configuration
• Summary

• Chapter 9: Writing Queries
• How can we get to our data?
• The LINQ to NHibernate provider
• Defining the root of our query
• Limiting the number of records returned
• Filtering a set of records
• Mapping a set of records
• Sorting the resulting set
• Grouping records
• Forcing a LINQ query to execute immediately
• Changing from querying the database to querying in-memory objects
• Creating a report using LINQ to NHibernate
• Time for action – Preparing the system
• Time for action – Creating the reports
• Criteria queries
• Untyped criteria queries
• Strongly-typed criteria queries
• Time for action – Using QueryOver to retrieve data
• Hibernate Query Language
• Lazy loading properties
• Executing multiple queries in a batch
• Eager loading versus lazy loading
• Bulk data changes
• Summary

• Chapter 10: Validating the Data to Persist
• What is validation and why is it so important?
• Who owns the database?
• Why, what, and where do we validate?
• Why validate?
• What data?
• Where to validate?
• Validating single properties
• Configuring the validator
• Defining validation rules
• Fluently configure validation rules
• Enforcing validation
• Time for action – Using property validation
• Validating complex business rules
• Enforcing always valid entities
• Using validation classes
• Time for action – Validating user input
• What to do if we don't own the database?
• Summary

• Chapter 11: Common Pitfalls—Things to Avoid
• Requesting the obvious
• Wrong mapping for read-only access
• Blindly relying on NHibernate
• Using implicit transactions
• Using database-generated IDs
• Using LINQ to NHibernate the wrong way
• The trouble with lazy loading
• The select (n+1) problem
• Accessing lazy loaded parts after the session is closed
• Did I just load the whole database?
• Using one model for read and write operations
• CQRS
• Phantom updates
• Time for action – Causing a phantom update
• Using NHibernate to persist any type of data
• Summary

• Appendix: Pop Quiz Answers
• Chapter 2
• A First Complete Sample
• Chapter 3
• Creating a Model

• Chapter 4
• Defining the Database Schema

• Chapter 5
• Mapping the Model to the Database

• Chapter 6
• Sessions and Transactions

• Chapter 7
• Testing, Profiling, Monitoring, and Logging

• Chapter 8
• Configuration

• Chapter 9
• Writing Queries

• Chapter 10
• Validating the Data to Persist

• Index