nhibernet并发出错
今天进行压力测试时当用户数量到100人就报很多莫名奇妙的错误,查一下日志,基本上都是与nhibernet有关,错误代码如下:
using System;
using System.Data;
using System.Collections;
using System.Data;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Web;
using NHibernate;
using NHibernate.Cfg;
using NHibernate.Engine; //ISessionFactoryImplementor
using Iesi.Collections;
using log4net;
namespace Com.DRPENG.Common.DBUtility
{
/// <summary>
///
/// </summary>
public partial class NHibernateHelper
{
private static ILog log = LogManager.GetLogger(typeof(NHibernateHelper));
private static NHibernate.Cfg.Configuration cfg = null;
private static ISessionFactory factory = null;
//private static ISessionFactoryImplementor Ifactory = null;
private static ISession session = null;
private static object obj = new object();
private static string SQLCON = Com.DRPENG.Common.WebStruct.Config.AppConfig.DataAccessConfig.ConnectionString;
/// <summary>
/// ISession KEY
/// </summary>
public static string ISESSION_KEY = "NHibernateHelper.ISession";
#region 初始化NHibernate
/// <summary>
/// 初始化NHibernate (从配置文件中读取配置信息)
/// </summary>
/// <returns>会话工厂</returns>
public static ISessionFactory BuildFactory()
{
lock (obj)
{
try
{
if (cfg == null || factory == null)
{
string configPath = System.Web.HttpContext.Current.Request.PhysicalApplicationPath + "hibernate.cfg.xml";
// Configure()方法是为了在hibernate.cfg.xml中查找属性
cfg = new Configuration().Configure(configPath);
Hashtable ht = new Hashtable();
// 对应于Ado.Net的连接串
ht.Add("hibernate.connection.connection_string", SQLCON);
cfg.AddProperties(ht);
return factory = cfg.BuildSessionFactory();
}
return factory;
}
catch (Exception ex)
{
log.Info(string.Format("初始化ISessionFactory失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
}
#endregion
#region 获取会话
/// <summary>
/// 获取会话
/// </summary>
/// <returns>会话ISession</returns>
public static ISession GetSession()
{
try
{
if (HttpContext.Current != null && HttpContext.Current.Items.Contains(ISESSION_KEY))
{
session = (ISession)HttpContext.Current.Items[ISESSION_KEY];
if (session.Connection.State == ConnectionState.Closed)
session.Connection.Open();
}
else
{
if (factory == null)
factory = BuildFactory();
session = factory.OpenSession();
HttpContext.Current.Items[ISESSION_KEY] = session;
}
return session;
}
catch (HibernateException ex)
{
log.Info(string.Format("获取会话失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+1 关闭会话
/// <summary>
/// 重载+1 关闭会话
/// <param name="session">会话</param>
/// </summary>
public static void CloseSession()
{
try
{
CloseSession(session);
}
catch (Exception ex)
{
log.Info(string.Format("关闭会话失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+2 关闭会话
/// <summary>
/// 重载+2 关闭会话
/// <param name="session">会话</param>
/// </summary>
public static void CloseSession(ISession session)
{
try
{
if (session != null && session.IsOpen)
{
//session.Clear();
if(session.Transaction!=null&&!session.Transaction.WasCommitted)
session.Transaction.Rollback();
session.Flush();
session.Close();
}
if (HttpContext.Current != null && HttpContext.Current.Items.Contains(ISESSION_KEY))
{
HttpContext.Current.Items.Remove(ISESSION_KEY);
}
}
catch (Exception ex)
{
log.Info(string.Format("关闭会话失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+1 获取对象
/// <summary>
/// 重载+1 获取对象
/// </summary>
/// <param name="type"></param>
/// <param name="id"></param>
/// <returns></returns>
public static Object Get(Type type, object id)
{
try
{
return session.Get(type, id);
}
catch (HibernateException ex)
{
log.Info(string.Format("获取对象失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+2 获取对象
/// <summary>
/// 重载+2 获取对象
/// </summary>
/// <param name="session">会话</param>
/// <param name="type"></param>
/// <param name="id"></param>
/// <returns></returns>
public static Object Get(ISession session, Type type, object id)
{
try
{
return session.Get(type, id);
}
catch (HibernateException ex)
{
log.Info(string.Format("获取对象失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+1 保存对象
/// <summary>
/// 重载+1 保存对象
/// </summary>
/// <param name="obj">对象</param>
public static void Save(Object obj)
{
ITransaction tx = session.BeginTransaction();
try
{
session.Save(obj);
TransCommit(tx);
}
catch (HibernateException ex)
{
TransRollback(tx);
log.Info(string.Format("保存失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+2 保存对象
/// <summary>
/// 重载+2 保存对象
/// </summary>
/// <param name="obj">对象</param>
/// <param name="id">ID</param>
public static void Save(Object obj, object id)
{
ITransaction tx = session.BeginTransaction();
try
{
session.Save(obj, id);
TransCommit(tx);
}
catch (HibernateException ex)
{
TransRollback(tx);
log.Info(string.Format("保存失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+3 保存对象
/// <summary>
/// 重载+3 保存对象
/// </summary>
/// <param name="session">会话</param>
/// <param name="obj">对象</param>
public static void Save(ISession session, Object obj)
{
ITransaction tx = session.BeginTransaction();
try
{
session.Save(obj);
TransCommit(tx);
}
catch (HibernateException ex)
{
TransRollback(tx);
log.Info(string.Format("保存失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+4 保存对象
/// <summary>
/// 重载+4 保存对象
/// </summary>
/// <param name="session">会话</param>
/// <param name="obj">对象</param>
/// <param name="id">ID</param>
public static void Save(ISession session, Object obj, object id)
{
ITransaction tx = session.BeginTransaction();
try
{
session.Save(obj, id);
TransCommit(tx);
}
catch (HibernateException ex)
{
TransRollback(tx);
log.Info(string.Format("保存失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+1 更新对象
/// <summary>
/// 重载+1 更新对象
/// </summary>
/// <param name="obj">对象</param>
public static void Update(Object obj)
{
ITransaction tx = session.BeginTransaction();
try
{
session.Update(obj);
TransCommit(tx);
}
catch (HibernateException ex)
{
TransRollback(tx);
log.Info(string.Format("更新失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+2 更新对象
/// <summary>
/// 重载+2 更新对象
/// </summary>
/// <param name="obj">对象</param>
/// <param name="id">ID</param>
public static void Update(Object obj, object id)
{
ITransaction tx = session.BeginTransaction();
try
{
session.Update(obj, id);
TransCommit(tx);
}
catch (HibernateException ex)
{
TransRollback(tx);
log.Info(string.Format("更新失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+3 更新对象
/// <summary>
/// 重载+3 更新对象
/// </summary>
/// <param name="session">会话</param>
/// <param name="obj">对象</param>
public static void Update(ISession session, Object obj)
{
ITransaction tx = session.BeginTransaction();
try
{
session.Update(obj);
TransCommit(tx);
}
catch (HibernateException ex)
{
TransRollback(tx);
log.Info(string.Format("更新失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+4 更新对象
/// <summary>
/// 重载+4 更新对象
/// </summary>
/// <param name="session">会话</param>
/// <param name="obj">对象</param>
/// <param name="id">ID</param>
public static void Update(ISession session, Object obj, object id)
{
ITransaction tx = session.BeginTransaction();
try
{
session.Update(obj, id);
TransCommit(tx);
}
catch (HibernateException ex)
{
TransRollback(tx);
log.Info(string.Format("更新失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+1 保存or更新对象
/// <summary>
/// 重载+1 保存or更新对象
/// </summary>
/// <param name="obj"></param>
public static void SaveOrUpdate(object obj)
{
try
{
session.SaveOrUpdate(obj);
}
catch (Exception ex)
{
log.Info(string.Format("保存or更新失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+2 保存or更新对象
/// <summary>
/// 重载+2 保存or更新对象
/// </summary>
/// <param name="session">会话</param>
/// <param name="obj"></param>
public static void SaveOrUpdate(ISession session, object obj)
{
try
{
session.SaveOrUpdate(obj);
}
catch (Exception ex)
{
log.Info(string.Format("保存or更新失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+1 删除对象
/// <summary>
/// 重载+1 删除对象
/// </summary>
/// <param name="obj">对象</param>
public static void Delete(Object obj)
{
ITransaction tx = session.BeginTransaction();
try
{
session.Delete(obj);
TransCommit(tx);
}
catch (HibernateException ex)
{
TransRollback(tx);
log.Info(string.Format("删除失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+2 删除对象
/// <summary>
/// 重载+2 删除对象
/// </summary>
/// <param name="query">查询</param>
/// <returns>受影响记录的行数</returns>
public static int Delete(string query)
{
ITransaction tx = session.BeginTransaction();
try
{
int getValue = session.Delete(query);
TransCommit(tx);
return getValue;
}
catch (HibernateException ex)
{
TransRollback(tx);
log.Info(string.Format("删除失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+3 删除对象
/// <summary>
/// 重载+3 删除对象
/// </summary>
/// <param name="query">查询</param>
/// <param name="value"></param>
/// <param name="type"></param>
/// <returns>受影响记录的行数</returns>
public static int Delete(string query, object value, NHibernate.Type.IType type)
{
ITransaction tx = session.BeginTransaction();
try
{
int getValue = session.Delete(query, value, type);
TransCommit(tx);
return getValue;
}
catch (HibernateException ex)
{
TransRollback(tx);
log.Info(string.Format("删除失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+4 删除对象
/// <summary>
/// 重载+4 删除对象
/// </summary>
/// <param name="query">查询</param>
/// <param name="values"></param>
/// <param name="types"></param>
/// <returns>受影响记录的行数</returns>
public static int Delete(string query, object[] values, NHibernate.Type.IType[] types)
{
ITransaction tx = session.BeginTransaction();
try
{
int getValue = session.Delete(query, values, types);
TransCommit(tx);
return getValue;
}
catch (HibernateException ex)
{
TransRollback(tx);
log.Info(string.Format("删除失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+5 删除对象
/// <summary>
/// 重载+5 删除对象
/// </summary>
/// <param name="session">会话</param>
/// <param name="obj">对象</param>
public static void Delete(ISession session, Object obj)
{
ITransaction tx = session.BeginTransaction();
try
{
session.Delete(obj);
TransCommit(tx);
}
catch (HibernateException ex)
{
TransRollback(tx);
log.Info(string.Format("删除失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+6 删除对象
/// <summary>
/// 重载+6 删除对象
/// </summary>
/// <param name="session">会话</param>
/// <param name="query">查询</param>
/// <returns>受影响记录的行数</returns>
public static int Delete(ISession session, string query)
{
ITransaction tx = session.BeginTransaction();
try
{
int getValue = session.Delete(query);
TransCommit(tx);
return getValue;
}
catch (HibernateException ex)
{
TransRollback(tx);
log.Info(string.Format("删除失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+7 删除对象
/// <summary>
/// 重载+7 删除对象
/// </summary>
/// <param name="session">会话</param>
/// <param name="query">查询</param>
/// <param name="value"></param>
/// <param name="type"></param>
/// <returns>受影响记录的行数</returns>
public static int Delete(ISession session, string query, object value, NHibernate.Type.IType type)
{
ITransaction tx = session.BeginTransaction();
try
{
int getValue = session.Delete(query, value, type);
TransCommit(tx);
return getValue;
}
catch (HibernateException ex)
{
TransRollback(tx);
log.Info(string.Format("删除失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+8 删除对象
/// <summary>
/// 重载+8 删除对象
/// </summary>
/// <param name="session">会话</param>
/// <param name="query">查询</param>
/// <param name="values"></param>
/// <param name="types"></param>
/// <returns>受影响记录的行数</returns>
public static int Delete(ISession session, string query, object[] values, NHibernate.Type.IType[] types)
{
ITransaction tx = session.BeginTransaction();
try
{
int getValue = session.Delete(query, values, types);
TransCommit(tx);
return getValue;
}
catch (HibernateException ex)
{
TransRollback(tx);
log.Info(string.Format("删除失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+1 创建查询对象
/// <summary>
/// 重载+1 创建查询对象
/// </summary>
/// <param name="hqlStr">HQL语句</param>
/// <param name="param">参数列表</param>
/// <returns>IQuery对象</returns>
public static IQuery CreateQuery(String hqlStr, IDictionary param)
{
try
{
IQuery query = session.CreateQuery(hqlStr);
string[] NamedParams = query.NamedParameters;
if (NamedParams != null && NamedParams.Length > 0)
{
for (int i = 0; i < NamedParams.Length; i++)
{
string name = NamedParams[i];
query.SetParameter(name, param[name]);
}
}
return query;
}
catch (Exception ex)
{
log.Info(string.Format("创建查询对象失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+2 创建查询对象
/// <summary>
/// 重载+2 创建查询对象
/// </summary>
/// <param name="session">会话</param>
/// <param name="hqlStr">HQL语句</param>
/// <param name="param">参数列表</param>
/// <returns>IQuery对象</returns>
public static IQuery CreateQuery(ISession session, String hqlStr, IDictionary param)
{
try
{
IQuery query = session.CreateQuery(hqlStr);
string[] NamedParams = query.NamedParameters;
if (NamedParams != null && NamedParams.Length > 0)
{
for (int i = 0; i < NamedParams.Length; i++)
{
string name = NamedParams[i];
query.SetParameter(name, param[name]);
}
}
return query;
}
catch (Exception ex)
{
log.Info(string.Format("创建查询对象失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 提交事务
/// <summary>
/// 提交事务
/// </summary>
/// <param name="tx"></param>
public static void TransCommit(ITransaction tx)
{
try
{
if (!tx.WasRolledBack)
tx.Commit();
}
catch (HibernateException ex)
{
tx.Rollback();
log.Info(string.Format("提交事务失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 回滚事务
/// <summary>
/// 回滚事务
/// </summary>
/// <param name="tx"></param>
public static void TransRollback(ITransaction tx)
{
try
{
tx.Rollback();
}
catch (HibernateException ex)
{
log.Info(string.Format("回滚事务失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
}
}
using System.Text;
using System.Web;
using NHibernate;
using NHibernate.Cfg;
using NHibernate.Engine; //ISessionFactoryImplementor
using Iesi.Collections;
using log4net;
namespace Com.DRPENG.Common.DBUtility
{
/// <summary>
///
/// </summary>
public partial class NHibernateHelper
{
private static ILog log = LogManager.GetLogger(typeof(NHibernateHelper));
private static NHibernate.Cfg.Configuration cfg = null;
private static ISessionFactory factory = null;
//private static ISessionFactoryImplementor Ifactory = null;
private static ISession session = null;
private static object obj = new object();
private static string SQLCON = Com.DRPENG.Common.WebStruct.Config.AppConfig.DataAccessConfig.ConnectionString;
/// <summary>
/// ISession KEY
/// </summary>
public static string ISESSION_KEY = "NHibernateHelper.ISession";
#region 初始化NHibernate
/// <summary>
/// 初始化NHibernate (从配置文件中读取配置信息)
/// </summary>
/// <returns>会话工厂</returns>
public static ISessionFactory BuildFactory()
{
lock (obj)
{
try
{
if (cfg == null || factory == null)
{
string configPath = System.Web.HttpContext.Current.Request.PhysicalApplicationPath + "hibernate.cfg.xml";
// Configure()方法是为了在hibernate.cfg.xml中查找属性
cfg = new Configuration().Configure(configPath);
Hashtable ht = new Hashtable();
// 对应于Ado.Net的连接串
ht.Add("hibernate.connection.connection_string", SQLCON);
cfg.AddProperties(ht);
return factory = cfg.BuildSessionFactory();
}
return factory;
}
catch (Exception ex)
{
log.Info(string.Format("初始化ISessionFactory失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
}
#endregion
#region 获取会话
/// <summary>
/// 获取会话
/// </summary>
/// <returns>会话ISession</returns>
public static ISession GetSession()
{
try
{
if (HttpContext.Current != null && HttpContext.Current.Items.Contains(ISESSION_KEY))
{
session = (ISession)HttpContext.Current.Items[ISESSION_KEY];
if (session.Connection.State == ConnectionState.Closed)
session.Connection.Open();
}
else
{
if (factory == null)
factory = BuildFactory();
session = factory.OpenSession();
HttpContext.Current.Items[ISESSION_KEY] = session;
}
return session;
}
catch (HibernateException ex)
{
log.Info(string.Format("获取会话失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+1 关闭会话
/// <summary>
/// 重载+1 关闭会话
/// <param name="session">会话</param>
/// </summary>
public static void CloseSession()
{
try
{
CloseSession(session);
}
catch (Exception ex)
{
log.Info(string.Format("关闭会话失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+2 关闭会话
/// <summary>
/// 重载+2 关闭会话
/// <param name="session">会话</param>
/// </summary>
public static void CloseSession(ISession session)
{
try
{
if (session != null && session.IsOpen)
{
//session.Clear();
if(session.Transaction!=null&&!session.Transaction.WasCommitted)
session.Transaction.Rollback();
session.Flush();
session.Close();
}
if (HttpContext.Current != null && HttpContext.Current.Items.Contains(ISESSION_KEY))
{
HttpContext.Current.Items.Remove(ISESSION_KEY);
}
}
catch (Exception ex)
{
log.Info(string.Format("关闭会话失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+1 获取对象
/// <summary>
/// 重载+1 获取对象
/// </summary>
/// <param name="type"></param>
/// <param name="id"></param>
/// <returns></returns>
public static Object Get(Type type, object id)
{
try
{
return session.Get(type, id);
}
catch (HibernateException ex)
{
log.Info(string.Format("获取对象失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+2 获取对象
/// <summary>
/// 重载+2 获取对象
/// </summary>
/// <param name="session">会话</param>
/// <param name="type"></param>
/// <param name="id"></param>
/// <returns></returns>
public static Object Get(ISession session, Type type, object id)
{
try
{
return session.Get(type, id);
}
catch (HibernateException ex)
{
log.Info(string.Format("获取对象失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+1 保存对象
/// <summary>
/// 重载+1 保存对象
/// </summary>
/// <param name="obj">对象</param>
public static void Save(Object obj)
{
ITransaction tx = session.BeginTransaction();
try
{
session.Save(obj);
TransCommit(tx);
}
catch (HibernateException ex)
{
TransRollback(tx);
log.Info(string.Format("保存失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+2 保存对象
/// <summary>
/// 重载+2 保存对象
/// </summary>
/// <param name="obj">对象</param>
/// <param name="id">ID</param>
public static void Save(Object obj, object id)
{
ITransaction tx = session.BeginTransaction();
try
{
session.Save(obj, id);
TransCommit(tx);
}
catch (HibernateException ex)
{
TransRollback(tx);
log.Info(string.Format("保存失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+3 保存对象
/// <summary>
/// 重载+3 保存对象
/// </summary>
/// <param name="session">会话</param>
/// <param name="obj">对象</param>
public static void Save(ISession session, Object obj)
{
ITransaction tx = session.BeginTransaction();
try
{
session.Save(obj);
TransCommit(tx);
}
catch (HibernateException ex)
{
TransRollback(tx);
log.Info(string.Format("保存失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+4 保存对象
/// <summary>
/// 重载+4 保存对象
/// </summary>
/// <param name="session">会话</param>
/// <param name="obj">对象</param>
/// <param name="id">ID</param>
public static void Save(ISession session, Object obj, object id)
{
ITransaction tx = session.BeginTransaction();
try
{
session.Save(obj, id);
TransCommit(tx);
}
catch (HibernateException ex)
{
TransRollback(tx);
log.Info(string.Format("保存失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+1 更新对象
/// <summary>
/// 重载+1 更新对象
/// </summary>
/// <param name="obj">对象</param>
public static void Update(Object obj)
{
ITransaction tx = session.BeginTransaction();
try
{
session.Update(obj);
TransCommit(tx);
}
catch (HibernateException ex)
{
TransRollback(tx);
log.Info(string.Format("更新失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+2 更新对象
/// <summary>
/// 重载+2 更新对象
/// </summary>
/// <param name="obj">对象</param>
/// <param name="id">ID</param>
public static void Update(Object obj, object id)
{
ITransaction tx = session.BeginTransaction();
try
{
session.Update(obj, id);
TransCommit(tx);
}
catch (HibernateException ex)
{
TransRollback(tx);
log.Info(string.Format("更新失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+3 更新对象
/// <summary>
/// 重载+3 更新对象
/// </summary>
/// <param name="session">会话</param>
/// <param name="obj">对象</param>
public static void Update(ISession session, Object obj)
{
ITransaction tx = session.BeginTransaction();
try
{
session.Update(obj);
TransCommit(tx);
}
catch (HibernateException ex)
{
TransRollback(tx);
log.Info(string.Format("更新失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+4 更新对象
/// <summary>
/// 重载+4 更新对象
/// </summary>
/// <param name="session">会话</param>
/// <param name="obj">对象</param>
/// <param name="id">ID</param>
public static void Update(ISession session, Object obj, object id)
{
ITransaction tx = session.BeginTransaction();
try
{
session.Update(obj, id);
TransCommit(tx);
}
catch (HibernateException ex)
{
TransRollback(tx);
log.Info(string.Format("更新失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+1 保存or更新对象
/// <summary>
/// 重载+1 保存or更新对象
/// </summary>
/// <param name="obj"></param>
public static void SaveOrUpdate(object obj)
{
try
{
session.SaveOrUpdate(obj);
}
catch (Exception ex)
{
log.Info(string.Format("保存or更新失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+2 保存or更新对象
/// <summary>
/// 重载+2 保存or更新对象
/// </summary>
/// <param name="session">会话</param>
/// <param name="obj"></param>
public static void SaveOrUpdate(ISession session, object obj)
{
try
{
session.SaveOrUpdate(obj);
}
catch (Exception ex)
{
log.Info(string.Format("保存or更新失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+1 删除对象
/// <summary>
/// 重载+1 删除对象
/// </summary>
/// <param name="obj">对象</param>
public static void Delete(Object obj)
{
ITransaction tx = session.BeginTransaction();
try
{
session.Delete(obj);
TransCommit(tx);
}
catch (HibernateException ex)
{
TransRollback(tx);
log.Info(string.Format("删除失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+2 删除对象
/// <summary>
/// 重载+2 删除对象
/// </summary>
/// <param name="query">查询</param>
/// <returns>受影响记录的行数</returns>
public static int Delete(string query)
{
ITransaction tx = session.BeginTransaction();
try
{
int getValue = session.Delete(query);
TransCommit(tx);
return getValue;
}
catch (HibernateException ex)
{
TransRollback(tx);
log.Info(string.Format("删除失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+3 删除对象
/// <summary>
/// 重载+3 删除对象
/// </summary>
/// <param name="query">查询</param>
/// <param name="value"></param>
/// <param name="type"></param>
/// <returns>受影响记录的行数</returns>
public static int Delete(string query, object value, NHibernate.Type.IType type)
{
ITransaction tx = session.BeginTransaction();
try
{
int getValue = session.Delete(query, value, type);
TransCommit(tx);
return getValue;
}
catch (HibernateException ex)
{
TransRollback(tx);
log.Info(string.Format("删除失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+4 删除对象
/// <summary>
/// 重载+4 删除对象
/// </summary>
/// <param name="query">查询</param>
/// <param name="values"></param>
/// <param name="types"></param>
/// <returns>受影响记录的行数</returns>
public static int Delete(string query, object[] values, NHibernate.Type.IType[] types)
{
ITransaction tx = session.BeginTransaction();
try
{
int getValue = session.Delete(query, values, types);
TransCommit(tx);
return getValue;
}
catch (HibernateException ex)
{
TransRollback(tx);
log.Info(string.Format("删除失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+5 删除对象
/// <summary>
/// 重载+5 删除对象
/// </summary>
/// <param name="session">会话</param>
/// <param name="obj">对象</param>
public static void Delete(ISession session, Object obj)
{
ITransaction tx = session.BeginTransaction();
try
{
session.Delete(obj);
TransCommit(tx);
}
catch (HibernateException ex)
{
TransRollback(tx);
log.Info(string.Format("删除失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+6 删除对象
/// <summary>
/// 重载+6 删除对象
/// </summary>
/// <param name="session">会话</param>
/// <param name="query">查询</param>
/// <returns>受影响记录的行数</returns>
public static int Delete(ISession session, string query)
{
ITransaction tx = session.BeginTransaction();
try
{
int getValue = session.Delete(query);
TransCommit(tx);
return getValue;
}
catch (HibernateException ex)
{
TransRollback(tx);
log.Info(string.Format("删除失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+7 删除对象
/// <summary>
/// 重载+7 删除对象
/// </summary>
/// <param name="session">会话</param>
/// <param name="query">查询</param>
/// <param name="value"></param>
/// <param name="type"></param>
/// <returns>受影响记录的行数</returns>
public static int Delete(ISession session, string query, object value, NHibernate.Type.IType type)
{
ITransaction tx = session.BeginTransaction();
try
{
int getValue = session.Delete(query, value, type);
TransCommit(tx);
return getValue;
}
catch (HibernateException ex)
{
TransRollback(tx);
log.Info(string.Format("删除失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+8 删除对象
/// <summary>
/// 重载+8 删除对象
/// </summary>
/// <param name="session">会话</param>
/// <param name="query">查询</param>
/// <param name="values"></param>
/// <param name="types"></param>
/// <returns>受影响记录的行数</returns>
public static int Delete(ISession session, string query, object[] values, NHibernate.Type.IType[] types)
{
ITransaction tx = session.BeginTransaction();
try
{
int getValue = session.Delete(query, values, types);
TransCommit(tx);
return getValue;
}
catch (HibernateException ex)
{
TransRollback(tx);
log.Info(string.Format("删除失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+1 创建查询对象
/// <summary>
/// 重载+1 创建查询对象
/// </summary>
/// <param name="hqlStr">HQL语句</param>
/// <param name="param">参数列表</param>
/// <returns>IQuery对象</returns>
public static IQuery CreateQuery(String hqlStr, IDictionary param)
{
try
{
IQuery query = session.CreateQuery(hqlStr);
string[] NamedParams = query.NamedParameters;
if (NamedParams != null && NamedParams.Length > 0)
{
for (int i = 0; i < NamedParams.Length; i++)
{
string name = NamedParams[i];
query.SetParameter(name, param[name]);
}
}
return query;
}
catch (Exception ex)
{
log.Info(string.Format("创建查询对象失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 重载+2 创建查询对象
/// <summary>
/// 重载+2 创建查询对象
/// </summary>
/// <param name="session">会话</param>
/// <param name="hqlStr">HQL语句</param>
/// <param name="param">参数列表</param>
/// <returns>IQuery对象</returns>
public static IQuery CreateQuery(ISession session, String hqlStr, IDictionary param)
{
try
{
IQuery query = session.CreateQuery(hqlStr);
string[] NamedParams = query.NamedParameters;
if (NamedParams != null && NamedParams.Length > 0)
{
for (int i = 0; i < NamedParams.Length; i++)
{
string name = NamedParams[i];
query.SetParameter(name, param[name]);
}
}
return query;
}
catch (Exception ex)
{
log.Info(string.Format("创建查询对象失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 提交事务
/// <summary>
/// 提交事务
/// </summary>
/// <param name="tx"></param>
public static void TransCommit(ITransaction tx)
{
try
{
if (!tx.WasRolledBack)
tx.Commit();
}
catch (HibernateException ex)
{
tx.Rollback();
log.Info(string.Format("提交事务失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
#region 回滚事务
/// <summary>
/// 回滚事务
/// </summary>
/// <param name="tx"></param>
public static void TransRollback(ITransaction tx)
{
try
{
tx.Rollback();
}
catch (HibernateException ex)
{
log.Info(string.Format("回滚事务失败!失败原因:{0}", ex.ToString()));
throw ex;
}
}
#endregion
}
}
后来经过李永京的帮忙,知道错在了在方法里用了事务。
该文章经过本人整理所得,欢迎转载,转载时请加上本文地址;本文基于署名 2.5 中国大陆许可协议发布,请勿演绎或用于商业目的,但是必须保留本文的署名张志涛(包含链接如您有任何疑问或者授权方面的协商,请给我留言。