using System;
using System.Collections.Generic;
using System.Text;
using System.Transactions;
using NHibernate;
using NHibernate.Cfg;
using NHibernate.Cache;
using NHibernate.Exceptions;
using System.Runtime.Remoting.Messaging;
namespace Company.Database.NHibernate
{
public sealed class NHibernateUtil
{
#region attributes
/// <summary>
/// sessionFactory attribute
/// </summary>
private static ISessionFactory sessionFactory;
#endregion
#region general methods
/// <summary>
///
/// </summary>
/// <param name="assembly"></param>
public static void InitSessionFactory(String assembly)
{
if (sessionFactory == null)
{
Configuration cfg = new Configuration();
cfg.AddAssembly(assembly);
sessionFactory = cfg.BuildSessionFactory();
}
}
/// <summary>
/// Allows you to register an interceptor on a new session. This may not be called if there is already
/// an open session attached to the HttpContext. If you have an interceptor to be used, modify
/// the HttpModule to call this before calling BeginTransaction().
/// </summary>
public static void RegisterInterceptor(IInterceptor interceptor)
{
ISession session = threadSession;
if (session != null && session.IsOpen)
{
throw new CacheException("You cannot register an interceptor once a session has already been opened");
}
GetSession(interceptor);
}
public static ISession GetSession()
{
return GetSession(null);
}
/// <summary>
/// Gets a session with or without an interceptor. This method is not called directly; instead,
/// it gets invoked from other public methods.
/// </summary>
private static ISession GetSession(IInterceptor interceptor)
{
ISession session = threadSession;
if (session == null)
{
if (interceptor != null)
{
session = sessionFactory.OpenSession(interceptor);
}
else
{
session = sessionFactory.OpenSession();
}
threadSession = session;
}
return session;
}
/// <summary>
/// Closes a session
/// </summary>
public static void CloseSession()
{
ISession session = threadSession;
threadSession = null;
if (session != null && session.IsOpen)
{
session.Close();
}
}
/// <summary>
/// Begins a transaction
/// </summary>
public static void BeginTransaction()
{
ITransaction transaction = threadTransaction;
if (transaction == null)
{
transaction = GetSession().BeginTransaction();
threadTransaction = transaction;
}
}
/// <summary>
/// Commits a transaction
/// </summary>
public static void CommitTransaction()
{
ITransaction transaction = threadTransaction;
try
{
if (transaction != null && !transaction.WasCommitted
&& !transaction.WasRolledBack)
{
transaction.Commit();
threadTransaction = null;
}
}
catch (HibernateException ex)
{
RollbackTransaction();
throw ex;
}
}
/// <summary>
/// Rolls back a transaction
/// </summary>
public static void RollbackTransaction()
{
ITransaction transaction = threadTransaction;
try
{
threadTransaction = null;
if (transaction != null && !transaction.WasCommitted
&& !transaction.WasRolledBack)
{
transaction.Rollback();
}
}
catch (HibernateException ex)
{
throw ex;
}
finally
{
CloseSession();
}
}
/// <summary>
/// Gets or sets the threadTransaction
/// </summary>
private static ITransaction threadTransaction
{
get
{
return (ITransaction)CallContext.GetData("THREAD_TRANSACTION");
}
set
{
CallContext.SetData("THREAD_TRANSACTION", value);
}
}
/// <summary>
/// Gets or sets the threadSession
/// </summary>
private static ISession threadSession
{
get
{
return (ISession)CallContext.GetData("THREAD_SESSION");
}
set
{
CallContext.SetData("THREAD_SESSION", value);
}
}
#endregion
#region Transaction Scope
/// <summary>
/// Gets new trasanction scope
/// </summary>
/// <param name="scopeOption"></param>
/// <returns></returns>
public static TransactionScope GetNewScope(TransactionScopeOption scopeOption)
{
bool newTransaction = System.Transactions.Transaction.Current == null;
if (newTransaction)
{
DisconnectCurrentSession();
}
TransactionScope scope = new TransactionScope(scopeOption);
if (newTransaction)
{
ReconnectCurrentSession();
}
return scope;
}
/// <summary>
/// disconnects the current session (if not in active transaction)
/// </summary>
public static void DisconnectCurrentSession()
{
ISession session = GetSession();
if (session == null) return;
if (!session.IsConnected) return;
if (session.Transaction == null)
{
session.Disconnect();
}
else
{
if (session.Transaction.WasCommitted || session.Transaction.WasRolledBack)
{
session.Disconnect();
}
}
}
/// <summary>
/// disconnects the current session (if not already connected)
/// </summary>
public static void ReconnectCurrentSession()
{
ISession session = GetSession();
if (session == null)
{
return;
}
if (!session.IsConnected)
{
session.Reconnect();
}
}
#endregion
}
}
I´m testing the HibernateUtil with TransactionScope with some DAO´s and Business Objects
and it´s OK... If you found some problems... :)
using System;
using System.Collections;
using System.Text;
using System.Transactions;
using NHibernateSample.Core.Domain;
using NHibernateSample.Dao;
using NHibernateSample.Dao.NHibernate;
using log4net;
[assembly: log4net.Config.XmlConfigurator(Watch = true)]
namespace NHibernateSample.Bo
{
public class CustomerBO
{
#region attributes
/// <summary>
/// customerDAO attribute
/// </summary>
private CustomerDAO customerDAO = new NHibernateCustomerDAO();
/// <summary>
/// userLogBO attribute
/// </summary>
private UserLogBO userLogBO = new UserLogBO();
/// <summary>
/// Log4Net attribute
/// </summary>
private static readonly log4net.ILog log = log4net.LogManager.GetLogger((System.Reflection.MethodBase.GetCurrentMethod().DeclaringType));
#endregion
#region methods
/// <summary>
/// Inserts a customer
/// </summary>
/// <param name="customer"></param>
public void Insert(Customer customer)
{
using (TransactionScope scope = Company.Database.NHibernate.NHibernateUtil.GetNewScope(TransactionScopeOption.Required))
{
try
{
customerDAO.Insert(customer);
// business Logic to insert log into DB
// Using other BO that contains TransactionScope too:
UserLogTO userLog = new UserLogTO();
userLog.User = customer.LoggedUser;
ActionTO action = new ActionTO();
action.Id = "FF";
userLog.Action = action;
userLogBO.Insert(userLog); // into this method contains Transaction scope too
// if the above Insert fails, it´s rolled back the transaction
Company.Database.NHibernate.NHibernateUtil.CommitTransaction();
}
catch (Exception e)
{
Company.Database.NHibernate.NHibernateUtil.RollbackTransaction();
log.Error("Method Insert: ", e);
throw e;
}
finally
{
Company.Database.NHibernate.NHibernateUtil.CloseSession();
scope.Complete();
}
}
}
}
}
Login
FAQ
Search
