public ResultInfo <int, string> QueryToReader(DbExecuteParameter dbExecuteParameter, Func <IDataReader, bool> rowAction)
{
int _times = 0;
while (Interlocked.CompareExchange(ref signal, 1, 0) == 1)
{
Thread.Sleep(lockInterval);
//waiting for lock to do;
if (_times >= (timeoutLock + dbExecuteParameter.ExectueTimeout))
{
return(ResultInfo <int, string> .Create(-1, "等待锁超时..."));
}
_times += (lockInterval / 1000);
}
try
{
int rows = 0;
using (DbConnection conn = CreateConnection(DbConnectionString))
{
if (conn.State != ConnectionState.Open)
{
conn.Open();
}
using (DbCommand cmd = CreateCommand(dbExecuteParameter, conn))
{
using (DbDataReader reader = cmd.ExecuteReader())
{
if (reader.HasRows == false)
{
return(ResultInfo <int, string> .Create(0, string.Empty));
}
bool isContinue = false;
while (reader.Read())
{
isContinue = rowAction(reader);
if (isContinue == false)
{
break;
}
++rows;
}
}
}
}
return(ResultInfo <int, string> .Create(rows, string.Empty));
}
catch (Exception ex)
{
return(new ResultInfo <int, string>(-1, ex.ToString()));
}
finally
{
Interlocked.Exchange(ref signal, 0);
}
}
/// <summary>
/// 同时执行多个sql语句使用
/// </summary>
/// <param name="sql"></param>
/// <param name="timeout"></param>
/// <returns></returns>
public ResultInfo <int, string> ExecuteTransaction(DbExecuteParameter dbExecuteParameter)
{
int _times = 0;
while (Interlocked.CompareExchange(ref signal, 1, 0) == 1)
{
Thread.Sleep(lockInterval);
//waiting for lock to do;
if (_times >= (timeoutLock + dbExecuteParameter.ExectueTimeout))
{
return(ResultInfo <int, string> .Create(-1, "等待锁超时..."));
}
_times += (lockInterval / 1000);
}
try
{
using (DbConnection conn = CreateConnection(DbConnectionString))
{
if (conn.State != ConnectionState.Open)
{
conn.Open();
}
using (DbTransaction tran = BeginTransaction(conn))
{
try
{
using (DbCommand cmd = CreateCommand(dbExecuteParameter, conn, tran))
{
int rt = cmd.ExecuteNonQuery();
tran.Commit();
var rValue = GetReturnParameter(cmd);
return(ResultInfo <int, string> .Create(rt < 0? 0 : rt,
rValue != null?rValue.ToString() : string.Empty));
}
}
catch (Exception ex)
{
tran.Rollback();
return(ResultInfo <int, string> .Create(-1, ex.ToString()));
}
}
}
}
catch (Exception ex)
{
return(ResultInfo <int, string> .Create(-1, ex.ToString()));
}
finally
{
Interlocked.Exchange(ref signal, 0);
}
}
public ResultInfo <List <T>, string> Query <T>(DbExecuteParameter dbExecuteParameter) where T : new()
{
int _times = 0;
while (Interlocked.CompareExchange(ref signal, 1, 0) == 1)
{
Thread.Sleep(lockInterval);
//waiting for lock to do;
if (_times >= (timeoutLock + dbExecuteParameter.ExectueTimeout))
{
return(ResultInfo <List <T>, string> .Create(null, "等待锁超时..."));
}
_times += (lockInterval / 1000);
}
try
{
using (DbConnection conn = CreateConnection(DbConnectionString))
{
if (conn.State != ConnectionState.Open)
{
conn.Open();
}
using (DbCommand cmd = CreateCommand(dbExecuteParameter, conn))
{
using (DbDataReader reader = cmd.ExecuteReader())
{
if (reader.HasRows == false)
{
return(ResultInfo <List <T>, string> .Create(new List <T>(1), string.Empty));
}
var items = reader.GetGenericObjectValues <T>(dbExecuteParameter.IgnoreCase);
return(ResultInfo <List <T>, string> .Create(items, string.Empty));
}
}
}
}
catch (Exception ex)
{
return(ResultInfo <List <T>, string> .Create(null, ex.ToString()));
}
finally
{
Interlocked.Exchange(ref signal, 0);
}
}
public ResultInfo <int, string> QueryToTable(DbExecuteParameter dbExecuteParameter, DataTable dstTable)
{
int _times = 0;
while (Interlocked.CompareExchange(ref signal, 1, 0) == 1)
{
Thread.Sleep(lockInterval);
//waiting for lock to do;
if (_times >= (timeoutLock + dbExecuteParameter.ExectueTimeout))
{
return(ResultInfo <int, string> .Create(-1, "等待锁超时..."));
}
_times += (lockInterval / 1000);
}
try
{
using (DbConnection conn = CreateConnection(DbConnectionString))
{
if (conn.State != ConnectionState.Open)
{
conn.Open();
}
using (DbCommand cmd = CreateCommand(dbExecuteParameter, conn))
{
using (DbDataReader dReader = cmd.ExecuteReader())
{
int oCnt = dstTable.Rows.Count;
dstTable.Load(dReader);
return(ResultInfo <int, string> .Create(dstTable.Rows.Count - oCnt, string.Empty));
}
}
}
}
catch (Exception ex)
{
return(ResultInfo <int, string> .Create(-1, ex.ToString()));
}
finally
{
Interlocked.Exchange(ref signal, 0);
}
}
public ResultInfo <DataSet, string> QueryToSet(DbExecuteParameter dbExecuteParameter)
{
int _times = 0;
while (Interlocked.CompareExchange(ref signal, 1, 0) == 1)
{
Thread.Sleep(lockInterval);
//waiting for lock to do;
if (_times >= (timeoutLock + dbExecuteParameter.ExectueTimeout))
{
return(ResultInfo <DataSet, string> .Create(null, "等待锁超时..."));
}
_times += (lockInterval / 1000);
}
try
{
using (DbConnection conn = CreateConnection(DbConnectionString))
{
if (conn.State != ConnectionState.Open)
{
conn.Open();
}
DataSet ds = new DataSet();
using (DbDataAdapter adapter = CreateAdapter())
{
using (DbCommand cmd = CreateCommand(dbExecuteParameter, conn))
{
adapter.SelectCommand = cmd;
adapter.Fill(ds);
}
}
return(ResultInfo <DataSet, string> .Create(ds, string.Empty));
}
}
catch (Exception ex)
{
return(new ResultInfo <DataSet, string>(null, ex.ToString()));
}
finally
{
Interlocked.Exchange(ref signal, 0);
}
}
public ResultInfo <T, string> ExecuteScalar <T>(DbExecuteParameter dbExecuteParameter)
{
int _times = 0;
while (Interlocked.CompareExchange(ref signal, 1, 0) == 1)
{
Thread.Sleep(lockInterval);
//waiting for lock to do;
if (_times >= (timeoutLock + dbExecuteParameter.ExectueTimeout))
{
return(ResultInfo <T, string> .Create(default(T), "等待锁超时..."));
}
_times += (lockInterval / 1000);
}
try
{
using (DbConnection conn = CreateConnection(DbConnectionString))
{
if (conn.State != ConnectionState.Open)
{
conn.Open();
}
using (DbCommand cmd = CreateCommand(dbExecuteParameter, conn))
{
object obj = cmd.ExecuteScalar();
var rValue = GetReturnParameter(cmd);
return(ResultInfo <T, string> .Create(obj == null?default(T) : (T)obj,
rValue == null?string.Empty : rValue.ToString()));
}
}
}
catch (Exception ex)
{
return(ResultInfo <T, string> .Create(default(T), ex.ToString()));
}
finally
{
Interlocked.Exchange(ref signal, 0);
}
}
protected DbCommand CreateCommand(DbExecuteParameter dbParameter,
DbConnection dbConn, DbTransaction dbTrans = null)
{
if (IsSingleton)
{
if (dbCommand == null)
{
dbCommand = dbFactory.CreateCommand();
}
}
else
{
if (dbCommand != null)
{
dbCommand.Dispose();
}
dbCommand = dbFactory.CreateCommand();
}
if (dbTrans != null)
{
dbCommand.Transaction = dbTrans;
}
if (dbParameter.IsStoredProcedure)
{
dbCommand.CommandType = CommandType.StoredProcedure;
}
dbCommand.Connection = dbConn;
dbCommand.CommandText = dbParameter.CommandText;
dbCommand.CommandTimeout = dbParameter.ExectueTimeout;
if (dbParameter.dbProviderParameters != null)
{
foreach (DbProviderParameter param in dbParameter.dbProviderParameters)
{
dbCommand.Parameters.Add(CreateParameter(param));
}
}
return(dbCommand);
}
public ResultInfo <IDataReader, string> QueryToReader(DbExecuteParameter dbExecuteParameter)
{
int _times = 0;
while (Interlocked.CompareExchange(ref signal, 1, 0) == 1)
{
Thread.Sleep(lockInterval);
//waiting for lock to do;
if (_times >= (timeoutLock + dbExecuteParameter.ExectueTimeout))
{
return(ResultInfo <IDataReader, string> .Create(null, "等待锁超时..."));
}
_times += (lockInterval / 1000);
}
try
{
DbConnection conn = CreateConnection(DbConnectionString);
{
if (conn.State != ConnectionState.Open)
{
conn.Open();
}
DbCommand cmd = CreateCommand(dbExecuteParameter, conn);
{
IDataReader reader = cmd.ExecuteReader();
return(ResultInfo <IDataReader, string> .Create(reader, string.Empty));
}
}
}
catch (Exception ex)
{
return(ResultInfo <IDataReader, string> .Create(null, ex.Message));
}
finally
{
Interlocked.Exchange(ref signal, 0);
}
}
/// <summary>
/// Fun<DataTable,bool>回调方法返回false则中断执行直接返回
/// </summary>
/// <param name="dbExecuteParameter"></param>
/// <param name="action"></param>
/// <returns></returns>
public ResultInfo <int, string> QueryChanged(DbExecuteParameter dbExecuteParameter, Func <DataTable, bool> action)
{
int _times = 0;
while (Interlocked.CompareExchange(ref signal, 1, 0) == 1)
{
Thread.Sleep(lockInterval);
//waiting for lock to do;
if (_times >= (timeoutLock + dbExecuteParameter.ExectueTimeout))
{
return(ResultInfo <int, string> .Create(-1, "等待锁超时..."));
}
_times += (lockInterval / 1000);
}
try
{
using (DbConnection conn = CreateConnection(DbConnectionString))
{
if (conn.State != ConnectionState.Open)
{
conn.Open();
}
using (DbDataAdapter adapter = this.CreateAdapter())
{
using (DbCommand cmd = this.CreateCommand(dbExecuteParameter, conn))
{
DataTable dt = new DataTable();
adapter.SelectCommand = cmd;
adapter.Fill(dt);
if (dt.Rows.Count == 0)
{
return(ResultInfo <int, string> .Create(-1, "无可更新的数据行"));
}
bool isContinue = action(dt);
if (isContinue == false)
{
return(ResultInfo <int, string> .Create(0, string.Empty));
}
DataTable changedt = dt.GetChanges(DataRowState.Added | DataRowState.Deleted | DataRowState.Modified);
if (changedt != null && changedt.Rows.Count > 0)
{
using (DbCommandBuilder dbBuilder = this.CreateCommandBuilder())
{
dbBuilder.DataAdapter = adapter;
int rt = adapter.Update(changedt);
return(ResultInfo <int, string> .Create(rt, string.Empty));
}
}
else
{
return(ResultInfo <int, string> .Create(0, string.Empty));
}
}
}
}
}
catch (Exception ex)
{
return(ResultInfo <int, string> .Create(-1, ex.ToString()));
}
finally
{
Interlocked.Exchange(ref signal, 0);
}
}
