DbHelperSQL

public DbHelperSQL()
{
}

///// <summary>
///// 设置数据库连接字符串
///// </summary>
///// <param name="str">web.config constr</param>
//public static void SetConnStr(string str)
//{
// connectionString = System.Configuration.ConfigurationManager.AppSettings["" + str + ""].ToString();
//}

 

#region 执行简单Sql语句
/// <summary>
/// 执行Sql语句
/// </summary>
/// <param name="strSql"></param>
public static int ExecuteNonQuery(string strSql)
{
#region
int rowscount = 0;
SqlCommand cmd = null;
try
{
cmd = new SqlCommand(strSql, new SqlConnection(connectionString));
if (cmd.Connection.State == ConnectionState.Closed)
cmd.Connection.Open();
cmd.CommandTimeout = 300;
rowscount = cmd.ExecuteNonQuery();
}
catch (SqlException sqlex) { throw sqlex; }
finally
{
cmd.Connection.Close();
cmd.Dispose();
////CloseConnection();
}
return rowscount;
#endregion
}

/// <summary>
/// 执行Sql语句
/// </summary>
/// <param name="strSql"></param>
public static int ExecuteNonQuery(string strSql, string connectionStr)
{
#region
int rowscount = 0;
SqlCommand cmd = null;
try
{
cmd = new SqlCommand(strSql, new SqlConnection(connectionStr));
if (cmd.Connection.State == ConnectionState.Closed)
cmd.Connection.Open();
cmd.CommandTimeout = 300;
rowscount = cmd.ExecuteNonQuery();
}
catch (SqlException sqlex) { throw sqlex; }
finally
{
cmd.Connection.Close();
cmd.Dispose();
////CloseConnection();
}
return rowscount;
#endregion
}

/// <summary>
/// 执行查询语句，返回DataSet
/// </summary>
/// <param name="SQLString">查询语句</param>
/// <returns>DataSet</returns>
public static DataSet Query(string strSql)
{
SqlCommand cmd = new SqlCommand(strSql, new SqlConnection(connectionString));
cmd.CommandTimeout = 300;
DataSet ds = null;
using (SqlDataAdapter da = new SqlDataAdapter(cmd))
{
try
{
if (cmd.Connection.State == ConnectionState.Closed)
cmd.Connection.Open();

ds = new DataSet();
da.Fill(ds, "ds");
cmd.Parameters.Clear();
}
catch (System.Data.SqlClient.SqlException ex)
{
throw new Exception(ex.Message);
}
finally
{
cmd.Connection.Close();
cmd.Dispose();
cmd = null;
////CloseConnection();
}
return ds;
}
}

/// <summary>
/// 执行查询语句，返回DataSet
/// </summary>
/// <param name="SQLString">查询语句</param>
/// <returns>DataSet</returns>
public static DataSet Query(string strSql, string connectionStr)
{
SqlCommand cmd = new SqlCommand(strSql, new SqlConnection(connectionStr));
cmd.CommandTimeout = 300;
DataSet ds = null;
using (SqlDataAdapter da = new SqlDataAdapter(cmd))
{
try
{
if (cmd.Connection.State == ConnectionState.Closed)
cmd.Connection.Open();

ds = new DataSet();
da.Fill(ds, "ds");
cmd.Parameters.Clear();
}
catch (System.Data.SqlClient.SqlException ex)
{
throw new Exception(ex.Message);
}
finally
{
cmd.Connection.Close();
cmd.Dispose();
cmd = null;
////CloseConnection();
}
return ds;
}
}

/// <summary>
/// 执行SQL语句，并返回第一行第一列结果
/// </summary>
/// <param name="strSql">SQL语句</param>
/// <returns></returns>
public static string ExecuteScalar(string strSql)
{
#region
string strReturn = "";
SqlCommand cmd = null;
try
{
cmd = new SqlCommand(strSql, new SqlConnection(connectionString));
if (cmd.Connection.State == ConnectionState.Closed)
cmd.Connection.Open();
cmd.CommandTimeout = 300;
object obj = cmd.ExecuteScalar();
if (obj == null)
return string.Empty;
strReturn = obj.ToString();
}
catch (SqlException ex)
{
throw ex;
}
finally
{
cmd.Connection.Close();
cmd.Dispose();
////CloseConnection();
}
return strReturn;
#endregion
}

/// <summary>
/// 执行SQL语句，并返回第一行第一列结果
/// </summary>
/// <param name="strSql">SQL语句</param>
/// <returns></returns>
public static string ExecuteScalar(string strSql, string connectionStr)
{
#region
string strReturn = "";
SqlCommand cmd = null;
try
{
cmd = new SqlCommand(strSql, new SqlConnection(connectionStr));
if (cmd.Connection.State == ConnectionState.Closed)
cmd.Connection.Open();
cmd.CommandTimeout = 300;
object obj = cmd.ExecuteScalar();
if (obj == null)
return string.Empty;
strReturn = obj.ToString();
}
catch (SqlException ex)
{
throw ex;
}
finally
{
cmd.Connection.Close();
cmd.Dispose();
////CloseConnection();
}
return strReturn;
#endregion
}

/// <summary>
/// 执行存储过程，返回结果第一行第一列
/// </summary>
/// <param name="procName">存储过程</param>
/// <param name="parameters">参数</param>
/// <returns>select</returns>
#region 执行存储过程，返回结果第一行第一列
public static object RunProcedureScalar(string procName, SqlParameter[] parameters)
{
using (SqlConnection conn = new SqlConnection(connectionString))
{
object oj = new object();
try
{
if (conn.State == ConnectionState.Closed)
conn.Open();
SqlCommand cmd = new SqlCommand(procName, conn);
cmd.CommandType = CommandType.StoredProcedure;
foreach (SqlParameter parameter in parameters)
{
cmd.Parameters.Add(parameter);
}
oj = cmd.ExecuteScalar();
}
catch (System.Data.SqlClient.SqlException ex)
{
throw new Exception(ex.Message);
}
finally
{

conn.Close();
}
return oj;
}
}

public static object RunProcedureScalar(string procName, SqlParameter[] parameters, string connectionStr)
{
using (SqlConnection conn = new SqlConnection(connectionStr))
{
object oj = new object();
try
{
if (conn.State == ConnectionState.Closed)
conn.Open();
SqlCommand cmd = new SqlCommand(procName, conn);
cmd.CommandType = CommandType.StoredProcedure;
foreach (SqlParameter parameter in parameters)
{
cmd.Parameters.Add(parameter);
}
oj = cmd.ExecuteScalar();
}
catch (System.Data.SqlClient.SqlException ex)
{
throw new Exception(ex.Message);
}
finally
{

conn.Close();
}
return oj;
}
}

#endregion

///// <summary>
///// 执行带一个存储过程参数的的SQL语句。
///// </summary>
///// <param name="SQLString">SQL语句</param>
///// <param name="content">参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加</param>
///// <returns>影响的记录数[返回整型值]</returns>
//public static int ExecuteNonQuery(string strSQL, string content)
//{
// SqlCommand cmd = new SqlCommand(strSQL, new SqlConnection(connectionString));
// try
// {
// if (cmd.Connection.State == ConnectionState.Closed)
// cmd.Connection.Open();
// cmd.CommandTimeout = 60;
// System.Data.SqlClient.SqlParameter myParameter = new System.Data.SqlClient.SqlParameter("@content", SqlDbType.NText);
// myParameter.Value = content;
// cmd.Parameters.Add(myParameter);

// int rows = cmd.ExecuteNonQuery();
// return rows;
// }
// catch (SqlException ex)
// {
// throw ex;
// }
// finally
// {
// cmd.Connection.Close();
// cmd.Dispose();
// //CloseConnection();
// }
//}

/// <summary>
/// 执行带一个存储过程参数的的SQL语句。
/// </summary>
/// <param name="SQLString">SQL语句</param>
/// <param name="content">参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加</param>
/// <returns>影响的记录数[返回object]</returns>
public static object ExecuteSqlGet(string strSQL, string content)
{
using (SqlCommand cmd = new SqlCommand(strSQL, new SqlConnection(connectionString)))
{
try
{
if (cmd.Connection.State == ConnectionState.Closed)
cmd.Connection.Open();

cmd.CommandTimeout = 60;
System.Data.SqlClient.SqlParameter myParameter = new System.Data.SqlClient.SqlParameter("@content", SqlDbType.NText);
myParameter.Value = content;
cmd.Parameters.Add(myParameter);

object obj = cmd.ExecuteScalar();
if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
{
return null;
}
else
{
return obj;
}
}
catch (System.Data.SqlClient.SqlException E)
{
throw new Exception(E.Message);
}
finally
{
cmd.Connection.Close();
cmd.Dispose();
//CloseConnection();
}
}
}

/// <summary>
/// 执行多条SQL语句，实现数据库事务。
/// </summary>
/// <param name="SQLStringList">多条SQL语句</param>
public static void ExecuteSqlTran(ArrayList SQLStringList)
{
SqlCommand cmd = new SqlCommand();

cmd.Connection = (new SqlConnection(connectionString));
if (cmd.Connection.State == ConnectionState.Closed)
cmd.Connection.Open();
cmd.CommandTimeout = 60;
SqlTransaction tx = cmd.Connection.BeginTransaction();
cmd.Transaction = tx;
try
{
for (int n = 0; n < SQLStringList.Count; n++)
{
string strsql = SQLStringList[n].ToString();
if (strsql.Trim().Length > 1)
{
cmd.CommandText = strsql;
cmd.ExecuteNonQuery();
}
}
tx.Commit();
}
catch (System.Data.SqlClient.SqlException E)
{
tx.Rollback();
throw new Exception(E.Message);
}
finally
{
cmd.Connection.Close();
cmd.Dispose();
//CloseConnection();
}

}

/// <summary>
/// 向数据库里插入图像格式的字段(和上面情况类似的另一种实例)
/// </summary>
/// <param name="strSQL">SQL语句</param>
/// <param name="fs">图像字节,数据库的字段类型为image的情况</param>
/// <returns>影响的记录数</returns>
public static int ExecuteSqlInsertImg(string strSQL, byte[] fs)
{
using (SqlCommand cmd = new SqlCommand(strSQL, new SqlConnection(connectionString)))
{
try
{
if (cmd.Connection.State == ConnectionState.Closed)
cmd.Connection.Open();

System.Data.SqlClient.SqlParameter myParameter = new System.Data.SqlClient.SqlParameter("@fs", SqlDbType.Image);
myParameter.Value = fs;
cmd.Parameters.Add(myParameter);
cmd.CommandTimeout = 60;
int rows = cmd.ExecuteNonQuery();
return rows;
}
catch (System.Data.SqlClient.SqlException E)
{
throw new Exception(E.Message);
}
finally
{
cmd.Connection.Close();
cmd.Dispose();
//CloseConnection();
}
}
}

#endregion

#region 执行带参数的SQL语句

/// <summary>
/// 执行SQL语句，返回影响的记录数
/// </summary>
/// <param name="SQLString">SQL语句</param>
/// <returns>影响的记录数</returns>
public static int ExecuteSql(string SQLString, params SqlParameter[] cmdParms)
{
using (SqlCommand cmd = new SqlCommand())
{
try
{
PrepareCommand(cmd, new SqlConnection(connectionString), null, SQLString, cmdParms);
if (cmd.Connection.State == ConnectionState.Closed)
cmd.Connection.Open();
int rows = cmd.ExecuteNonQuery();
cmd.Parameters.Clear();
return rows;
}
catch (System.Data.SqlClient.SqlException E)
{
throw new Exception(E.Message);
}
finally
{
cmd.Connection.Close();
cmd.Dispose();
//CloseConnection();
}
}
}

/// <summary>
/// 执行SQL语句，返回影响的记录数
/// </summary>
/// <param name="SQLString">SQL语句</param>
/// <returns>影响的记录数</returns>
public static int ExecuteSql(string SQLString, string connectionStr, params SqlParameter[] cmdParms)
{
using (SqlCommand cmd = new SqlCommand())
{
try
{
PrepareCommand(cmd, new SqlConnection(connectionStr), null, SQLString, cmdParms);
if (cmd.Connection.State == ConnectionState.Closed)
cmd.Connection.Open();
int rows = cmd.ExecuteNonQuery();
cmd.Parameters.Clear();
return rows;
}
catch (System.Data.SqlClient.SqlException E)
{
throw new Exception(E.Message);
}
finally
{
cmd.Connection.Close();
cmd.Dispose();
//CloseConnection();
}
}
}

/// <summary>
/// 执行多条SQL语句，实现数据库事务。
/// </summary>
/// <param name="SQLStringList">SQL语句的哈希表（key为sql语句，value是该语句的SqlParameter[]）</param>
public static void ExecuteSqlTran(Hashtable SQLStringList)
{
SqlConnection sqlConnection = new SqlConnection(connectionString);
if (sqlConnection.State == ConnectionState.Closed)
sqlConnection.Open();
using (SqlTransaction trans = sqlConnection.BeginTransaction())
{
SqlCommand cmd = new SqlCommand();
try
{
//循环
foreach (DictionaryEntry myDE in SQLStringList)
{
string cmdText = myDE.Key.ToString();
SqlParameter[] cmdParms = (SqlParameter[])myDE.Value;
PrepareCommand(cmd, sqlConnection, trans, cmdText, cmdParms);
int val = cmd.ExecuteNonQuery();
cmd.Parameters.Clear();

trans.Commit();
}
}
catch (SqlException ex)
{
trans.Rollback();
throw ex;
}
finally
{
cmd.Connection.Close();
cmd.Dispose();
//CloseConnection();
}
}

}

/// <summary>
/// 执行一条计算查询结果语句，返回查询结果（object）。
/// </summary>
/// <param name="SQLString">计算查询结果语句</param>
/// <returns>查询结果（object）</returns>
public static object ExecuteScalar(string SQLString, params SqlParameter[] cmdParms)
{
using (SqlCommand cmd = new SqlCommand())
{
try
{
PrepareCommand(cmd, new SqlConnection(connectionString), null, SQLString, cmdParms);
if (cmd.Connection.State == ConnectionState.Closed)
cmd.Connection.Open();
object obj = cmd.ExecuteScalar();
cmd.Parameters.Clear();
if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
{
return null;
}
else
{
return obj;
}
}
catch (System.Data.SqlClient.SqlException e)
{
throw new Exception(e.Message);
}
finally
{
cmd.Connection.Close();
cmd.Dispose();
//CloseConnection();
}
}
}

/// <summary>
/// 执行一条计算查询结果语句，返回查询结果（object）。
/// </summary>
/// <param name="SQLString">计算查询结果语句</param>
/// <returns>查询结果（object）</returns>
public static object ExecuteScalar(string SQLString, string connectionStr, params SqlParameter[] cmdParms)
{
using (SqlCommand cmd = new SqlCommand())
{
try
{
PrepareCommand(cmd, new SqlConnection(connectionStr), null, SQLString, cmdParms);
if (cmd.Connection.State == ConnectionState.Closed)
cmd.Connection.Open();
object obj = cmd.ExecuteScalar();
cmd.Parameters.Clear();
if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
{
return null;
}
else
{
return obj;
}
}
catch (System.Data.SqlClient.SqlException e)
{
throw new Exception(e.Message);
}
finally
{
cmd.Connection.Close();
cmd.Dispose();
//CloseConnection();
}
}
}

/// <summary>
/// 执行查询语句，返回SqlDataReader (使用该方法切记要手工关闭SqlDataReader和连接)
/// </summary>
/// <param name="strSQL">查询语句</param>
/// <returns>SqlDataReader</returns>
public static SqlDataReader ExecuteReader(string SQLString, params SqlParameter[] cmdParms)
{
SqlCommand cmd = new SqlCommand();
try
{
PrepareCommand(cmd, new SqlConnection(connectionString), null, SQLString, cmdParms);
if (cmd.Connection.State == ConnectionState.Closed)
cmd.Connection.Open();
SqlDataReader myReader = cmd.ExecuteReader(System.Data.CommandBehavior.CloseConnection);
cmd.Parameters.Clear();
return myReader;
}
catch (SqlException ex)
{
throw ex;
}
//finally //不能在此关闭，否则，返回的对象将无法使用
//{
// cmd.Dispose();
// connection.//CloseConnection();
//}

}

/// <summary>
/// 执行查询语句，返回SqlDataReader (使用该方法切记要手工关闭SqlDataReader和连接)
/// </summary>
/// <param name="strSQL">查询语句</param>
/// <returns>SqlDataReader</returns>
public static SqlDataReader ExecuteReader(string SQLString, string connectionStr, params SqlParameter[] cmdParms)
{
SqlCommand cmd = new SqlCommand();
try
{
PrepareCommand(cmd, new SqlConnection(connectionStr), null, SQLString, cmdParms);
if (cmd.Connection.State == ConnectionState.Closed)
cmd.Connection.Open();
SqlDataReader myReader = cmd.ExecuteReader(System.Data.CommandBehavior.CloseConnection);
cmd.Parameters.Clear();
return myReader;
}
catch (SqlException ex)
{
throw ex;
}
//finally //不能在此关闭，否则，返回的对象将无法使用
//{
// cmd.Dispose();
// connection.//CloseConnection();
//}

}

/// <summary>
/// 执行查询语句，返回DataSet
/// </summary>
/// <param name="SQLString">查询语句</param>
/// <returns>DataSet</returns>
public static DataSet Query(string SQLString, params SqlParameter[] cmdParms)
{
SqlCommand cmd = new SqlCommand();
PrepareCommand(cmd, new SqlConnection(connectionString), null, SQLString, cmdParms);
using (SqlDataAdapter sda = new SqlDataAdapter(cmd))
{
DataSet ds = new DataSet();
try
{
if (cmd.Connection.State == ConnectionState.Closed)
cmd.Connection.Open();

sda.Fill(ds, "ds");
cmd.Parameters.Clear();
}
catch (System.Data.SqlClient.SqlException ex)
{
throw new Exception(ex.Message);
}
finally
{
sda.SelectCommand.Connection.Close();
sda.SelectCommand.Dispose();
sda.SelectCommand.Connection = null;
//CloseConnection();
}
return ds;
}
}

/// <summary>
/// 执行查询语句，返回DataSet
/// </summary>
/// <param name="SQLString">查询语句</param>
/// <returns>DataSet</returns>
public static DataSet Query(string SQLString, string connectionStr, params SqlParameter[] cmdParms)
{
SqlCommand cmd = new SqlCommand();
PrepareCommand(cmd, new SqlConnection(connectionStr), null, SQLString, cmdParms);
using (SqlDataAdapter sda = new SqlDataAdapter(cmd))
{
DataSet ds = new DataSet();
try
{
if (cmd.Connection.State == ConnectionState.Closed)
cmd.Connection.Open();

sda.Fill(ds, "ds");
cmd.Parameters.Clear();
}
catch (System.Data.SqlClient.SqlException ex)
{
throw new Exception(ex.Message);
}
finally
{
sda.SelectCommand.Connection.Close();
sda.SelectCommand.Dispose();
sda.SelectCommand.Connection = null;
//CloseConnection();
}
return ds;
}
}

private static void PrepareCommand(SqlCommand cmd, SqlConnection conn, SqlTransaction trans, string cmdText, SqlParameter[] cmdParms)
{
if (conn.State != ConnectionState.Open)
conn.Open();
cmd.Connection = conn;
cmd.CommandTimeout = 300;
cmd.CommandText = cmdText;
if (trans != null)
cmd.Transaction = trans;
cmd.CommandType = CommandType.Text;//cmdType;
if (cmdParms != null)
{
foreach (SqlParameter 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 返回 DataSet 或 DataTable
/// <summary>
/// 返回DataSet数据集
/// </summary>
/// <param name="strSql">SQL语句</param>
public static DataSet GetDataSet(string strSql)
{
SqlCommand cmd = new SqlCommand(strSql, new SqlConnection(connectionString));
cmd.CommandTimeout = 300;
DataSet ds = null;
using (SqlDataAdapter da = new SqlDataAdapter(cmd))
{
try
{
if (cmd.Connection.State == ConnectionState.Closed)
cmd.Connection.Open();
ds = new DataSet();
da.Fill(ds, "ds");
cmd.Parameters.Clear();
}
catch (System.Data.SqlClient.SqlException ex)
{
throw new Exception(ex.Message);
}
finally
{
cmd.Connection.Close();
cmd.Dispose();
cmd = null;
////CloseConnection();
}
return ds;
}
}

/// <summary>
/// 添加DataSet表 返回 DataSet
/// </summary>
/// <param name="ds">DataSet对象</param>
/// <param name="strSql">Sql语句</param>
/// <param name="strTableName">表名</param>
public static DataSet GetDataSet(DataSet ds, string strSql, string strTabName)
{
#region
SqlDataAdapter sda = null;
try
{
sda = new SqlDataAdapter(strSql, new SqlConnection(connectionString)); ;
if (sda.SelectCommand.Connection.State == ConnectionState.Closed)
sda.SelectCommand.Connection.Open();
sda.Fill(ds, strTabName);
}
catch (SqlException ex)
{
throw ex;
}
finally
{
sda.SelectCommand.Connection.Close();
sda.SelectCommand.Connection.Dispose();
sda = null;
//CloseConnection();
}
return ds;
#endregion
}

/// <summary>
/// 返回DataTable对象
/// </summary>
/// <param name="strSql">SQL语句</param>
/// <returns></returns>
public static DataTable GetDataTable(string strSql)
{
SqlCommand cmd = new SqlCommand(strSql, new SqlConnection(connectionString));
cmd.CommandTimeout = 60;
DataTable dt = new DataTable();
using (SqlDataAdapter da = new SqlDataAdapter(cmd))
{
try
{
if (cmd.Connection.State == ConnectionState.Closed)
cmd.Connection.Open();
da.Fill(dt);
cmd.Parameters.Clear();
}
catch (System.Data.SqlClient.SqlException ex)
{
throw new Exception(ex.Message);
}
finally
{
cmd.Connection.Close();
cmd.Dispose();
cmd = null;
////CloseConnection();
}
return dt;
}
}
/// <summary>
/// 返回DataTable对象
/// </summary>
/// <param name="strSql">SQL语句</param>
/// <returns></returns>
public static DataTable GetDataTablea(string strSql)
{
SqlCommand cmd = new SqlCommand(strSql, new SqlConnection(AgentConnectionString));
cmd.CommandTimeout = 60;
DataTable dt = new DataTable();
using (SqlDataAdapter da = new SqlDataAdapter(cmd))
{
try
{
if (cmd.Connection.State == ConnectionState.Closed)
cmd.Connection.Open();
da.Fill(dt);
cmd.Parameters.Clear();
}
catch (System.Data.SqlClient.SqlException ex)
{
throw new Exception(ex.Message);
}
finally
{
cmd.Connection.Close();
cmd.Dispose();
cmd = null;
////CloseConnection();
}
return dt;
}
}

/// <summary>
/// 返回 int 类型的值 用于统计一张表中符合条件的记录条数
/// </summary>
/// <param name="strSql">SQL语句</param>
/// <returns></returns>
public static int GetDataTableRecordCount(string strSql)
{
int recordCount = 0;
DataTable dt = GetDataTable(strSql);
if (dt != null)
recordCount = dt.Rows.Count;
return recordCount;
}

/// <summary>
/// 返回DataView数据视图
/// </summary>
/// <param name="strSql">Sql语句</param>
public static DataView GetDataView(string strSql)
{
#region
DataView dv = GetDataSet(strSql).Tables[0].DefaultView;
return dv;
#endregion
}

/// <summary>
/// 返回SqlDataReader对象 使用完须关闭DataReader,关闭数据库连接
/// </summary>
/// <param name="strSql">sql语句</param>
/// <returns></returns>
public static SqlDataReader GetDataReader(string strSql)
{
#region
SqlCommand cmd = null;
SqlDataReader sdr = null;
try
{
cmd = new SqlCommand(strSql, new SqlConnection(connectionString));
if (cmd.Connection.State == ConnectionState.Closed)
cmd.Connection.Open();
cmd.CommandTimeout = 60;
sdr = cmd.ExecuteReader(System.Data.CommandBehavior.CloseConnection);
}
catch (SqlException ex)
{
throw ex;
}
//finally
//{
// cmd.Connection.Close();
// cmd.Dispose();
//}
return sdr;
#endregion
}

#endregion

#region 执行存储过程
/// <summary>
/// 执行存储过程
/// </summary>
/// <param name="procName">存储过程的名称</param>
/// <returns>返回存储过程返回值</returns>
public static int RunProcedure(string procName)
{
#region
int reVal = 0;
SqlCommand cmd = null;
try
{
cmd = CreateCommand(procName, null);
cmd.ExecuteNonQuery();
reVal = (int)cmd.Parameters["ReturnValue"].Value;
}
catch (SqlException ex)
{
throw ex;
}
finally
{
cmd.Connection.Close();
cmd.Dispose();
//CloseConnection();
}
return reVal;
#endregion

}

/// <summary>
/// 执行存储过程
/// </summary>
/// <param name="procName">存储过程的名称</param>
/// <returns>返回存储过程返回值</returns>
public static int RunProcedure(string procName, string connectionStr)
{
#region
int reVal = 0;
SqlCommand cmd = null;
try
{
cmd = CreateCommand(procName, connectionStr, null);
cmd.ExecuteNonQuery();
reVal = (int)cmd.Parameters["ReturnValue"].Value;
}
catch (SqlException ex)
{
throw ex;
}
finally
{
cmd.Connection.Close();
cmd.Dispose();
//CloseConnection();
}
return reVal;
#endregion

}

/// <summary>
/// 执行存储过程
/// </summary>
/// <param name="procName">存储过程的名称</param>
/// <returns>返回存储过程返回值</returns>
public static DataSet RunProcedure2(string procName)
{
DataSet dataSet = null;
SqlCommand cmd = null;
SqlDataAdapter sda = null;
try
{
cmd = new SqlCommand(procName, new SqlConnection(connectionString));
if (cmd.Connection.State == ConnectionState.Closed)
cmd.Connection.Open();
cmd.CommandTimeout = 300;
cmd.CommandType = CommandType.StoredProcedure;
sda = new SqlDataAdapter(cmd);
dataSet = new DataSet();
sda.Fill(dataSet);
}
catch (SqlException ex)
{
throw ex;
}
finally
{
sda.SelectCommand.Connection.Close();
sda.SelectCommand.Dispose();
//CloseConnection();
}
return dataSet;
}

/// <summary>
/// 执行存储过程
/// </summary>
/// <param name="procName">存储过程名称</param>
/// <param name="prams">存储过程所需参数</param>
/// <returns>返回存储过程返回值</returns>
public static int RunProcedure(string procName, SqlParameter[] prams)
{
#region
int reVal = 0;
SqlCommand cmd = null;
try
{
cmd = CreateCommand(procName, prams);
cmd.ExecuteNonQuery();
reVal = (int)cmd.Parameters["ReturnValue"].Value;
}
catch (SqlException ex)
{
throw ex;
}
finally
{
cmd.Connection.Close();
cmd.Dispose();
//CloseConnection();
}
return reVal;
#endregion
}

//2009.6.4
/// <summary>
/// 执行存储过程 返回 ExecuteNonQuery 方法 影响的行数
/// </summary>
/// <param name="procName">存储过程名称</param>
/// <param name="prams">存储过程所需参数</param>
/// <returns>返回 ExecuteNonQuery 方法 影响的行数</returns>
public static int RunProcedureReExecuteNonQueryVal(string procName, SqlParameter[] prams)
{
#region
int reVal = 0;
SqlCommand cmd = null;
try
{
cmd = CreateCommand(procName, prams);
reVal = cmd.ExecuteNonQuery();
}
catch (SqlException ex)
{
throw ex;
}
finally
{
cmd.Connection.Close();
cmd.Dispose();
//CloseConnection();
}
return reVal;
#endregion
}

/// <summary>
/// 执行存储过程
/// </summary>
/// <param name="storedProcName">存储过程名</param>
/// <param name="parameters">存储过程参数</param>
/// <returns>DataTable</returns>
public static DataTable RunProcedureReDataTable(string storedProcName, SqlParameter[] parameters)
{
DataTable dt = new DataTable();
SqlDataAdapter sqlDA = null;
try
{
sqlDA = new SqlDataAdapter();
sqlDA.SelectCommand = CreateCommand(storedProcName, parameters);
sqlDA.Fill(dt);
}
catch (SqlException ex)
{
throw ex;
}
finally
{
sqlDA.SelectCommand.Connection.Close();
sqlDA.SelectCommand.Connection.Dispose();

}
return dt;
}

/// <summary>
/// 执行存储过程
/// </summary>
/// <param name="procName">存储过程名称</param>
/// <param name="prams">存储过程所需参数</param>
/// <returns>返回存储过程返回值</returns>
public static int RunProcedure(string procName, SqlParameter[] prams, out int rowsAffected)
{
#region
int returnValue = 0;
SqlCommand cmd = null;
try
{
cmd = CreateCommand(procName, prams);
rowsAffected = cmd.ExecuteNonQuery();

returnValue = (int)cmd.Parameters["ReturnValue"].Value;
}
catch (SqlException ex)
{
throw ex;
}
finally
{
cmd.Connection.Close();
cmd.Dispose();
//CloseConnection();
}
return returnValue;
#endregion
}
//2009.3.2

/// <summary>
/// 执行存储过程
/// </summary>
/// <param name="storedProcName">存储过程名</param>
/// <param name="parameters">存储过程参数</param>
/// <param name="tableName">DataSet结果中的表名</param>
/// <returns>DataSet</returns>
public static DataSet RunProcedure(string storedProcName, SqlParameter[] parameters, string tableName)
{
DataSet dataSet = new DataSet();
SqlDataAdapter sqlDA = null;
try
{
sqlDA = new SqlDataAdapter();
sqlDA.SelectCommand = CreateCommand(storedProcName, parameters);
sqlDA.Fill(dataSet, tableName);
}
catch (SqlException ex)
{
throw ex;
}
finally
{
sqlDA.SelectCommand.Connection.Close();
sqlDA.SelectCommand.Dispose();
sqlDA = null;
//CloseConnection();
}
return dataSet;
}

/// <summary>
/// 执行存储过程
/// </summary>
/// <param name="storedProcName">存储过程名</param>
/// <param name="parameters">存储过程参数</param>
/// <param name="tableName">DataSet结果中的表名</param>
/// <returns>DataSet</returns>
public static DataSet RunProcedure(string storedProcName, SqlParameter[] parameters, string tableName, string connectionStr)
{
DataSet dataSet = new DataSet();
SqlDataAdapter sqlDA = null;
try
{
sqlDA = new SqlDataAdapter();
sqlDA.SelectCommand = CreateCommand(storedProcName,connectionStr, parameters);
sqlDA.Fill(dataSet, tableName);
}
catch (SqlException ex)
{
throw ex;
}
finally
{
sqlDA.SelectCommand.Connection.Close();
sqlDA.SelectCommand.Dispose();
sqlDA = null;
//CloseConnection();
}
return dataSet;
}

/// <summary>
/// 执行存储过程返回DataReader对象
/// </summary>
/// <param name="procName">Sql语句</param>
/// <param name="dataReader">DataReader对象</param>
public static void RunProcedure(string procName, SqlDataReader dataReader)
{
#region
SqlCommand cmd = null;
try
{
cmd = CreateCommand(procName, null);
dataReader = cmd.ExecuteReader(System.Data.CommandBehavior.CloseConnection);
}
catch (SqlException ex)
{
throw ex;
}
//finally
//{
// cmd.Connection.Close();
// cmd.Dispose();
// //CloseConnection();
//}
#endregion
}

/// <summary>
/// 执行存储过程
/// </summary>
/// <param name="procName">存储过程的名称</param>
/// <param name="prams">存储过程所需参数</param>
/// <param name="dataReader">DataReader对象</param>
public static void RunProcedure(string procName, SqlParameter[] prams, SqlDataReader dataReader)
{
#region
SqlCommand cmd = null;
try
{
cmd = CreateCommand(procName, prams);
dataReader = cmd.ExecuteReader(System.Data.CommandBehavior.CloseConnection);
}
catch (SqlException ex)
{
throw ex;
}
finally
{
cmd.Connection.Close();
cmd.Dispose();
//CloseConnection();
}
#endregion
}

/// <summary>
/// 创建一个SqlCommand对象以此来执行存储过程
/// </summary>
/// <param name="procName">存储过程的名称</param>
/// <param name="prams">存储过程所需参数</param>
/// <returns>返回SqlCommand对象</returns>
private static SqlCommand CreateCommand(string procName, SqlParameter[] prams)
{
#region
// 确认打开连接
SqlCommand cmd = null;
try
{
cmd = new SqlCommand(procName, new SqlConnection(connectionString));
if (cmd.Connection.State == ConnectionState.Closed)
cmd.Connection.Open();
cmd.CommandTimeout = 300;
cmd.CommandType = CommandType.StoredProcedure;

// 依次把参数传入存储过程
if (prams != null)
{
foreach (SqlParameter parameter in prams)
cmd.Parameters.Add(parameter);
}

// 加入返回参数
cmd.Parameters.Add(
new SqlParameter("ReturnValue", SqlDbType.Int, 4,
ParameterDirection.ReturnValue, false, 0, 0,
string.Empty, DataRowVersion.Default, null));
}
catch (SqlException sqlex)
{
throw sqlex;
}

return cmd;
#endregion
}

/// <summary>
/// 创建一个SqlCommand对象以此来执行存储过程
/// </summary>
/// <param name="procName">存储过程的名称</param>
/// <param name="prams">存储过程所需参数</param>
/// <returns>返回SqlCommand对象</returns>
private static SqlCommand CreateCommand(string procName, string connectionStr, SqlParameter[] prams)
{
#region
// 确认打开连接
SqlCommand cmd = null;
try
{
cmd = new SqlCommand(procName, new SqlConnection(connectionStr));
if (cmd.Connection.State == ConnectionState.Closed)
cmd.Connection.Open();
cmd.CommandTimeout = 300;
cmd.CommandType = CommandType.StoredProcedure;

// 依次把参数传入存储过程
if (prams != null)
{
foreach (SqlParameter parameter in prams)
cmd.Parameters.Add(parameter);
}

// 加入返回参数
cmd.Parameters.Add(
new SqlParameter("ReturnValue", SqlDbType.Int, 4,
ParameterDirection.ReturnValue, false, 0, 0,
string.Empty, DataRowVersion.Default, null));
}
catch (SqlException sqlex)
{
throw sqlex;
}

return cmd;
#endregion
}

/// <summary>
/// 生成存储过程参数
/// </summary>
/// <param name="ParamName">存储过程名称</param>
/// <param name="DbType">参数类型</param>
/// <param name="Size">参数大小</param>
/// <param name="Direction">参数方向</param>
/// <param name="Value">参数值</param>
/// <returns>新的 parameter 对象</returns>
public static SqlParameter MakeParam(string ParamName, SqlDbType DbType, Int32 Size, ParameterDirection Direction, object Value)
{
#region
SqlParameter param = null; ;
try
{
if (Size > 0)
param = new SqlParameter(ParamName, DbType, Size);
else
param = new SqlParameter(ParamName, DbType);

param.Direction = Direction;
if (!(Direction == ParameterDirection.Output && Value == null))
param.Value = Value;
}
catch (SqlException ex)
{
throw ex;
}

return param;
#endregion
}

/// <summary>
/// 传入输入参数
/// </summary>
/// <param name="ParamName">存储过程名称</param>
/// <param name="DbType">参数类型</param></param>
/// <param name="Size">参数大小</param>
/// <param name="Value">参数值</param>
/// <returns>新的 parameter 对象</returns>
public static SqlParameter MakeInParam(string ParamName, SqlDbType DbType, int Size, object Value)
{
#region
return MakeParam(ParamName, DbType, Size, ParameterDirection.Input, Value);

#endregion
}

/// <summary>
/// 传入返回值参数
/// </summary>
/// <param name="ParamName">存储过程名称</param>
/// <param name="DbType">参数类型</param>
/// <param name="Size">参数大小</param>
/// <returns>新的 parameter 对象</returns>
public static SqlParameter MakeOutParam(string ParamName, SqlDbType DbType, int Size)
{
#region
return MakeParam(ParamName, DbType, Size, ParameterDirection.Output, null);
#endregion
}
#endregion

#region 读取Excel
/// <summary>
/// 读取Excel
/// </summary>
/// <param name="Path"></param>
/// <param name="tableName"></param>
/// <returns></returns>
public static DataSet ExcelToDS(string Path, string tableName)
{
string strConn = "Provider=Microsoft.Jet.OLEDB.4.0;" + "Data Source=" + Path + ";" + "Extended Properties=Excel 8.0;"; //HDR=Yes;
DataSet ds = null;
using (OleDbConnection conn = new OleDbConnection(strConn))
{
OleDbDataAdapter myCommand = null;
try
{
conn.Open();
string strExcel = "";
strExcel = "select * from [" + tableName + "$]";
myCommand = new OleDbDataAdapter(strExcel, strConn);
ds = new DataSet();
myCommand.Fill(ds, "table1");
}
catch (SqlException ex)
{
throw ex;
}
finally
{
myCommand.Dispose();
conn.Close();
}
return ds;
}
}

/// <summary>
/// 将 Excel 文件转成 DataTable
/// </summary>
/// <param name="strExcelFileName">Excel文件及其路径</param>
/// <param name="strSheetName">工作表名,如:Sheet1</param>
/// <param name="isTitleOrDataOfFirstRow">True 第一行是标题,False 第一行是数据</param>
/// <returns>DataTable</returns>
public static DataTable ExcelToDataTable(string strExcelFileName, string strSheetName, bool isTitleOrDataOfFirstRow)
{

string HDR = string.Empty;//如果第一行是数据而不是标题的话, 应该写: "HDR=No;"
if (isTitleOrDataOfFirstRow)
{
HDR = "YES";//第一行是标题
}
else
{
HDR = "NO";//第一行是数据
}
//源的定义
string strConn = "Provider=Microsoft.Jet.OLEDB.4.0;" + "Data Source=" + strExcelFileName + ";" + "Extended Properties='Excel 8.0;HDR=" + HDR + ";IMEX=1';";

//Sql语句
//string strExcel = string.Format("select * from [{0}$]", strSheetName); 这是一种方法
string strExcel = "select * from [" + strSheetName + "$]";
//定义存放的数据表
DataSet ds = new DataSet();

//连接数据源
using (OleDbConnection conn = new OleDbConnection(strConn))
{
OleDbDataAdapter adapter = null;
try
{
conn.Open();
//适配到数据源
adapter = new OleDbDataAdapter(strExcel, strConn);
adapter.Fill(ds, strSheetName);
}
catch (System.Data.SqlClient.SqlException ex)
{
throw ex;
}
finally
{
adapter.SelectCommand.Connection.Close();
adapter.SelectCommand.Dispose();
}
}
return ds.Tables[strSheetName];
}

#endregion

#region SQL 分页语句 及 cs 文件方法
/*
set ANSI_NULLS ON
set QUOTED_IDENTIFIER ON
go

CREATE Procedure [dbo].[Pager2005]
@TableName varchar(50), --表名
@Fields varchar(5000) = '*', --字段名(全部字段为*)
@OrderField varchar(5000), --排序字段(必须!支持多字段)
@sqlWhere varchar(5000) = Null,--条件语句(不用加where)
@pageSize int, --每页多少条记录
@pageIndex int = 1 , --指定当前为第几页
@isCount bit,
@TotalPage int output, --返回总页数
@totalRecord int output
as
begin

Begin Tran --开始事务

Declare @sql nvarchar(4000);
--Declare @totalRecord int output;

if(@isCount =1)
begin
--计算总记录数

if (@SqlWhere='' or @sqlWhere=NULL)
set @sql = 'select @totalRecord = count(*) from ' + @TableName
else
set @sql = 'select @totalRecord = count(*) from ' + @TableName + ' where ' + @sqlWhere

EXEC sp_executesql @sql,N'@totalRecord int OUTPUT',@totalRecord OUTPUT--计算总记录数

--计算总页数
select @TotalPage=CEILING((@totalRecord+0.0)/@PageSize)
end

if (@SqlWhere='' or @sqlWhere=NULL)
set @sql = 'Select * FROM (select ROW_NUMBER() Over(order by ' + @OrderField + ') as rowId,' + @Fields + ' from ' + @TableName
else
set @sql = 'Select * FROM (select ROW_NUMBER() Over(order by ' + @OrderField + ') as rowId,' + @Fields + ' from ' + @TableName + ' where ' + @SqlWhere


--处理页数超出范围情况
if @PageIndex<=0
Set @pageIndex = 1

if @pageIndex>@TotalPage
Set @pageIndex = @TotalPage

--处理开始点和结束点
Declare @StartRecord int
Declare @EndRecord int

set @StartRecord = (@pageIndex-1)*@PageSize + 1
set @EndRecord = @StartRecord + @pageSize - 1

--继续合成sql语句
set @Sql = @Sql + ') as ' + @TableName + ' where rowId between ' + Convert(varchar(50),@StartRecord) + ' and ' + Convert(varchar(50),@EndRecord)

Exec(@Sql)
---------------------------------------------------
If @@Error <> 0
Begin
RollBack Tran
Return -1
End
Else
Begin
Commit Tran
Return @totalRecord ---返回记录总数
End
end
*
/// <summary>
///分页获取数据列表
/// </summary>
/// <returns></returns>
public static DataSet GetList(int pageSize, int pageIndex,string tablename,string fieldname, string where, string order, bool isCount, out int totalRecord)
{
totalRecord = 0;
SqlParameter totalPageParm = new SqlParameter("@TotalPage", SqlDbType.Int);
totalPageParm.Direction = ParameterDirection.Output;
SqlParameter totalRecordParm = new SqlParameter("@totalRecord", SqlDbType.Int);
totalRecordParm.Direction = ParameterDirection.Output;

SqlParameter[] parameters = {
new SqlParameter("@TableName", SqlDbType.VarChar, 50),
new SqlParameter("@Fields", SqlDbType.VarChar, 5000),
new SqlParameter("@OrderField", SqlDbType.VarChar, 5000),
new SqlParameter("@sqlWhere", SqlDbType.VarChar, 5000),
new SqlParameter("@pageSize", SqlDbType.Int),
new SqlParameter("@pageIndex", SqlDbType.Int),
new SqlParameter("@isCount", SqlDbType.Bit),
totalPageParm,totalRecordParm
};
parameters[0].Value = tablename; //表、视图名称
parameters[1].Value = fieldname; //选择字段，全选用*
parameters[2].Value = order;
parameters[3].Value = where;
parameters[4].Value = pageSize;
parameters[5].Value = pageIndex;
parameters[6].Value = isCount;
CMS.DBUtility.SQL.DBHelpSP sqp = new CMS.DBUtility.SQL.DBHelpSP();
DataSet ds = sqp.ReturnDataSet(CMS.DBUtility.SQL.Configuration.ConnAdmin, "Page2005", parameters);
if (isCount)
{
int.TryParse(totalRecordParm.Value.ToString(), out totalRecord);
}
return ds;
}
*/
#endregion
}
}