Nhibernate 数据操作封装类 可以执行hql 原生sql 返回DataSet

publicclassSessionManager
{
#region当前单实例

privatereadonlystaticSessionManagerinstance=newSessionManager();
///<summary>
///当前实例
///</summary>
publicstaticSessionManagerCurrInstance
{
get
{
returninstance;
}
}

#endregion

privateISessionFactory_sessionFactory;
privateSessionManager()
{
_sessionFactory=GetSessionFactory();
}
privateISessionFactoryGetSessionFactory()
{
//stringstrFilePaht=System.AppDomain.CurrentDomain.BaseDirectory.ToString()+"hibernate.cfg.xml";
Configurationconfig=(newConfiguration()).Configure();
glo.DataBaseDerived=config.GetDerivedProperties()["connection.driver_class"].ToString();

returnconfig.BuildSessionFactory();
}
///<summary>
///获取Session
///</summary>
///<returns></returns>
publicISessionGetSession()
{
return_sessionFactory.OpenSession();
}

///<summary>
///初始数据库设置
///</summary>
publicvoidDbInitial()
{
ISession_session=_sessionFactory.OpenSession();
_session.Close();
}
}

publicclassNhibernateHelper:IDbHelper
{
#region当前单实例
privatereadonlystaticNhibernateHelperinstance=newNhibernateHelper();
publicstaticNhibernateHelperCurrInstance
{
get
{
returninstance;
}
}
#endregion
///<summary>
///新增记录
///</summary>
///<paramname="Model"></param>
///<returns></returns>
publicboolCreateModel(objectModel)
{
boolbl=true;

using(ISession_session=SessionManager.CurrInstance.GetSession())
{
ITransactiontx=_session.BeginTransaction();
try
{_session.Save(Model);
_session.Flush();
tx.Commit();
}
catch(HibernateExceptionex)
{
bl=false;
tx.Rollback();
throwex;
}
finally
{
if(_session!=null)
{
_session.Close();
}
}
}
returnbl;
}
///<summary>
///修改记录
///</summary>
///<paramname="Model"></param>
///<returns></returns>
publicboolUpdateModel(objectModel)
{
boolbl=true;
using(ISession_session=SessionManager.CurrInstance.GetSession())
{
ITransactiontx=_session.BeginTransaction();
try
{
_session.Update(Model);
_session.Flush();
tx.Commit();
}
catch(HibernateExceptionex)
{
bl=false;
tx.Rollback();
throwex;
}
finally
{
if(_session!=null)
{
_session.Close();
}
}
}
returnbl;
}
///<summary>
///批量保存更新实体类
///</summary>
///<paramname="Models"></param>
///<returns></returns>
publicboolSaveOrUpdateModel(IList<object>Models)
{
boolbl=true;
using(ISession_session=SessionManager.CurrInstance.GetSession())
{
ITransactiontx=_session.BeginTransaction();
try
{
foreach(varModelinModels)
{
_session.Update(Model);
}
_session.Flush();
tx.Commit();
}
catch(HibernateExceptionex)
{
bl=false;
tx.Rollback();
throwex;
}
finally
{
if(_session!=null)
{
_session.Close();
}
}
}
returnbl;
}
///<summary>
///删除记录
///</summary>
///<paramname="Model"></param>
///<returns></returns>
publicboolDeleteModel(objectModel)
{
boolbl=true;
using(ISession_session=SessionManager.CurrInstance.GetSession())
{
ITransactiontx=_session.BeginTransaction();
try
{
_session.Delete(Model);
_session.Flush();
tx.Commit();
}
catch(HibernateExceptionex)
{
bl=false;
tx.Rollback();
throwex;
}
finally
{
if(_session!=null)
{
_session.Close();
}
}
}
returnbl;
}
///<summary>
///删除记录(ByID)
///</summary>
///<paramname="Model"></param>
///<returns></returns>
publicboolDeleteModelByID(stringentityName,objectID)
{
boolbl=true;
using(ISession_session=SessionManager.CurrInstance.GetSession())
{
ITransactiontx=_session.BeginTransaction();
try
{
objectModel=_session.Get(entityName,ID);
_session.Delete(Model);
_session.Flush();
tx.Commit();
}
catch(HibernateExceptionex)
{
bl=false;
tx.Rollback();
throwex;
}
finally
{
if(_session!=null)
{
_session.Close();
}
}
}
returnbl;
}
///<summary>
///按ID查找记录
///</summary>
///<paramname="entityName">实体类的名字</param>
///<paramname="ID">记录ID</param>
///<returns></returns>
publicobjectGetModelById(stringentityName,objectID)
{
using(ISession_session=SessionManager.CurrInstance.GetSession())
{
try
{
return_session.Get(entityName,ID);
}
catch(HibernateExceptionex)
{
throwex;
}
finally
{
if(_session!=null)
{
_session.Close();
}
}
}
}
///<summary>
///执行Hql查询语句
///</summary>
///<paramname="hql"></param>
///<returns></returns>
publicIList<object>CreateHqlQuery(stringhql)
{
using(ISession_session=SessionManager.CurrInstance.GetSession())
{
try
{
return_session.CreateQuery(hql).List<object>();
}
catch(HibernateExceptionex)
{
throwex;
}
finally
{
if(_session!=null)
{
_session.Close();
}
}
}
}
///<summary>
///执行Hql查询语句,不直接释放session，请在外部使用时加using释放
///</summary>
///<paramname="hql"></param>
///<returns></returns>
publicIList<object>CreateHqlQueryNoRelease(stringhql,refISession_session)
{
try
{
_session=SessionManager.CurrInstance.GetSession();
return_session.CreateQuery(hql).List<object>();
}
catch(HibernateExceptionex)
{
throwex;
}

}
///<summary>
///执行Hql语句,并返回object[],例子：selectc.Name,count(c.Name)fromGbookcgroupbyc.Name
///</summary>
///<paramname="hql"></param>
///<returns></returns>
publicIList<object[]>CreateHqlQuery_Arry(stringhql)
{
using(ISession_session=SessionManager.CurrInstance.GetSession())
{
try
{
return_session.CreateQuery(hql).List<object[]>();
}
catch(HibernateExceptionex)
{
throwex;
}
finally
{
if(_session!=null)
{
_session.Close();
}
}
}
}
///<summary>
///执行Hql,更新、删除语句,多条语句使用;间隔
///</summary>
///<paramname="hql"></param>
///<returns>返回执行记录数</returns>
publicintCreateHqlQuery_UpdateAndDelete(stringhql)
{
intCount=0;
inti=0;
using(ISession_session=SessionManager.CurrInstance.GetSession())
{
ITransactiontx=_session.BeginTransaction();
try
{
string[]strArry=hql.Split(';');
foreach(stringstrhqlinstrArry)
{
i=_session.CreateQuery(strhql).ExecuteUpdate();
Count+=i;
}
_session.Flush();
tx.Commit();
}
catch(HibernateExceptionex)
{
Count=-1;
tx.Rollback();
throwex;
}
finally
{
if(_session!=null)
{
_session.Close();
}
}
}
returnCount;
}
///<summary>
///执行Sql查询语句
///</summary>
///<paramname="hql"></param>
///<returns></returns>
publicIList<object>CreateSqlQuery(stringsql)
{
using(ISession_session=SessionManager.CurrInstance.GetSession())
{
try
{
return_session.CreateSQLQuery(sql).List<object>();
}
catch(HibernateExceptionex)
{
throwex;
}
finally
{
if(_session!=null)
{
_session.Close();
}
}
}
}
///<summary>
///执行sql语句，没有返回数据集，提供事务支持
///</summary>
///<paramname="sql"></param>
///<returns></returns>
publicboolExecuteNonQuery(stringsql)
{
returnExecuteNonQuery(sql,null);
}
///<summary>
///执行sql语句，没有返回数据集，提供事务支持
///</summary>
///<paramname="sql"></param>
///<paramname="paramenters"></param>
///<returns></returns>
publicboolExecuteNonQuery(stringsql,IDbDataParameter[]paramenters)
{
boolbl=false;
ISession_session=null;
ITransactiontransaction=null;
try
{
_session=SessionManager.CurrInstance.GetSession();
transaction=_session.BeginTransaction();
IDbCommandcommand=_session.Connection.CreateCommand();
transaction.Enlist(command);//注意此处要把command添加到事物中
command.CommandText=sql;
if(paramenters!=null)
{
foreach(IDataParameterparminparamenters)
{
command.Parameters.Add(parm);
}
}
inti=command.ExecuteNonQuery();
transaction.Commit();
}
catch(Exceptionex)
{
if(transaction!=null)
{
transaction.Rollback();
}
throwex;
}
finally
{
if(_session!=null)
{
_session.Close();
}
}
returnbl;
}
///<summary>
///填充DataSet，方法二
///</summary>
///<paramname="sql"></param>
///<returns></returns>
publicDataSetExecuteDataset2(stringsql)
{
ISession_session=null;
DataSetds=newDataSet();
try
{
_session=SessionManager.CurrInstance.GetSession();
IDbCommandcommand=_session.Connection.CreateCommand();
command.CommandText=sql;
IDataReaderreader=command.ExecuteReader();
DataTableresult=newDataTable();
//result.Load(reader);//此方法亦可
DataTableschemaTable=reader.GetSchemaTable();
for(inti=0;i<schemaTable.Rows.Count;i++)
{
stringcolumnName=schemaTable.Rows[i][0].ToString();
result.Columns.Add(columnName);
}
while(reader.Read())
{
intfieldCount=reader.FieldCount;
object[]values=newObject[fieldCount];
for(inti=0;i<fieldCount;i++)
{
values[i]=reader.GetValue(i);
}
result.Rows.Add(values);
}
ds.Tables.Add(result);
}
catch(Exceptionex)
{
throwex;
}
finally
{
if(_session!=null)
{
_session.Close();
}
}
returnds;
}
///<summary>
///填充DataSet（此方法亦可）
///</summary>
///<paramname="sql"></param>
///<returns></returns>
publicDataSetExecuteDataset(stringsql)
{
returnExecuteDataset(sql,null);
}
///<summary>
///填充DataSet
///</summary>
///<paramname="sql"></param>
///<returns></returns>
publicDataSetExecuteDataset(stringsql,IDbDataParameter[]paramenters)
{
ISession_session=null;
DataSetds=newDataSet();
try
{
_session=SessionManager.CurrInstance.GetSession();
IDbCommandcommand=_session.Connection.CreateCommand();
command.CommandText=sql;
if(paramenters!=null)
{
foreach(IDataParameterparminparamenters)
{
command.Parameters.Add(parm);
}
}
switch(glo.DataBaseType)
{
caseDataBaseType.SqlServer:
SqlDataAdapterda=newSqlDataAdapter(commandasSqlCommand);
da.Fill(ds);
break;
caseDataBaseType.MySql:
MySqlDataAdapterdaMy=newMySqlDataAdapter(commandasMySqlCommand);
daMy.Fill(ds);
break;
caseDataBaseType.Oracle:
OracleDataAdapterdaOrl=newOracleDataAdapter(commandasOracleCommand);
daOrl.Fill(ds);
break;
default:
break;
}
}
catch(Exceptionex)
{
throwex;
}
finally
{
if(_session!=null)
{
_session.Close();
}
}
returnds;
}

}
///<summary>
///数据库类型
///</summary>
publicenumDataBaseType
{
MySql,
SqlServer,
Oracle
}
publicclassglo
{
privatestaticstringdataBaseDerived="";
///<summary>
///Nhibernate数据库驱动配置
///</summary>
publicstaticstringDataBaseDerived
{
set
{
dataBaseDerived=value;
switch(dataBaseDerived)
{
case"NHibernate.Driver.MySqlDataDriver":
dataBaseType=DataBaseType.MySql;
break;
case"NHibernate.Driver.SqlClientDriver":
dataBaseType=DataBaseType.SqlServer;
break;
case"NHibernate.Driver.OracleClientDriver":
dataBaseType=DataBaseType.Oracle;
break;
}
}
get
{
returndataBaseDerived;
}
}
privatestaticDataBaseTypedataBaseType;
///<summary>
///数据库类型
///</summary>
publicstaticDataBaseTypeDataBaseType
{
get
{
if(glo.DataBaseDerived=="")
{
SessionManager.CurrInstance.DbInitial();
}
returndataBaseType;
}
}
#region使用web.config的配置方法
//privatestaticDataBaseTypebaseType;
//publicstaticDataBaseTypeBaseType
//{
//get
//{
//stringstrDbtype=ConfigHelper.GetConfigString("DataType");
//switch(strDbtype)
//{
//case"MYSQL":
//baseType=DataBaseType.MySql;
//break;
//case"SQLSERVER":
//baseType=DataBaseType.SqlServer;
//break;
//case"ORACLE":
//baseType=DataBaseType.Oracle;
//break;
//}
//returnbaseType;
//}
//}
#endregion
}