AHTC/RFIDReaderTC/DBOperator/DbHelperSQL.cs
2025-05-19 09:22:33 +08:00

678 lines
23 KiB
C#
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

using System;
using System.Collections;
using System.Collections.Specialized;
using System.Data;
using System.Data.SqlClient;
using System.Configuration;
namespace Dictionary.DBUtility
{
/// <summary>
/// 数据访问抽象基础类
/// Copyright (C) 2004-2008
/// All rights reserved
/// </summary>
public abstract class DbHelperSQL
{
//数据库连接字符串(web.config来配置)
public static string _dbconnString = ConfigurationSettings.AppSettings["_dbconnString"];
//public static string _dbconnString = LTP.Common.DEncrypt.DESEncrypt.Decrypt(LTP.Common.ConfigHelper.GetConfigString("_dbconnString"));
public DbHelperSQL()
{
}
#region
public static int GetMaxID(string FieldName, string TableName)
{
string strsql = "select max(" + FieldName + ")+1 from " + TableName;
object obj = GetSingle(strsql);
if (obj == null)
{
return 1;
}
else
{
return int.Parse(obj.ToString());
}
}
public static bool Exists(string strSql)
{
object obj =GetSingle(strSql);
int cmdresult;
if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
{
cmdresult = 0;
}
else
{
cmdresult = int.Parse(obj.ToString());
}
if (cmdresult == 0)
{
return false;
}
else
{
return true;
}
}
public static bool Exists(string strSql, params SqlParameter[] cmdParms)
{
object obj =GetSingle(strSql, cmdParms);
int cmdresult;
if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
{
cmdresult = 0;
}
else
{
cmdresult = int.Parse(obj.ToString());
}
if (cmdresult == 0)
{
return false;
}
else
{
return true;
}
}
#endregion
#region SQL语句
/// <summary>
/// 执行SQL语句返回影响的记录数
/// </summary>
/// <param name="SQLString">SQL语句</param>
/// <returns>影响的记录数</returns>
public static int ExecuteSql(string SQLString)
{
using (IDbCommand cmd = _dbf.GetDBCommand(SQLString, _dbconn))
{
try
{
Open();
int rows = cmd.ExecuteNonQuery();
return rows;
}
catch (Exception E)
{
Close();
throw E;
}
}
}
/// <summary>
/// 执行SQL语句设置命令的执行等待时间
/// </summary>
/// <param name="SQLString"></param>
/// <param name="Times"></param>
/// <returns></returns>
public static int ExecuteSqlByTime(string SQLString, int Times)
{
using (IDbCommand cmd = _dbf.GetDBCommand(SQLString, _dbconn))
{
try
{
Open();
cmd.CommandTimeout = Times;
int rows = cmd.ExecuteNonQuery();
return rows;
}
catch (Exception E)
{
Close();
throw new Exception(E.Message);
}
}
}
/// <summary>
/// 执行多条SQL语句实现数据库事务。
/// </summary>
/// <param name="SQLStringList">多条SQL语句</param>
public static void ExecuteSqlTran(ArrayList SQLStringList)
{
conn.Open();
IDbCommand cmd = _dbf.GetDBCommand();//IDbCommand cmd = _dbf.GetDBCommand();
cmd.Connection = _dbconn;
TransBegin();
cmd.Transaction = _dbtrans
try
{
for (int n = 0; n < SQLStringList.Count; n++)
{
string strsql = SQLStringList[n].ToString();
if (strsql.Trim().Length > 1)
{
cmd.CommandText = strsql;
cmd.ExecuteNonQuery();
}
}
TransCommit();
}
catch (Exception E)
{
tx.Rollback();
throw new Exception(E.Message);
}
}
/// <summary>
/// 执行带一个存储过程参数的SQL语句。
/// </summary>
/// <param name="SQLString">SQL语句</param>
/// <param name="content">参数内容,比如一个字段是格式复杂的文章,有特殊符号,可以通过这个方式添加</param>
/// <returns>影响的记录数</returns>
public static int ExecuteSql(string SQLString, string content)
{
IDbCommand cmd = _dbf.GetDBCommand(SQLString, _dbconn);
IDbDataParameter myParameter =_dbf.GetParameter("@content", DbType.NText);
myParameter.Value = content;
cmd.Parameters.Add(myParameter);
try
{
Open();
int rows = cmd.ExecuteNonQuery();
return rows;
}
catch (Exception E)
{
throw new Exception(E.Message);
}
finally
{
cmd.Dispose();
Close();
}
}
/// <summary>
/// 执行带一个存储过程参数的的SQL语句。
/// </summary>
/// <param name="SQLString">SQL语句</param>
/// <param name="content">参数内容,比如一个字段是格式复杂的文章,有特殊符号,可以通过这个方式添加</param>
/// <returns>影响的记录数</returns>
public static object ExecuteSqlGet(string SQLString, string content)
{
IDbCommand cmd = _dbf.GetDBCommand(SQLString, _dbconn);
IDbDataParameter myParameter =_dbf.GetParameter("@content", DbType.NText);
myParameter.Value = content;
cmd.Parameters.Add(myParameter);
try
{
Open();
object obj = cmd.ExecuteScalar();
if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
{
return null;
}
else
{
return obj;
}
}
catch (Exception E)
{
throw new Exception(E.Message);
}
finally
{
cmd.Dispose();
Close();
}
}
/// <summary>
/// 向数据库里插入图像格式的字段(和上面情况类似的另一种实例)
/// </summary>
/// <param name="strSQL">SQL语句</param>
/// <param name="fs">图像字节,数据库的字段类型为image的情况</param>
/// <returns>影响的记录数</returns>
public static int ExecuteSqlInsertImg(string strSQL, byte[] fs)
{
IDbCommand cmd = _dbf.GetDBCommand(strSQL, _dbconn);
IDbDataParameter myParameter =_dbf.GetParameter("@fs", DbType.Image);
myParameter.Value = fs;
cmd.Parameters.Add(myParameter);
try
{
Open();
int rows = cmd.ExecuteNonQuery();
return rows;
}
catch (Exception E)
{
throw new Exception(E.Message);
}
finally
{
cmd.Dispose();
Close();
}
}
/// <summary>
/// 执行一条计算查询结果语句返回查询结果object
/// </summary>
/// <param name="SQLString">计算查询结果语句</param>
/// <returns>查询结果object</returns>
public static object GetSingle(string SQLString)
{
using (IDbCommand cmd = _dbf.GetDBCommand(SQLString, _dbconn))
{
try
{
Open();
object obj = cmd.ExecuteScalar();
if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
{
return null;
}
else
{
return obj;
}
}
catch (Exception e)
{
Close();
throw new Exception(e.Message);
}
}
}
/// <summary>
/// 执行查询语句返回SqlDataReader(使用该方法切记要手工关闭SqlDataReader和连接)
/// </summary>
/// <param name="strSQL">查询语句</param>
/// <returns>SqlDataReader</returns>
public static IDbDataReader ExecuteReader(string strSQL)
{
IDbCommand cmd = _dbf.GetDBCommand(strSQL, _dbconn);
try
{
Open();
IDataReader myReader =GetDataReader( cmd);
return myReader;
}
catch (Exception e)
{
throw new Exception(e.Message);
}
//finally //不能在此关闭,否则,返回的对象将无法使用
//{
// cmd.Dispose();
// Close();
//}
}
/// <summary>
/// 执行查询语句返回DataSet
/// </summary>
/// <param name="SQLString">查询语句</param>
/// <returns>DataSet</returns>
public static DataSet Query(string SQLString)
{
try
{
IDbCommand dbc = _dbf.GetDBCommand();
if (_dbtrans != null)
{
dbc.Transaction = _dbtrans;
}
dbc.Connection = _dbconn;
dbc.CommandText = sql;
IDbDataAdapter ida = _dbf.GetDataAdapter(dbc);
DataSet ds = new DataSet();
ida.Fill(ds);
return ds;
}
catch (Exception ex)
{
_DBConnInfo = ex.Message;
throw ex;
//return null;
}
}
/// <summary>
/// 执行查询语句返回DataSet,设置命令的执行等待时间
/// </summary>
/// <param name="SQLString"></param>
/// <param name="Times"></param>
/// <returns></returns>
public static DataSet Query(string SQLString, int Times)
{
DataSet ds = new DataSet();
try
{
Open();
IDbCommand dbc = _dbf.GetDBCommand();
if (_dbtrans != null)
{
dbc.Transaction = _dbtrans;
}
dbc.Connection = _dbconn;
dbc.CommandText = SQLString;
SqlDataAdapter command = new SqlDataAdapter(dbc);
command.SelectCommand.CommandTimeout = Times;
command.Fill(ds, "ds");
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
return ds;
}
#endregion
#region SQL语句
/// <summary>
/// 执行SQL语句返回影响的记录数
/// </summary>
/// <param name="SQLString">SQL语句</param>
/// <returns>影响的记录数</returns>
public static int ExecuteSql(string SQLString, params IDbDataParameter[] cmdParms)
{
using (IDbCommand cmd = _dbf.GetDBCommand())
{
try
{
PrepareCommand(cmd, _dbconn, null, SQLString, cmdParms);
int rows = cmd.ExecuteNonQuery();
cmd.Parameters.Clear();
return rows;
}
catch (Exception E)
{
throw new Exception(E.Message);
}
}
}
/// <summary>
/// 执行多条SQL语句实现数据库事务。
/// </summary>
/// <param name="SQLStringList">SQL语句的哈希表key为sql语句value是该语句的SqlParameter[]</param>
public static void ExecuteSqlTran(Hashtable SQLStringList)
{
Open();
TransBegin();
IDbCommand cmd = _dbf.GetDBCommand();
try
{
//循环
foreach (DictionaryEntry myDE in SQLStringList)
{
string cmdText = myDE.Key.ToString();
IDbDataParameter[] cmdParms = (IDbDataParameter[])myDE.Value;
PrepareCommand(cmd, _dbconn, _dbtrans, cmdText, cmdParms);
int val = cmd.ExecuteNonQuery();
cmd.Parameters.Clear();
TransCommit();
}
}
catch
{
TransRollback();
throw;
}
}
}
/// <summary>
/// 执行一条计算查询结果语句返回查询结果object
/// </summary>
/// <param name="SQLString">计算查询结果语句</param>
/// <returns>查询结果object</returns>
public static object GetSingle(string SQLString, params IDbDataParameter[] cmdParms)
{
using (IDbCommand cmd = _dbf.GetDBCommand())
{
try
{
PrepareCommand(cmd, _dbconn, null, SQLString, cmdParms);
object obj = cmd.ExecuteScalar();
cmd.Parameters.Clear();
if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
{
return null;
}
else
{
return obj;
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
}
/// <summary>
/// 执行查询语句返回SqlDataReader (使用该方法切记要手工关闭SqlDataReader和连接)
/// </summary>
/// <param name="strSQL">查询语句</param>
/// <returns>SqlDataReader</returns>
public static IDataReader ExecuteReader(string SQLString, params IDbDataParameter[] cmdParms)
{
IDbCommand cmd = _dbf.GetDBCommand();
try
{
PrepareCommand(cmd, _dbconn, null, SQLString, cmdParms);
IDataReader myReader =_dbf.GetDataReader( cmd);
cmd.Parameters.Clear();
return myReader;
}
catch (Exception e)
{
throw new Exception(e.Message);
}
//finally //不能在此关闭,否则,返回的对象将无法使用
//{
// cmd.Dispose();
// Close();
//}
}
/// <summary>
/// 执行查询语句返回DataSet
/// </summary>
/// <param name="SQLString">查询语句</param>
/// <returns>DataSet</returns>
public static DataSet Query(string SQLString, params IDbDataParameter[] cmdParms)
{
IDbCommand cmd = _dbf.GetDBCommand();
PrepareCommand(cmd, _dbconn, null, SQLString, cmdParms);
using (IDataAdapter da = _dbf.GetDataAdapter(cmd))
{
DataSet ds = new DataSet();
try
{
da.Fill(ds, "ds");
cmd.Parameters.Clear();
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
return ds;
}
}
private static void PrepareCommand(IDbCommand cmd, IDbConnection conn, IDbTransaction trans, string cmdText, SqlParameter[] cmdParms)
{
Open();
cmd.Connection = _dbconn;
cmd.CommandText = cmdText;
if (trans != null)
cmd.Transaction = trans;
cmd.CommandType = CommandType.Text;//cmdType;
if (cmdParms != null)
{
foreach (IDbDataParameter parameter in cmdParms)
{
if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) &&
(parameter.Value == null))
{
parameter.Value = DBNull.Value;
}
cmd.Parameters.Add(parameter);
}
}
}
#endregion
#region
/// <summary>
/// 执行存储过程 (使用该方法切记要手工关闭SqlDataReader和连接)
/// </summary>
/// <param name="storedProcName">存储过程名</param>
/// <param name="parameters">存储过程参数</param>
/// <returns>SqlDataReader</returns>
public static IDataReader RunProcedure(string storedProcName, IDataParameter[] parameters)
{
SqlDataReader returnReader;
Open();
IDbCommand command = BuildQueryCommand(_dbconn, storedProcName, parameters);
command.CommandType = CommandType.StoredProcedure;
returnReader =_dbf.GetDataReader();
//Close(); 不能在此关闭,否则,返回的对象将无法使用
return returnReader;
}
/// <summary>
/// 执行存储过程
/// </summary>
/// <param name="storedProcName">存储过程名</param>
/// <param name="parameters">存储过程参数</param>
/// <param name="tableName">DataSet结果中的表名</param>
/// <returns>DataSet</returns>
public static DataSet RunProcedure(string storedProcName, IDataParameter[] parameters, string tableName)
{
DataSet dataSet = new DataSet();
Open();
IDbDataAdapter sqlDA = _dbf.GetDataAdapter();
sqlDA.SelectCommand = BuildQueryCommand(_dbconn, storedProcName, parameters);
sqlDA.Fill(dataSet, tableName);
Close();
return dataSet;
}
public static DataSet RunProcedure(string storedProcName, IDataParameter[] parameters, string tableName, int Times)
{
DataSet dataSet = new DataSet();
Open();
IDbDataAdapter sqlDA = _dbf.GetDataAdapter();
sqlDA.SelectCommand = BuildQueryCommand(_dbconn, storedProcName, parameters);
sqlDA.SelectCommand.CommandTimeout = Times;
sqlDA.Fill(dataSet, tableName);
Close();
return dataSet;
}
/// <summary>
/// 构建 SqlCommand 对象(用来返回一个结果集,而不是一个整数值)
/// </summary>
/// <param name="_dbconn">数据库连接</param>
/// <param name="storedProcName">存储过程名</param>
/// <param name="parameters">存储过程参数</param>
/// <returns>SqlCommand</returns>
private static IDbCommand BuildQueryCommand(IDbConnection _dbconn, string storedProcName, IDataParameter[] parameters)
{
IDbCommand command = _dbf.GetDBCommand(storedProcName, _dbconn);
command.CommandType = CommandType.StoredProcedure;
foreach (SqlParameter parameter in parameters)
{
if (parameter != null)
{
// 检查未分配值的输出参数,将其分配以DBNull.Value.
if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) &&
(parameter.Value == null))
{
parameter.Value = DBNull.Value;
}
command.Parameters.Add(parameter);
}
}
return command;
}
/// <summary>
/// 执行存储过程,返回影响的行数
/// </summary>
/// <param name="storedProcName">存储过程名</param>
/// <param name="parameters">存储过程参数</param>
/// <param name="rowsAffected">影响的行数</param>
/// <returns></returns>
public static int RunProcedure(string storedProcName, IDataParameter[] parameters, out int rowsAffected)
{
int result;
Open();
IDbCommand command = BuildIntCommand(_dbconn, storedProcName, parameters);
rowsAffected = command.ExecuteNonQuery();
result = (int)command.Parameters["ReturnValue"].Value;
//Close();
return result;
}
/// <summary>
/// 创建 SqlCommand 对象实例(用来返回一个整数值)
/// </summary>
/// <param name="storedProcName">存储过程名</param>
/// <param name="parameters">存储过程参数</param>
/// <returns>SqlCommand 对象实例</returns>
private static IDbCommand BuildIntCommand(IDbConnection _dbconn, string storedProcName, IDataParameter[] parameters)
{
IDbCommand command = BuildQueryCommand(_dbconn, storedProcName, parameters);
command.Parameters.Add(new SqlParameter("ReturnValue",
SqlDbType.Int, 4, ParameterDirection.ReturnValue,
false, 0, 0, string.Empty, DataRowVersion.Default, null));
return command;
}
#endregion
}
}