Most business operations result in addition/removal of, updates to database records. A business operation is considered successful only when all constituent database operations are committed to database successfully, among other things. Failure of even a single database operation signals the failure of the whole business operation. In this situation, all other successful database operations need to be reverted back. Most relational databases offer ability to bundle multiple database operations as one unit called transaction. Relational databases offer a guarantee that either all operations inside a transaction succeed or they all fail, leaving the data in a consistent state. This behavior is also described using ACID properties which stand for Atomic, Consistency, Isolation, and Durability. These properties guarantee that database transactions are processed in a reliable manner. Let's briefly understand what behavior these properties define:

Unit of work is a design pattern which assists with reliably inserting, updating, and deleting records in database as one unit of work, in accordance with the business operations being carried out. NHibernate supports unit of work pattern through its own implementation of transaction. To make use of this, you first need to tell session object to begin a transaction by calling the BeginTransaction method on session object. Once a transaction is started, any database operation performed using the session object is recorded but is not actually sent to database. When you are finished with your business operation, you can call the Commit method on the transaction to tell NHibernate that you do not intend to carry out any more database operations as part of this business operation and NHibernate should send all the database operations to the database server as one unit. Following is a simplified version of how this code would look:

using (var session = config.OpenSession())
{
  using (var transaction = session.BeginTransaction())
  {
    try
    {
      //Database operations here
      transaction.Commit();
    }
    catch (Exception ex)
    {
      transaction.Rollback();
      throw;
    }

  }
}

Most important bits in the preceding piece of code are beginning the transaction and running database operations inside of a try…catch block. If there is any error while database operations are being carried out, an exception would be thrown which is caught in the catch block. Here, the transaction is rolled back, resulting in reverting any state changes that were applied to data in database and removing all database operations recorded in the session object. If database operation finished without errors then call to Commit at the end of the try block would make sure that all the database operations are sent to database as one unit. They all either update data in the database or throw an error and are rolled back.

Remember that NHibernate transaction ultimately results in a database transaction but it is not the same as a database transaction. SQL to start a database transaction is sent to database as soon as ITransaction.BeginTransaction is executed. The lifetime of database transaction is controlled by NHibernate transaction.