public void Save(T entity)
      {
            ITransaction tx = Session.BeginTransaction();
            try
            {
                Session.SaveOrUpdate(entity);
                tx.Commit();
                Session.Flush();
            }
            catch
            {
                tx.Rollback();
                throw;
            }         
      }

    public static class Repository<T>
    {
        private static IRepository<T> _internalRepository = new NHRepository<T>();
        private static IRepository<T> InternalRepository
        {
            get
            {
               return _internalRepository;
            }
        }


       /// <summary>
       /// Get the entity from the persistance store, or return null
       /// if it doesn't exist.
       /// </summary>
       /// <param name="id">The entity's id</param>
       /// <returns>Either the entity that matches the id, or a null</returns>
       public static T Get(object id)
       {
          return InternalRepository.Get(id);
       }

       // other methods

Product obj = new Product();
obj.Name = "This is a Test";

Repository<Product>.Save(obj);

using System;
using System.Collections.Generic;
using System.Data;
using NHibernate;
using NHibernate.Connection;
using NHibernate.Expression;

namespace Quicoli.Commons.Repository
{
   public class NHRepository<T> : IRepository<T>
   {
      protected virtual ISession Session
      {
            get { return SessionManager.Current.GetSession(); }
      }

      public T Get(object id)
      {
         return (T)Session.Get(typeof(T), id);
      }

      public T Load(object id)
      {
         return (T)Session.Load(typeof(T), id);
      }

      public void Delete(T entity)
      {
         Session.Delete(entity);
      }

      public void Save(T entity)
      {
            ITransaction tx = Session.BeginTransaction();
            try
            {
                Session.SaveOrUpdate(entity);
                Session.Flush();
                tx.Commit();
            }
            catch
            {
                tx.Rollback();
                throw;
            }         
      }

      public ICollection<T> FindAll(Order order, params ICriterion[] criteria)
      {
         ICriteria crit = RepositoryHelper<T>.CreateCriteriaFromArray(Session, criteria);
         crit.AddOrder(order);
         return crit.List<T>();
      }

      public ICollection<T> FindAll(Order[] orders, params ICriterion[] criteria)
      {
         ICriteria crit = RepositoryHelper<T>.CreateCriteriaFromArray(Session, criteria);
         foreach (Order order in orders)
         {
            crit.AddOrder(order);
         }
         return crit.List<T>();
      }

      public ICollection<T> FindAll(params ICriterion[] criteria)
      {
         ICriteria crit = RepositoryHelper<T>.CreateCriteriaFromArray(Session, criteria);
         return crit.List<T>();
      }

      public ICollection<T> FindAll(int firstResult, int numberOfResults, params ICriterion[] criteria)
      {
         ICriteria crit = RepositoryHelper<T>.CreateCriteriaFromArray(Session, criteria);
         crit.SetFirstResult(firstResult)
            .SetMaxResults(numberOfResults);
         return crit.List<T>();
      }

      public ICollection<T> FindAll(
         int firstResult, int numberOfResults, Order selectionOrder, params ICriterion[] criteria)
      {
         ICriteria crit = RepositoryHelper<T>.CreateCriteriaFromArray(Session, criteria);
         crit.SetFirstResult(firstResult)
            .SetMaxResults(numberOfResults);
         crit.AddOrder(selectionOrder);
         return crit.List<T>();
      }

      public ICollection<T> FindAll(
         int firstResult, int numberOfResults, Order[] selectionOrder, params ICriterion[] criteria)
      {
         ICriteria crit = RepositoryHelper<T>.CreateCriteriaFromArray(Session, criteria);
         crit.SetFirstResult(firstResult)
            .SetMaxResults(numberOfResults);
         foreach (Order order in selectionOrder)
         {
            crit.AddOrder(order);
         }
         return crit.List<T>();
      }

      public ICollection<T> FindAll(string namedQuery, params Parameter[] parameters)
      {
         IQuery query = RepositoryHelper<T>.CreateQuery(Session, namedQuery, parameters);
         return query.List<T>();
      }

      public ICollection<T> FindAll(
         int firstResult, int numberOfResults, string namedQuery, params Parameter[] parameters)
      {
         IQuery query = RepositoryHelper<T>.CreateQuery(Session, namedQuery, parameters);
         query.SetFirstResult(firstResult)
            .SetMaxResults(numberOfResults);
         return query.List<T>();
      }

      public T FindOne(params ICriterion[] criteria)
      {
         ICriteria crit = RepositoryHelper<T>.CreateCriteriaFromArray(Session, criteria);
         return (T)crit.UniqueResult();
      }

      public T FindOne(string namedQuery, params Parameter[] parameters)
      {
         IQuery query = RepositoryHelper<T>.CreateQuery(Session, namedQuery, parameters);
         return (T)query.UniqueResult();
      }

      public ICollection<T> FindAll(DetachedCriteria criteria, params Order[] orders)
      {
         ICriteria executableCriteria = RepositoryHelper<T>.GetExecutableCriteria(Session, criteria, orders);
         return executableCriteria.List<T>();
      }

      public ICollection<T> FindAll(DetachedCriteria criteria, int firstResult, int maxResults, params Order[] orders)
      {
         ICriteria executableCriteria = RepositoryHelper<T>.GetExecutableCriteria(Session, criteria, orders);
         executableCriteria.SetFirstResult(firstResult);
         executableCriteria.SetMaxResults(maxResults);
         return executableCriteria.List<T>();
      }

      public T FindOne(DetachedCriteria criteria)
      {
         ICriteria executableCriteria = RepositoryHelper<T>.GetExecutableCriteria(Session, criteria, null);
         return (T)executableCriteria.UniqueResult();
      }

      public T FindFirst(DetachedCriteria criteria, params Order[] orders)
      {
         ICriteria executableCriteria = RepositoryHelper<T>.GetExecutableCriteria(Session, criteria, orders);
         executableCriteria.SetFirstResult(0);
         executableCriteria.SetMaxResults(1);
         return (T)executableCriteria.UniqueResult();
      }

      /// <summary>
      /// Find the first entity of type
      /// </summary>
      /// <param name="orders">Optional orderring</param>
      /// <returns>The entity or null</returns>
      public T FindFirst(params Order[] orders)
      {
         return FindFirst(null, orders);
      }

      /// <summary>
      /// Check if any instance matches the criteria.
      /// </summary>
      /// <returns><c>true</c> if an instance is found; otherwise <c>false</c>.</returns>
      public bool Exists(DetachedCriteria criteria)
      {
         return 0 != Count(criteria);
      }

      /// <summary>
      /// Check if any instance of the type exists
      /// </summary>
      /// <returns><c>true</c> if an instance is found; otherwise <c>false</c>.</returns>
      public bool Exists()
      {
         return Exists(null);
      }

      /// <summary>
      /// Counts the number of instances matching the criteria.
      /// </summary>
      /// <param name="criteria"></param>
      /// <returns></returns>
      public long Count(DetachedCriteria criteria)
      {
         ICriteria crit = RepositoryHelper<T>.GetExecutableCriteria(Session, criteria, null);
              crit.SetProjection(Projections.RowCount());
              object countMayBe_Int32_Or_Int64_DependingOnDatabase = crit.UniqueResult();
         return Convert.ToInt64(countMayBe_Int32_Or_Int64_DependingOnDatabase);
      }

      /// <summary>
      /// Counts the overall number of instances.
      /// </summary>
      /// <returns></returns>
      public long Count()
      {
         return Count(null);
      }
   }
}

using System;
using System.Collections.Generic;
using System.Text;
using System.Data;
using NHibernate;
using NHibernate.Cfg;

namespace Quicoli.Commons.Repository
{
    public class SessionManager
    {
        #region private members

        private bool _initialized = false;
        private ISessionFactory _factory;

        #endregion

        #region public properties

        /// <summary>
        /// Returns true if the SessionSource has been initialized successfully.
        /// </summary>
        public bool IsInitialized
        {
            get { return _initialized; }
        }

        #endregion

        #region singleton implementation

        private static SessionManager _current = new SessionManager();
        public static SessionManager Current
        {
            get { return _current; }
        }

        #endregion


        private SessionManager()
        {
            //prevent direct creation
        }

        /// <summary>
        /// Reads the NHibernate configuration and builds the session factory.
        /// </summary>
        public void Initialize()
        {
            Configuration cfg = new Configuration();
           
            _factory = cfg.Configure().BuildSessionFactory();

            _initialized = true;
        }

        /// <summary>
        /// Closes the current session factory.  The next call
        /// to initialize or GetSession will re-initialize the SessionSource
        /// </summary>
        public void Close()
        {
            if (_factory == null)
                return;

            _factory.Close();
            _initialized = false;
        }

        /// <summary>
        /// Gets an open NHibernate ISession for work with the database.
        /// </summary>       
        /// <returns>ISession</returns>
        public ISession GetSession()
        {
            //if we aren't initialized, do it
            if (!_initialized)
                Initialize();

            return _factory.OpenSession();
        }

        /// <summary>
        /// Gets an open NHibernate ISession (using the existing connection) for work with the database
        /// </summary>
        /// <param name="connection">An existing IDbConnection</param>
        /// <returns>ISession</returns>
        public ISession GetSession(IDbConnection connection)
        {
            //if we aren't initialized, do it
            if (!_initialized)
                Initialize();

            return _factory.OpenSession(connection);
        }

        /// <summary>
        /// Gets an open NHibernate ISession fro work with the database.
        /// </summary>
        /// <param name="interceptor">A custom interceptor to attach to the session before returning it.</param>
        /// <returns></returns>
        public ISession GetSession(IInterceptor interceptor)
        {
            if (!_initialized)
                Initialize();

            return _factory.OpenSession(interceptor);
        }

    }
}

try
  Save
  commit
catch
  rollback

      public void Save(T entity)
      {
            ISession session = Session;
            ITransaction tx = session.BeginTransaction();
            try
            {
                session.SaveOrUpdate(entity);
                session.Flush();
                tx.Commit();
            }
            catch
            {
                tx.Rollback();
                throw;
            }         
      }