1225 lines
55 KiB
C#
1225 lines
55 KiB
C#
/**
|
|
*
|
|
* SQLSERVER辅助类,封装对SQLSERVER的各种操作.
|
|
*
|
|
* Author FeiLong Wang (hustemb@gmail.com)
|
|
* Copyright (c) 2006. All Rights Reserved.
|
|
* LastModifiedDate:2008-1-26
|
|
*
|
|
*
|
|
*/
|
|
using System;
|
|
using System.Configuration;
|
|
using System.Data;
|
|
using System.Data.SqlClient;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
|
|
namespace WMS.DBUtility
|
|
{
|
|
public class SqlServerHelper : IDisposable
|
|
{
|
|
#region Varibales
|
|
// 适配器
|
|
|
|
// 数据库连接字符串
|
|
private static readonly string m_connectionString = ConfigurationManager.ConnectionStrings["wmsConnString"].ConnectionString;
|
|
/// Parameters缓存哈希表
|
|
|
|
|
|
public static string ConnectionString
|
|
{
|
|
get { return SqlServerHelper.m_connectionString; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Contructors
|
|
/// <summary>
|
|
/// 释放对象资源
|
|
/// </summary>
|
|
public void Dispose()
|
|
{
|
|
|
|
GC.SuppressFinalize(true);
|
|
}
|
|
|
|
|
|
|
|
#endregion
|
|
|
|
#region ExecuteNonQuery
|
|
/// <summary>
|
|
/// 直接执行SQL语句
|
|
/// 示例:
|
|
/// int result = ExecuteNonQuery("SELECT * FROM [table123]");
|
|
/// </summary>
|
|
/// <param name="commandText">SQL语句</param>
|
|
/// <returns>返回命令影响的行数</returns>
|
|
public static int ExecuteNonQuery(string commandText)
|
|
{
|
|
return ExecuteNonQuery(CommandType.Text, commandText);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 执行指定连接字符串,类型的SqlCommand.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// 示例:
|
|
/// int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders");
|
|
/// </remarks>
|
|
/// <param name="ConnectionString">一个有效的数据库连接字符串</param>
|
|
/// <param name="commandType">命令类型 (存储过程,命令文本, 其它.)</param>
|
|
/// <param name="commandText">存储过程名称或SQL语句</param>
|
|
/// <returns>返回命令影响的行数</returns>
|
|
public static int ExecuteNonQuery(CommandType commandType, string commandText)
|
|
{
|
|
return ExecuteNonQuery(commandType, commandText, (SqlParameter[])null);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 执行指定连接字符串,类型的SqlCommand.如果没有提供参数,不返回结果.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// 示例:
|
|
/// int result = ExecuteNonQuery(CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
|
|
/// </remarks>
|
|
/// <param name="ConnectionString">一个有效的数据库连接字符串</param>
|
|
/// <param name="commandType">命令类型 (存储过程,命令文本, 其它.)</param>
|
|
/// <param name="commandText">存储过程名称或SQL语句</param>
|
|
/// <param name="commandParameters">SqlParameter参数数组</param>
|
|
/// <returns>返回命令影响的行数</returns>
|
|
public static int ExecuteNonQuery(CommandType commandType, string commandText, params SqlParameter[] commandParameters)
|
|
{
|
|
if (m_connectionString == null || m_connectionString.Length == 0) throw new ArgumentNullException("ConnectionString");
|
|
|
|
using (SqlConnection connection = new SqlConnection(m_connectionString))
|
|
{
|
|
connection.ConnectionString = m_connectionString;
|
|
connection.Open();
|
|
|
|
return ExecuteNonQuery(connection, commandType, commandText, commandParameters);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 执行指定数据库连接对象的命令
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// 示例:
|
|
/// int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders");
|
|
/// </remarks>
|
|
/// <param name="connection">一个有效的数据库连接对象</param>
|
|
/// <param name="commandType">命令类型(存储过程,命令文本或其它.)</param>
|
|
/// <param name="commandText">存储过程名称或SQL语句</param>
|
|
/// <returns>返回影响的行数</returns>
|
|
public static int ExecuteNonQuery(SqlConnection connection, CommandType commandType, string commandText)
|
|
{
|
|
return ExecuteNonQuery(connection, commandType, commandText, (SqlParameter[])null);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 执行带事务的SqlCommand.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// 示例.:
|
|
/// int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "PublishOrders");
|
|
/// </remarks>
|
|
/// <param name="transaction">一个有效的数据库连接对象</param>
|
|
/// <param name="commandType">命令类型(存储过程,命令文本或其它.)</param>
|
|
/// <param name="commandText">存储过程名称或SQL语句</param>
|
|
/// <returns>返回影响的行数/returns>
|
|
public static int ExecuteNonQuery(SqlTransaction transaction, CommandType commandType, string commandText)
|
|
{
|
|
return ExecuteNonQuery(transaction, commandType, commandText, (SqlParameter[])null);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 执行指定数据库连接对象的命令
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// 示例:
|
|
/// int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
|
|
/// </remarks>
|
|
/// <param name="connection">一个有效的数据库连接对象</param>
|
|
/// <param name="commandType">命令类型(存储过程,命令文本或其它.)</param>
|
|
/// <param name="commandText">T存储过程名称或SQL语句</param>
|
|
/// <param name="commandParameters">SqlParamter参数数组</param>
|
|
/// <returns>返回影响的行数</returns>
|
|
public static int ExecuteNonQuery(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
|
|
{
|
|
if (connection == null) throw new ArgumentNullException("connection");
|
|
|
|
// 创建SqlCommand命令,并进行预处理
|
|
SqlCommand cmd = new SqlCommand();
|
|
bool mustCloseConnection = false;
|
|
PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters, out mustCloseConnection);
|
|
|
|
// Finally, execute the command
|
|
int retval = cmd.ExecuteNonQuery();
|
|
|
|
// 清除参数,以便再次使用.
|
|
cmd.Parameters.Clear();
|
|
if (mustCloseConnection)
|
|
connection.Close();
|
|
return retval;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 执行带事务的SqlCommand(指定参数).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// 示例:
|
|
/// int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
|
|
/// </remarks>
|
|
/// <param name="transaction">一个有效的数据库连接对象</param>
|
|
/// <param name="commandType">命令类型(存储过程,命令文本或其它.)</param>
|
|
/// <param name="commandText">存储过程名称或SQL语句</param>
|
|
/// <param name="commandParameters">SqlParamter参数数组</param>
|
|
/// <returns>返回影响的行数</returns>
|
|
public static int ExecuteNonQuery(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
|
|
{
|
|
if (transaction == null) throw new ArgumentNullException("transaction");
|
|
if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
|
|
|
|
// 预处理
|
|
SqlCommand cmd = new SqlCommand();
|
|
bool mustCloseConnection = false;
|
|
PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);
|
|
|
|
// 执行
|
|
int retval = cmd.ExecuteNonQuery();
|
|
|
|
// 清除参数集,以便再次使用.
|
|
cmd.Parameters.Clear();
|
|
return retval;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ExecuteDataTable
|
|
/// <summary>
|
|
/// 执行指定数据库连接字符串的命令,返回DataTable.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// 示例:
|
|
/// DataTable dt = ExecuteDataTable("SELECT * FROM [table1]");
|
|
/// </remarks>
|
|
/// <param name="commandText">SQL语句</param>
|
|
/// <returns>返回一个包含结果集的DataTable</returns>
|
|
public static DataTable ExecuteDataTable(string commandText)
|
|
{
|
|
return ExecuteDataTable(CommandType.Text, commandText, (SqlParameter[])null);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 执行指定数据库连接字符串的命令,返回DataTable.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// 示例:
|
|
/// DataTable dt = ExecuteDataTable(connString, CommandType.StoredProcedure, "GetOrders");
|
|
/// </remarks>
|
|
/// <param name="ConnectionString">一个有效的数据库连接字符串</param>
|
|
/// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param>
|
|
/// <param name="commandText">存储过程名称或SQL语句</param>
|
|
/// <returns>返回一个包含结果集的DataTable</returns>
|
|
public static DataTable ExecuteDataTable(CommandType commandType, string commandText)
|
|
{
|
|
return ExecuteDataTable(commandType, commandText, (SqlParameter[])null);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 执行指定数据库连接字符串的命令,返回DataTable.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// 示例:
|
|
/// DataTable dt = ExecuteDataTable(connString, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
|
|
/// </remarks>
|
|
/// <param name="ConnectionString">一个有效的数据库连接字符串</param>
|
|
/// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param>
|
|
/// <param name="commandText">存储过程名称或SQL语句</param>
|
|
/// <param name="commandParameters">SqlParamters参数数组</param>
|
|
/// <returns>返回一个包含结果集的DataTable</returns>
|
|
public static DataTable ExecuteDataTable(CommandType commandType, string commandText, params SqlParameter[] commandParameters)
|
|
{
|
|
if (m_connectionString == null || m_connectionString.Length == 0) throw new ArgumentNullException("ConnectionString");
|
|
// 创建并打开数据库连接对象,操作完成释放对象.
|
|
using (SqlConnection connection = new SqlConnection(m_connectionString))
|
|
{
|
|
connection.ConnectionString = m_connectionString;
|
|
connection.Open();
|
|
// 调用指定数据库连接字符串重载方法.
|
|
return ExecuteDataTable(connection, commandType, commandText, commandParameters);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 执行指定数据库连接对象的命令,返回DataTable.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// 示例:
|
|
/// DataTable dt = ExecuteDataTable(conn, CommandType.StoredProcedure, "GetOrders");
|
|
/// </remarks>
|
|
/// <param name="connection">一个有效的数据库连接对象</param>
|
|
/// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param>
|
|
/// <param name="commandText">存储过程名或SQL语句</param>
|
|
/// <returns>返回一个包含结果集的DataTable</returns>
|
|
public static DataTable ExecuteDataTable(SqlConnection connection, CommandType commandType, string commandText)
|
|
{
|
|
return ExecuteDataTable(connection, commandType, commandText, (SqlParameter[])null);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 执行指定数据库连接对象的命令,指定存储过程参数,返回DataTable.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// 示例:
|
|
/// DataTable dt = ExecuteDataTable(conn, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
|
|
/// </remarks>
|
|
/// <param name="connection">一个有效的数据库连接对象</param>
|
|
/// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param>
|
|
/// <param name="commandText">存储过程名或SQL语句</param>
|
|
/// <param name="commandParameters">SqlParamter参数数组</param>
|
|
/// <returns>返回一个包含结果集的DataTable</returns>
|
|
public static DataTable ExecuteDataTable(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
|
|
{
|
|
if (connection == null) throw new ArgumentNullException("connection");
|
|
// 预处理
|
|
SqlCommand cmd = new SqlCommand();
|
|
bool mustCloseConnection = false;
|
|
PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters, out mustCloseConnection);
|
|
// 创建SqlDataAdapter和DataTable.
|
|
using (SqlDataAdapter da = new SqlDataAdapter())
|
|
{
|
|
da.SelectCommand = cmd;
|
|
DataTable tab = new DataTable();
|
|
try
|
|
{
|
|
// 填充DataTable.
|
|
da.Fill(tab);
|
|
cmd.Parameters.Clear();
|
|
if (mustCloseConnection)
|
|
connection.Close();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
|
|
string errMsg = ex.Message;
|
|
}
|
|
|
|
return tab;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 执行指定事务的命令,返回DataTable.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// 示例:
|
|
/// DataTable dt = ExecuteDataTable(trans, CommandType.StoredProcedure, "GetOrders");
|
|
/// </remarks>
|
|
/// <param name="transaction">事务</param>
|
|
/// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param>
|
|
/// <param name="commandText">存储过程名或SQL语句</param>
|
|
/// <returns>返回一个包含结果集的DataTable</returns>
|
|
public static DataTable ExecuteDataTable(SqlTransaction transaction, CommandType commandType, string commandText)
|
|
{
|
|
return ExecuteDataTable(transaction, commandType, commandText, (SqlParameter[])null);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 执行指定事务的命令,指定参数,返回DataTable.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// 示例:
|
|
/// DataTable dt = ExecuteDataTable(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
|
|
/// </remarks>
|
|
/// <param name="transaction">事务</param>
|
|
/// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param>
|
|
/// <param name="commandText">存储过程名或SQL语句</param>
|
|
/// <param name="commandParameters">SqlParamter参数数组</param>
|
|
/// <returns>返回一个包含结果集的DataTable</returns>
|
|
public static DataTable ExecuteDataTable(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
|
|
{
|
|
if (transaction == null) throw new ArgumentNullException("transaction");
|
|
if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
|
|
// 预处理
|
|
SqlCommand cmd = new SqlCommand();
|
|
bool mustCloseConnection = false;
|
|
PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);
|
|
// 创建 DataAdapter & DataTable
|
|
using (SqlDataAdapter da = new SqlDataAdapter())
|
|
{
|
|
da.SelectCommand = cmd;
|
|
DataTable dt = new DataTable();
|
|
da.Fill(dt);
|
|
cmd.Parameters.Clear();
|
|
return dt;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region ExecuteDataSet
|
|
/// <summary>
|
|
/// 执行指定数据库连接字符串的命令,返回DataSet.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// 示例:
|
|
/// DataSet ds = ExecuteDataSet("SELECT * FROM [table1]");
|
|
/// </remarks>
|
|
/// <param name="commandText">SQL语句</param>
|
|
/// <returns>返回一个包含结果集的DataSet</returns>
|
|
public static DataSet ExecuteDataSet(string commandText)
|
|
{
|
|
return ExecuteDataSet(CommandType.Text, commandText, (SqlParameter[])null);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 执行指定数据库连接字符串的命令,返回DataSet.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// 示例:
|
|
/// DataSet ds = ExecuteDataSet(connString, CommandType.StoredProcedure, "GetOrders");
|
|
/// </remarks>
|
|
/// <param name="ConnectionString">一个有效的数据库连接字符串</param>
|
|
/// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param>
|
|
/// <param name="commandText">存储过程名称或SQL语句</param>
|
|
/// <returns>返回一个包含结果集的DataSet</returns>
|
|
public static DataSet ExecuteDataSet(CommandType commandType, string commandText)
|
|
{
|
|
return ExecuteDataSet(commandType, commandText, (SqlParameter[])null);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 执行指定数据库连接字符串的命令,返回DataSet.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// 示例:
|
|
/// DataSet ds = ExecuteDataSet(connString, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
|
|
/// </remarks>
|
|
/// <param name="ConnectionString">一个有效的数据库连接字符串</param>
|
|
/// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param>
|
|
/// <param name="commandText">存储过程名称或SQL语句</param>
|
|
/// <param name="commandParameters">SqlParamters参数数组</param>
|
|
/// <returns>返回一个包含结果集的DataSet</returns>
|
|
public static DataSet ExecuteDataSet(CommandType commandType, string commandText, params SqlParameter[] commandParameters)
|
|
{
|
|
if (m_connectionString == null || m_connectionString.Length == 0) throw new ArgumentNullException("ConnectionString");
|
|
|
|
// 创建并打开数据库连接对象,操作完成释放对象.
|
|
using (SqlConnection connection = new SqlConnection(m_connectionString))
|
|
{
|
|
connection.ConnectionString = m_connectionString;
|
|
connection.Open();
|
|
|
|
// 调用指定数据库连接字符串重载方法.
|
|
return ExecuteDataSet(connection, commandType, commandText, commandParameters);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 执行指定数据库连接对象的命令,返回DataSet.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// 示例:
|
|
/// DataSet ds = ExecuteDataSet(conn, CommandType.StoredProcedure, "GetOrders");
|
|
/// </remarks>
|
|
/// <param name="connection">一个有效的数据库连接对象</param>
|
|
/// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param>
|
|
/// <param name="commandText">存储过程名或SQL语句</param>
|
|
/// <returns>返回一个包含结果集的DataSet</returns>
|
|
public static DataSet ExecuteDataSet(SqlConnection connection, CommandType commandType, string commandText)
|
|
{
|
|
return ExecuteDataSet(connection, commandType, commandText, (SqlParameter[])null);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 执行指定数据库连接对象的命令,指定存储过程参数,返回DataSet.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// 示例:
|
|
/// DataSet ds = ExecuteDataSet(conn, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
|
|
/// </remarks>
|
|
/// <param name="connection">一个有效的数据库连接对象</param>
|
|
/// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param>
|
|
/// <param name="commandText">存储过程名或SQL语句</param>
|
|
/// <param name="commandParameters">SqlParamter参数数组</param>
|
|
/// <returns>返回一个包含结果集的DataSet</returns>
|
|
public static DataSet ExecuteDataSet(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
|
|
{
|
|
try
|
|
{
|
|
if (connection == null) throw new ArgumentNullException("connection");
|
|
// 预处理
|
|
SqlCommand cmd = new SqlCommand();
|
|
bool mustCloseConnection = false;
|
|
PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters, out mustCloseConnection);
|
|
// 创建SqlDataAdapter和DataSet.
|
|
using (SqlDataAdapter da = new SqlDataAdapter())
|
|
{
|
|
da.SelectCommand = cmd;
|
|
DataSet ds = new DataSet();
|
|
// 填充DataSet.
|
|
da.Fill(ds);
|
|
cmd.Parameters.Clear();
|
|
if (mustCloseConnection)
|
|
connection.Close();
|
|
return ds;
|
|
}
|
|
}
|
|
catch (Exception exp)
|
|
{
|
|
throw exp;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 执行指定事务的命令,返回DataSet.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// 示例:
|
|
/// DataSet ds = ExecuteDataSet(trans, CommandType.StoredProcedure, "GetOrders");
|
|
/// </remarks>
|
|
/// <param name="transaction">事务</param>
|
|
/// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param>
|
|
/// <param name="commandText">存储过程名或SQL语句</param>
|
|
/// <returns>返回一个包含结果集的DataSet</returns>
|
|
public static DataSet ExecuteDataSet(SqlTransaction transaction, CommandType commandType, string commandText)
|
|
{
|
|
return ExecuteDataSet(transaction, commandType, commandText, (SqlParameter[])null);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 执行指定事务的命令,指定参数,返回DataSet.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// 示例:
|
|
/// DataSet ds = ExecuteDataSet(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
|
|
/// </remarks>
|
|
/// <param name="transaction">事务</param>
|
|
/// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param>
|
|
/// <param name="commandText">存储过程名或SQL语句</param>
|
|
/// <param name="commandParameters">SqlParamter参数数组</param>
|
|
/// <returns>返回一个包含结果集的DataSet</returns>
|
|
public static DataSet ExecuteDataSet(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
|
|
{
|
|
if (transaction == null) throw new ArgumentNullException("transaction");
|
|
if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
|
|
// 预处理
|
|
|
|
|
|
|
|
SqlCommand cmd = new SqlCommand();
|
|
bool mustCloseConnection = false;
|
|
PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);
|
|
|
|
// 创建 DataAdapter & DataSet
|
|
using (SqlDataAdapter da = new SqlDataAdapter())
|
|
{
|
|
da.SelectCommand = cmd;
|
|
DataSet ds = new DataSet();
|
|
da.Fill(ds);
|
|
cmd.Parameters.Clear();
|
|
return ds;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region ExecuteScalar
|
|
/// <summary>
|
|
/// 执行指定数据库连接字符串的命令,返回结果集中的第一行第一列.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// 示例:
|
|
/// int orderCount = (int)ExecuteScalar("SELECT MAX(PK_ID) FROM [table123]");
|
|
/// </remarks>
|
|
/// <param name="commandText">SQL语句</param>
|
|
/// <returns>返回结果集中的第一行第一列</returns>
|
|
public static object ExecuteScalar(string commandText)
|
|
{
|
|
// 执行参数为空的方法
|
|
|
|
|
|
|
|
return ExecuteScalar(CommandType.Text, commandText);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 执行指定数据库连接字符串的命令,返回结果集中的第一行第一列.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// 示例:
|
|
/// int orderCount = (int)ExecuteScalar(connString, CommandType.StoredProcedure, "GetOrderCount");
|
|
/// </remarks>
|
|
/// <param name="ConnectionString">一个有效的数据库连接字符串</param>
|
|
/// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param>
|
|
/// <param name="commandText">存储过程名称或SQL语句</param>
|
|
/// <returns>返回结果集中的第一行第一列</returns>
|
|
public static object ExecuteScalar(CommandType commandType, string commandText)
|
|
{
|
|
// 执行参数为空的方法
|
|
|
|
|
|
|
|
return ExecuteScalar(commandType, commandText, (SqlParameter[])null);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 执行指定数据库连接字符串的命令,指定参数,返回结果集中的第一行第一列.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// 示例:
|
|
/// int orderCount = (int)ExecuteScalar(connString, CommandType.StoredProcedure, "GetOrderCount", new SqlParameter("@prodid", 24));
|
|
/// </remarks>
|
|
/// <param name="ConnectionString">一个有效的数据库连接字符串</param>
|
|
/// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param>
|
|
/// <param name="commandText">存储过程名称或SQL语句</param>
|
|
/// <param name="commandParameters">分配给命令的SqlParamter参数数组</param>
|
|
/// <returns>返回结果集中的第一行第一列</returns>
|
|
public static object ExecuteScalar(CommandType commandType, string commandText, params SqlParameter[] commandParameters)
|
|
{
|
|
if (ConnectionString == null || ConnectionString.Length == 0) throw new ArgumentNullException("ConnectionString");
|
|
// 创建并打开数据库连接对象,操作完成释放对象.
|
|
using (SqlConnection connection = new SqlConnection(m_connectionString))
|
|
{
|
|
connection.ConnectionString = ConnectionString;
|
|
connection.Open();
|
|
|
|
// 调用指定数据库连接字符串重载方法.
|
|
return ExecuteScalar(connection, commandType, commandText, commandParameters);
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 执行指定数据库连接对象的命令,返回结果集中的第一行第一列.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// 示例:
|
|
/// int orderCount = (int)ExecuteScalar(conn, CommandType.StoredProcedure, "GetOrderCount");
|
|
/// </remarks>
|
|
/// <param name="connection">一个有效的数据库连接对象</param>
|
|
/// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param>
|
|
/// <param name="commandText">存储过程名称或SQL语句</param>
|
|
/// <returns>返回结果集中的第一行第一列</returns>
|
|
public static object ExecuteScalar(SqlConnection connection, CommandType commandType, string commandText)
|
|
{
|
|
// 执行参数为空的方法
|
|
|
|
|
|
|
|
return ExecuteScalar(connection, commandType, commandText, (SqlParameter[])null);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 执行指定数据库连接对象的命令,指定参数,返回结果集中的第一行第一列.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// 示例:
|
|
/// int orderCount = (int)ExecuteScalar(conn, CommandType.StoredProcedure, "GetOrderCount", new SqlParameter("@prodid", 24));
|
|
/// </remarks>
|
|
/// <param name="connection">一个有效的数据库连接对象</param>
|
|
/// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param>
|
|
/// <param name="commandText">存储过程名称或SQL语句</param>
|
|
/// <param name="commandParameters">分配给命令的SqlParamter参数数组</param>
|
|
/// <returns>返回结果集中的第一行第一列</returns>
|
|
public static object ExecuteScalar(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
|
|
{
|
|
if (connection == null) throw new ArgumentNullException("connection");
|
|
|
|
// 创建SqlCommand命令,并进行预处理
|
|
SqlCommand cmd = new SqlCommand();
|
|
|
|
bool mustCloseConnection = false;
|
|
PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters, out mustCloseConnection);
|
|
|
|
// 执行SqlCommand命令,并返回结果.
|
|
object retval = cmd.ExecuteScalar();
|
|
|
|
// 清除参数,以便再次使用.
|
|
cmd.Parameters.Clear();
|
|
|
|
if (mustCloseConnection)
|
|
connection.Close();
|
|
|
|
return retval;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 执行指定数据库事务的命令,返回结果集中的第一行第一列.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// 示例:
|
|
/// int orderCount = (int)ExecuteScalar(trans, CommandType.StoredProcedure, "GetOrderCount");
|
|
/// </remarks>
|
|
/// <param name="transaction">一个有效的连接事务</param>
|
|
/// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param>
|
|
/// <param name="commandText">存储过程名称或SQL语句</param>
|
|
/// <returns>返回结果集中的第一行第一列</returns>
|
|
public static object ExecuteScalar(SqlTransaction transaction, CommandType commandType, string commandText)
|
|
{
|
|
// 执行参数为空的方法
|
|
|
|
|
|
|
|
return ExecuteScalar(transaction, commandType, commandText, (SqlParameter[])null);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 执行指定数据库事务的命令,指定参数,返回结果集中的第一行第一列.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// 示例:
|
|
/// int orderCount = (int)ExecuteScalar(trans, CommandType.StoredProcedure, "GetOrderCount", new SqlParameter("@prodid", 24));
|
|
/// </remarks>
|
|
/// <param name="transaction">一个有效的连接事务</param>
|
|
/// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param>
|
|
/// <param name="commandText">存储过程名称或SQL语句</param>
|
|
/// <param name="commandParameters">分配给命令的SqlParamter参数数组</param>
|
|
/// <returns>返回结果集中的第一行第一列</returns>
|
|
public static object ExecuteScalar(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
|
|
{
|
|
if (transaction == null) throw new ArgumentNullException("transaction");
|
|
if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
|
|
|
|
// 创建SqlCommand命令,并进行预处理
|
|
SqlCommand cmd = new SqlCommand();
|
|
bool mustCloseConnection = false;
|
|
PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);
|
|
|
|
// 执行SqlCommand命令,并返回结果.
|
|
object retval = cmd.ExecuteScalar();
|
|
|
|
// 清除参数,以便再次使用.
|
|
cmd.Parameters.Clear();
|
|
return retval;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ExecuteReader
|
|
/// <summary>
|
|
/// 执行指定数据库连接字符串的数据阅读器.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// 示例:
|
|
/// SqlDataReader dr = ExecuteReader(connString, CommandType.StoredProcedure, "GetOrders");
|
|
/// </remarks>
|
|
/// <param name="ConnectionString">一个有效的数据库连接字符串</param>
|
|
/// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param>
|
|
/// <param name="commandText">存储过程名或SQL语句</param>
|
|
/// <returns>返回包含结果集的SqlDataReader</returns>
|
|
public static SqlDataReader ExecuteReader(string commandText)
|
|
{
|
|
return ExecuteReader(CommandType.Text, commandText);
|
|
}
|
|
/// <summary>
|
|
/// 执行指定数据库连接字符串的数据阅读器.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// 示例:
|
|
/// SqlDataReader dr = ExecuteReader(connString, CommandType.StoredProcedure, "GetOrders");
|
|
/// </remarks>
|
|
/// <param name="ConnectionString">一个有效的数据库连接字符串</param>
|
|
/// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param>
|
|
/// <param name="commandText">存储过程名或SQL语句</param>
|
|
/// <returns>返回包含结果集的SqlDataReader</returns>
|
|
public static SqlDataReader ExecuteReader(CommandType commandType, string commandText)
|
|
{
|
|
return ExecuteReader(commandType, commandText, (SqlParameter[])null);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 执行指定数据库连接字符串的数据阅读器,指定参数.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// 示例:
|
|
/// SqlDataReader dr = ExecuteReader(connString, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
|
|
/// </remarks>
|
|
/// <param name="ConnectionString">一个有效的数据库连接字符串</param>
|
|
/// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param>
|
|
/// <param name="commandText">存储过程名或SQL语句</param>
|
|
/// <param name="commandParameters">SqlParamter参数数组(new SqlParameter("@prodid", 24))</param>
|
|
/// <returns>返回包含结果集的SqlDataReader</returns>
|
|
public static SqlDataReader ExecuteReader(CommandType commandType, string commandText, params SqlParameter[] commandParameters)
|
|
{
|
|
if (m_connectionString == null || m_connectionString.Length == 0) throw new ArgumentNullException("ConnectionString");
|
|
SqlConnection connection = null;
|
|
try
|
|
{
|
|
connection = new SqlConnection(m_connectionString);
|
|
connection.ConnectionString = m_connectionString;
|
|
connection.Open();
|
|
|
|
return ExecuteReader(connection, null, commandType, commandText, commandParameters, SqlConnectionOwnership.Internal);
|
|
}
|
|
catch (Exception exp)
|
|
{
|
|
// If we fail to return the SqlDatReader, we need to close the connection ourselves
|
|
if (connection != null) connection.Close();
|
|
throw exp;
|
|
}
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// 执行指定数据库连接对象的数据阅读器.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// 示例:
|
|
/// SqlDataReader dr = ExecuteReader(conn, CommandType.StoredProcedure, "GetOrders");
|
|
/// </remarks>
|
|
/// <param name="connection">一个有效的数据库连接对象</param>
|
|
/// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param>
|
|
/// <param name="commandText">存储过程名或SQL语句</param>
|
|
/// <returns>返回包含结果集的SqlDataReader</returns>
|
|
public static SqlDataReader ExecuteReader(SqlConnection connection, CommandType commandType, string commandText)
|
|
{
|
|
return ExecuteReader(connection, commandType, commandText, (SqlParameter[])null);
|
|
}
|
|
|
|
/// <summary>
|
|
/// [调用者方式]执行指定数据库连接对象的数据阅读器,指定参数.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// 示例:
|
|
/// SqlDataReader dr = ExecuteReader(conn, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
|
|
/// </remarks>
|
|
/// <param name="connection">一个有效的数据库连接对象</param>
|
|
/// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param>
|
|
/// <param name="commandText">命令类型 (存储过程,命令文本或其它)</param>
|
|
/// <param name="commandParameters">SqlParamter参数数组</param>
|
|
/// <returns>返回包含结果集的SqlDataReader</returns>
|
|
public static SqlDataReader ExecuteReader(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
|
|
{
|
|
return ExecuteReader(connection, (SqlTransaction)null, commandType, commandText, commandParameters, SqlConnectionOwnership.External);
|
|
}
|
|
|
|
/// <summary>
|
|
/// [调用者方式]执行指定数据库事务的数据阅读器,指定参数值.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// 示例:
|
|
/// SqlDataReader dr = ExecuteReader(trans, CommandType.StoredProcedure, "GetOrders");
|
|
/// </remarks>
|
|
/// <param name="transaction">一个有效的连接事务</param>
|
|
/// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param>
|
|
/// <param name="commandText">存储过程名称或SQL语句</param>
|
|
/// <returns>返回包含结果集的SqlDataReader</returns>
|
|
public static SqlDataReader ExecuteReader(SqlTransaction transaction, CommandType commandType, string commandText)
|
|
{
|
|
return ExecuteReader(transaction, commandType, commandText, (SqlParameter[])null);
|
|
}
|
|
|
|
/// <summary>
|
|
/// [调用者方式]执行指定数据库事务的数据阅读器,指定参数.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// 示例:
|
|
/// SqlDataReader dr = ExecuteReader(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
|
|
/// </remarks>
|
|
/// <param name="transaction">一个有效的连接事务</param>
|
|
/// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param>
|
|
/// <param name="commandText">存储过程名称或SQL语句</param>
|
|
/// <param name="commandParameters">分配给命令的SqlParamter参数数组</param>
|
|
/// <returns>返回包含结果集的SqlDataReader</returns>
|
|
public static SqlDataReader ExecuteReader(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
|
|
{
|
|
if (transaction == null) throw new ArgumentNullException("transaction");
|
|
if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
|
|
|
|
return ExecuteReader(transaction.Connection, transaction, commandType, commandText, commandParameters, SqlConnectionOwnership.External);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 枚举,标识数据库连接是由BaseSqlHelper提供还是由调用者提供
|
|
|
|
|
|
|
|
/// </summary>
|
|
private enum SqlConnectionOwnership
|
|
{
|
|
/// <summary>由BaseSqlHelper提供连接</summary>
|
|
Internal,
|
|
/// <summary>由调用者提供连接</summary>
|
|
External
|
|
}
|
|
|
|
/// <summary>
|
|
/// 执行指定数据库连接对象的数据阅读器.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// 如果是BaseSqlHelper打开连接,当连接关闭DataReader也将关闭.
|
|
/// 如果是调用都打开连接,DataReader由调用都管理.
|
|
/// </remarks>
|
|
/// <param name="connection">一个有效的数据库连接对象</param>
|
|
/// <param name="transaction">一个有效的事务,或者为 'null'</param>
|
|
/// <param name="commandType">命令类型 (存储过程,命令文本或其它)</param>
|
|
/// <param name="commandText">存储过程名或SQL语句</param>
|
|
/// <param name="commandParameters">SqlParameters参数数组,如果没有参数则为'null'</param>
|
|
/// <param name="connectionOwnership">标识数据库连接对象是由调用者提供还是由BaseSqlHelper提供</param>
|
|
/// <returns>返回包含结果集的SqlDataReader</returns>
|
|
private static SqlDataReader ExecuteReader(SqlConnection connection, SqlTransaction transaction, CommandType commandType, string commandText, SqlParameter[] commandParameters, SqlConnectionOwnership connectionOwnership)
|
|
{
|
|
if (connection == null) throw new ArgumentNullException("connection");
|
|
bool mustCloseConnection = false;
|
|
// 创建命令
|
|
SqlCommand cmd = new SqlCommand();
|
|
try
|
|
{
|
|
PrepareCommand(cmd, connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);
|
|
// 创建数据阅读器
|
|
|
|
|
|
|
|
SqlDataReader dataReader;
|
|
if (connectionOwnership == SqlConnectionOwnership.External)
|
|
{
|
|
dataReader = cmd.ExecuteReader();
|
|
}
|
|
else
|
|
{
|
|
dataReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
|
|
}
|
|
// 清除参数,以便再次使用..
|
|
// HACK There is a problem here, the output parameter values are fletched
|
|
// when the reader is closed, so if the parameters are detached from the command
|
|
// then the SqlReader can set its values.
|
|
// When this happen, the parameters can be used again in other command.
|
|
bool canClear = true;
|
|
foreach (SqlParameter commandParameter in cmd.Parameters)
|
|
{
|
|
if (commandParameter.Direction != ParameterDirection.Input)
|
|
canClear = false;
|
|
}
|
|
|
|
if (canClear)
|
|
{
|
|
cmd.Parameters.Clear();
|
|
}
|
|
return dataReader;
|
|
}
|
|
catch (Exception exp)
|
|
{
|
|
if (mustCloseConnection)
|
|
connection.Close();
|
|
throw exp;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Common Utility
|
|
/// <summary>
|
|
/// 预处理用户提供的命令,数据库连接/事务/命令类型/参数
|
|
/// </summary>
|
|
/// <param name="command">要处理的SqlCommand</param>
|
|
/// <param name="connection">数据库连接</param>
|
|
/// <param name="transaction">一个有效的事务或者是null值</param>
|
|
/// <param name="commandType">命令类型 (存储过程,命令文本, 其它.)</param>
|
|
/// <param name="commandText">存储过程名或都SQL命令文本</param>
|
|
/// <param name="commandParameters">和命令相关联的SqlParameter参数数组,如果没有参数为'null'</param>
|
|
/// <param name="mustCloseConnection"><c>true</c> 如果连接是打开的,则为true,其它情况下为false.</param>
|
|
private static void PrepareCommand(SqlCommand command, SqlConnection connection, SqlTransaction transaction, CommandType commandType, string commandText, SqlParameter[] commandParameters, out bool mustCloseConnection)
|
|
{
|
|
if (command == null) throw new ArgumentNullException("command");
|
|
if (commandText == null || commandText.Length == 0) throw new ArgumentNullException("commandText");
|
|
// 如果连接没有打开则打开连接
|
|
if (connection.State != ConnectionState.Open)
|
|
{
|
|
mustCloseConnection = true;
|
|
connection.Open();
|
|
}
|
|
else
|
|
{
|
|
mustCloseConnection = false;
|
|
}
|
|
// 给命令分配一个数据库连接.
|
|
command.Connection = connection;
|
|
// 设置命令文本(存储过程名或SQL语句)
|
|
command.CommandText = commandText;
|
|
// 分配事务
|
|
if (transaction != null)
|
|
{
|
|
if (transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
|
|
command.Transaction = transaction;
|
|
}
|
|
// 设置命令类型.
|
|
command.CommandType = commandType;
|
|
// 分配命令参数
|
|
if (commandParameters != null)
|
|
{
|
|
command.Parameters.Clear();
|
|
foreach (SqlParameter parm in commandParameters)
|
|
command.Parameters.Add(parm);
|
|
}
|
|
return;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 将DataReader转化为DataSet
|
|
/// </summary>
|
|
/// <param name="reader">DataReader数据接口</param>
|
|
/// <returns>DataSet格式的数据</returns>
|
|
private static DataSet Reader2Set(IDataReader reader)
|
|
{
|
|
DataTable table = new DataTable();
|
|
int fieldCount = reader.FieldCount;
|
|
for (int i = 0; i < fieldCount; i++)
|
|
{
|
|
table.Columns.Add(reader.GetName(i), reader.GetFieldType(i));
|
|
}
|
|
table.BeginLoadData();
|
|
object[] values = new object[fieldCount];
|
|
while (reader.Read())
|
|
{
|
|
reader.GetValues(values);
|
|
table.LoadDataRow(values, true);
|
|
}
|
|
table.EndLoadData();
|
|
DataSet ds = new DataSet();
|
|
ds.Tables.Add(table);
|
|
return ds;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 将DataReader转化为DataTable
|
|
/// </summary>
|
|
/// <param name="reader">DataReader数据接口</param>
|
|
/// <returns>DataTable格式的数据</returns>
|
|
private static DataTable Reader2Table(IDataReader reader)
|
|
{
|
|
DataTable table = new DataTable();
|
|
int fieldCount = reader.FieldCount;
|
|
for (int i = 0; i < fieldCount; i++)
|
|
{
|
|
table.Columns.Add(reader.GetName(i), reader.GetFieldType(i));
|
|
}
|
|
table.BeginLoadData();
|
|
object[] values = new object[fieldCount];
|
|
while (reader.Read())
|
|
{
|
|
reader.GetValues(values);
|
|
table.LoadDataRow(values, true);
|
|
}
|
|
table.EndLoadData();
|
|
return table;
|
|
}
|
|
#endregion
|
|
|
|
#region Cache
|
|
|
|
/// <summary>
|
|
/// 追加参数数组到缓存.
|
|
/// </summary>
|
|
/// <param name="ConnectionString">一个有效的数据库连接字符串</param>
|
|
/// <param name="commandText">存储过程名或SQL语句</param>
|
|
/// <param name="commandParameters">要缓存的参数数组</param>
|
|
public static void CacheParameterSet(string commandText, params SqlParameter[] commandParameters)
|
|
{
|
|
if (ConnectionString == null || ConnectionString.Length == 0) throw new ArgumentNullException("ConnectionString");
|
|
if (commandText == null || commandText.Length == 0) throw new ArgumentNullException("commandText");
|
|
|
|
string hashKey = ConnectionString + ":" + commandText;
|
|
|
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// SqlParameter参数数组的深层拷贝.
|
|
/// </summary>
|
|
/// <param name="originalParameters">原始参数数组</param>
|
|
/// <returns>返回一个同样的参数数组</returns>
|
|
private static SqlParameter[] CloneParameters(SqlParameter[] originalParameters)
|
|
{
|
|
SqlParameter[] clonedParameters = new SqlParameter[originalParameters.Length];
|
|
|
|
for (int i = 0, j = originalParameters.Length; i < j; i++)
|
|
{
|
|
clonedParameters[i] = (SqlParameter)((ICloneable)originalParameters[i]).Clone();
|
|
}
|
|
|
|
return clonedParameters;
|
|
}
|
|
#endregion Cache
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// 多条SQL语句一块执行的效果
|
|
/// </summary>
|
|
/// <param name="commandType">command类型</param>
|
|
/// <param name="ListCommandText">存储过程名数组</param>
|
|
/// <param name="ListOracleParameters">参数数组 泛型</param>
|
|
/// <param name="msg"></param>
|
|
/// <returns></returns>
|
|
public static int ExecuteNonSQLList(CommandType commandType, System.Collections.Generic.List<string> ListCommandText, ref string msg)
|
|
{
|
|
return ExecuteNonSQLList(m_connectionString, commandType, ListCommandText, ref msg);
|
|
}
|
|
public static int ExecuteNonSQLList(CommandType commandType, System.Collections.Generic.List<string> ListCommandText, List<SqlParameter[]> ListSqlParameters, ref string msg)
|
|
{
|
|
return ExecuteNonSQLList(m_connectionString, commandType, ListCommandText,ListSqlParameters, ref msg);
|
|
}
|
|
|
|
///// <summary>
|
|
///// 多条SQL语句一块执行的效果
|
|
///// </summary>
|
|
///// <param name="commandType">command类型</param>
|
|
///// <param name="ListCommandText">存储过程名数组</param>
|
|
///// <param name="ListOracleParameters">参数数组 泛型</param>
|
|
///// <param name="msg"></param>
|
|
///// <returns></returns>
|
|
//public static int ExecuteNonSQLList(string connectionString, CommandType commandType, System.Collections.Generic.List<string> ListCommandText, ref string msg)
|
|
//{
|
|
// int flag = 0;
|
|
// if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
|
|
|
|
// using (SqlConnection sc = new SqlConnection(connectionString))
|
|
// {
|
|
// sc.Open();
|
|
// SqlTransaction tran = sc.BeginTransaction();
|
|
|
|
// for (int i = 0; i < ListCommandText.Count; i++)
|
|
// {
|
|
// flag = ExecuteNonQuery(sc, commandType, ListCommandText[i]);
|
|
|
|
// if (flag < 0)
|
|
// {
|
|
// //msg = ListCommandParameters[i][ListCommandParameters[i].Length - 1].Value.ToString();
|
|
// RollbackTransaction(tran);
|
|
// return flag;
|
|
// }
|
|
// }
|
|
// CommitTransaction(tran);
|
|
// return flag;
|
|
// }
|
|
//}
|
|
|
|
/// <summary>
|
|
/// 多条SQL语句一块执行的效果
|
|
/// </summary>
|
|
/// <param name="connectionString">连接字符串</param>
|
|
/// <param name="commandType">command类型</param>
|
|
/// <param name="ListCommandText">存储过程名数组</param>
|
|
/// <param name="ListOracleParameters">参数数组 泛型</param>
|
|
/// <param name="msg"></param>
|
|
/// <returns></returns>
|
|
public static int ExecuteNonSQLList(string connectionString, CommandType commandType, List<string> ListCommandText,List<SqlParameter[]> ListSqlParameters, ref string msg)
|
|
{
|
|
int flag = 0;
|
|
if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
|
|
|
|
using (SqlConnection sc = new SqlConnection(connectionString))
|
|
{
|
|
sc.Open();
|
|
SqlTransaction tran = sc.BeginTransaction();
|
|
|
|
for (int i = 0; i < ListCommandText.Count; i++)
|
|
{
|
|
flag = ExecuteNonQuery(tran, commandType, ListCommandText[i],ListSqlParameters[i]);
|
|
|
|
if (flag < 0)
|
|
{
|
|
//msg = ListCommandParameters[i][ListCommandParameters[i].Length - 1].Value.ToString();
|
|
RollbackTransaction(tran);
|
|
return flag;
|
|
}
|
|
}
|
|
CommitTransaction(tran);
|
|
return flag;
|
|
}
|
|
}
|
|
public static int ExecuteNonSQLList(string connectionString, CommandType commandType, List<string> ListCommandText, ref string msg)
|
|
{
|
|
int flag = 0;
|
|
if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
|
|
|
|
using (SqlConnection sc = new SqlConnection(connectionString))
|
|
{
|
|
sc.Open();
|
|
SqlTransaction tran = sc.BeginTransaction();
|
|
|
|
for (int i = 0; i < ListCommandText.Count; i++)
|
|
{
|
|
flag = ExecuteNonQuery(tran, commandType, ListCommandText[i]);
|
|
|
|
if (flag < 0)
|
|
{
|
|
//msg = ListCommandParameters[i][ListCommandParameters[i].Length - 1].Value.ToString();
|
|
RollbackTransaction(tran);
|
|
return flag;
|
|
}
|
|
}
|
|
CommitTransaction(tran);
|
|
return flag;
|
|
}
|
|
}
|
|
|
|
#region Transaction
|
|
static SqlConnection sc;
|
|
public static SqlTransaction BeginTransaction(string connectionString)
|
|
{
|
|
sc = new SqlConnection(connectionString);
|
|
if (sc.State != ConnectionState.Open)
|
|
{
|
|
sc.Open();
|
|
}
|
|
SqlTransaction tran = sc.BeginTransaction();
|
|
return tran;
|
|
}
|
|
|
|
public static SqlTransaction BeginTransaction()
|
|
{
|
|
return BeginTransaction(m_connectionString);
|
|
}
|
|
|
|
public static void RollbackTransaction(SqlTransaction tran)
|
|
{
|
|
if (tran != null)
|
|
{
|
|
tran.Rollback();
|
|
}
|
|
if (sc != null)
|
|
{
|
|
sc.Close();
|
|
|
|
}
|
|
}
|
|
|
|
public static void CommitTransaction(SqlTransaction tran)
|
|
{
|
|
string errText = string.Empty;
|
|
try
|
|
{
|
|
if (tran != null)
|
|
{
|
|
tran.Commit();
|
|
|
|
}
|
|
if (sc != null)
|
|
{
|
|
|
|
sc.Close();
|
|
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
|
|
WMS.Common.LogWriteText.WriteLog(ex.Message.ToString() + ex.InnerException.ToString());
|
|
if (sc != null)
|
|
{
|
|
sc.Close();
|
|
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
|
|
}
|
|
}
|