public ResultInfo <IDataReader, string> QueryToReader(DbExecuteParameter dbExecuteParameter)
{
while (Interlocked.CompareExchange(ref signal, 1, 0) == 1)
{
Thread.Sleep(LockTimeout);
//waiting for lock to do;
}
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(new ResultInfo <IDataReader, string>(null, ex.Message));
}
finally
{
Interlocked.Exchange(ref signal, 0);
}
}
public ResultInfo <int, string> ExecuteCmd(DbExecuteParameter dbExecuteParameter)
{
while (Interlocked.CompareExchange(ref signal, 1, 0) == 1)
{
Thread.Sleep(LockTimeout);
//waiting for lock to do;
}
try
{
using (DbConnection conn = CreateConnection(DbConnectionString))
{
if (conn.State != ConnectionState.Open)
{
conn.Open();
}
using (DbCommand cmd = CreateCommand(dbExecuteParameter, conn))
{
int rt = cmd.ExecuteNonQuery();
var rValue = GetReturnParameter(cmd);
return(new ResultInfo <int, string>(rt,
rValue == null ? string.Empty : rValue.ToString()));
}
}
}
catch (Exception ex)
{
return(new ResultInfo <int, string>(-1, ex.ToString()));
}
finally
{
Interlocked.Exchange(ref signal, 0);
}
}
public ResultInfo <DataTable, string> GetDataTable(DbExecuteParameter dbExecuteParameter)
{
ResultInfo <DataTable, string> resultInfo = new ResultInfo <DataTable, string>();
resultInfo = _provider.Query(dbExecuteParameter);
return(resultInfo);
}
public ResultInfo <DataSet, string> GetDataSet(DbExecuteParameter dbExecuteParameter)
{
ResultInfo <DataSet, string> resultInfo = new ResultInfo <DataSet, string>();
resultInfo = _pivotDataProvider.GetDataSet(dbExecuteParameter);
return(resultInfo);
}
public DataTable GetSystemFieldsMapping()
{
DataTable resultTable = new DataTable();
try
{
DbExecuteParameter dbExecuteParameter = new DbExecuteParameter();
dbExecuteParameter.CommandText = "SELECT NameSc,SysColumnName,SysTableName FROM dbo.TabColName";
dbExecuteParameter.IgnoreCase = true;
dbExecuteParameter.IsStoredProcedure = false;
dbExecuteParameter.ExectueTimeout = 1800;
ResultInfo <DataTable, string> resultInfo = GetDataTable(dbExecuteParameter);
if (resultInfo.Result != null)
{
resultTable = resultInfo.Result;
}
else
{
throw new Exception(resultInfo.Info);
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
return(resultTable);
}
public ResultInfo <int, string> QueryTo <T>(DbExecuteParameter dbExecuteParameter, Func <T, bool> rowAction)
where T : new()
{
while (Interlocked.CompareExchange(ref signal, 1, 0) == 1)
{
Thread.Sleep(LockTimeout);
//waiting for lock to do;
}
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())
{
T row = reader.DataReaderTo <T>(dbExecuteParameter.IgnoreCase);
isContinue = rowAction(row);
if (isContinue == false)
{
break;
}
++rows;
}
}
}
}
return(ResultInfo <int, string> .Create <int, string>(rows, string.Empty));
}
catch (Exception ex)
{
return(new ResultInfo <int, string>(-1, ex.ToString()));
}
finally
{
Interlocked.Exchange(ref signal, 0);
}
}
public ResultInfo <DataTable, string> GetDataTable()
{
DbExecuteParameter dbExecuteParameter = new DbExecuteParameter();
dbExecuteParameter.IsStoredProcedure = true;
dbExecuteParameter.IgnoreCase = true;
dbExecuteParameter.CommandText = "P_Test";
ResultInfo <DataTable, string> resultInfo = new ResultInfo <DataTable, string>();
resultInfo = _pivotDataProvider.GetDataTable(dbExecuteParameter);
return(resultInfo);
}
public ResultInfo <List <T>, string> Query <T>(DbExecuteParameter dbExecuteParameter) where T : new()
{
while (Interlocked.CompareExchange(ref signal, 1, 0) == 1)
{
Thread.Sleep(LockTimeout);
//waiting for lock to do;
}
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(new ResultInfo <List <T>, string>(new List <T>(1), string.Empty));
}
var items = reader.GetGenericObjectValues <T>(dbExecuteParameter.IgnoreCase);
return(new ResultInfo <List <T>, string>(items, string.Empty));
}
}
}
}
catch (Exception ex)
{
return(new ResultInfo <List <T>, string>(null, 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 <int, string> QueryToTable(DbExecuteParameter dbExecuteParameter, DataTable dstTable)
{
while (Interlocked.CompareExchange(ref signal, 1, 0) == 1)
{
Thread.Sleep(LockTimeout);
//waiting for lock to do;
}
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(new ResultInfo <int, string>(dstTable.Rows.Count - oCnt, string.Empty));
}
}
}
}
catch (Exception ex)
{
return(new ResultInfo <int, string>(-1, ex.ToString()));
}
finally
{
Interlocked.Exchange(ref signal, 0);
}
}
public ResultInfo <DataSet, string> QueryToSet(DbExecuteParameter dbExecuteParameter)
{
while (Interlocked.CompareExchange(ref signal, 1, 0) == 1)
{
Thread.Sleep(LockTimeout);
//waiting for lock to do;
}
try
{
using (DbConnection conn = CreateConnection(DbConnectionString))
{
if (conn.State != ConnectionState.Open)
{
conn.Open();
}
DataSet dt = new DataSet();
using (DbDataAdapter adapter = CreateAdapter())
{
using (DbCommand cmd = CreateCommand(dbExecuteParameter, conn))
{
adapter.SelectCommand = cmd;
adapter.Fill(dt);
}
}
return(new ResultInfo <DataSet, string>(dt, string.Empty));
}
}
catch (Exception ex)
{
return(new ResultInfo <DataSet, string>(null, ex.ToString()));
}
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)
{
while (Interlocked.CompareExchange(ref signal, 1, 0) == 1)
{
Thread.Sleep(LockTimeout);
//waiting for lock to do;
}
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(new ResultInfo <int, string>(-1, "无可更新的数据行"));
}
bool isContinue = action(dt);
if (isContinue == false)
{
return(new ResultInfo <int, string>(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(new ResultInfo <int, string>(rt, string.Empty));
}
}
else
{
return(new ResultInfo <int, string>(-1, "无变更的数据行"));
}
}
}
}
}
catch (Exception ex)
{
return(new ResultInfo <int, string>(-1, ex.ToString()));
}
finally
{
Interlocked.Exchange(ref signal, 0);
}
}
