|
using System;
using System.Collections.Generic;
using System.Text;
using System.Configuration;
using System.Data;
using System.Data.SqlClient;
using System.Reflection;
namespace {namespace}.DBUtility
{
public abstract class SqlHelper
{
/// <summary>
/// 數據庫連接字符串
/// </summary>
public static readonly string ConnectionString = ConfigurationManager.ConnectionStrings["SqlConnectionString"].ToString();
#region 批量數據插入數據庫
/// <summary>
/// 批量數據插入數據庫
/// </summary>
/// <param name="dt">DataTable</param>
public static void DataTableToSQLServer(DataTable dt, string TabName) {
using (SqlConnection destinationConnection = new SqlConnection(ConnectionString)) {
destinationConnection.Open();
using (SqlBulkCopy bulkCopy = new SqlBulkCopy(destinationConnection)) {
//將DataTable表名作爲待導入庫中的目標表名
bulkCopy.DestinationTableName = TabName;
foreach (DataColumn item in dt.Columns) {
bulkCopy.ColumnMappings.Add(item.ColumnName, item.ColumnName);
}
bulkCopy.WriteToServer(dt);
}
}
}
#endregion
#region 執行操作，返回表 +static DataTable ExcuteTable(string sql, CommandType type, params SqlParameter[] ps)
/// <summary>
/// 執行操作，返回表
/// </summary>
/// <param name="sql"></param>
/// <returns></returns>
public static DataTable ExcuteTable(string sql, CommandType type, params SqlParameter[] ps) {
DataTable dt = new DataTable();
SqlDataAdapter da = new SqlDataAdapter(sql, ConnectionString);
da.SelectCommand.CommandType = type;
da.SelectCommand.Parameters.AddRange(ps);
da.Fill(dt);
return dt;
}
#endregion
#region 執行操作，返回DataSet表集合 +static DataSet ExcuteTable(string sql, CommandType type, params SqlParameter[] ps)
/// <summary>
/// 執行操作，返回表
/// </summary>
/// <param name="sql"></param>
/// <returns></returns>
public static DataSet ExcuteDataSet(string sql, CommandType type, params SqlParameter[] ps) {
DataSet ds = new DataSet();
SqlDataAdapter da = new SqlDataAdapter(sql, ConnectionString);
da.SelectCommand.CommandType = type;
da.SelectCommand.Parameters.AddRange(ps);
da.Fill(ds);
return ds;
}
#endregion
#region 返回單個值的泛型版本 -static T ExcuteScalar<T>(string sql, params SqlParameter[] ps)
/// <summary>
/// 返回單個值的泛型版本
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="sql"></param>
/// <param name="ps"></param>
/// <returns></returns>
public static T ExcuteScalar<T>(string sql, params SqlParameter[] ps) {
using (SqlConnection conn = new SqlConnection(ConnectionString)) {
conn.Open();
SqlCommand comm = new SqlCommand(sql, conn);
comm.Parameters.AddRange(ps);
object obj = comm.ExecuteScalar(); //標識列返回的值的類型不是int而是decimal
return default(T);
}
}
#endregion
#region 返回泛型集合 + static List<T> GetList<T>(DataTable dt)
/// <summary>
/// 返回泛型集合
/// </summary>
/// <typeparam name="T">類型佔位，並不是一個真正存在的類型，只在運行的時候才能確定它的類型是什麼</typeparam>
/// <param name="dt"></param>
/// <returns></returns>
public static List<T> GetList<T>(DataTable dt) {
//int num = dt.Columns.Count;
List<T> lists = new List<T>();
//獲取當前T所指定的類型
Type t = typeof(T);
//通過反射的方式得到類型的屬性
PropertyInfo[] ps = t.GetProperties();
foreach (DataRow row in dt.Rows) {
//每一行對應着一個對象，通過反射的方式創建出對象
T obj = (T)Activator.CreateInstance(t);
//不能通過對象.屬性的方式來賦值，因爲屬性是什麼都不知道
//通過反射的方式爲對象的屬性賦值
foreach (PropertyInfo p in ps) {
string name = p.Name;
//表的字段名稱就是類的屬性名稱
p.SetValue(obj, row[name], null);
}
lists.Add(obj);
}
return lists;
}
#endregion
#region 用提供的參數，在連接字符串所指定的數據庫中執行SQL語句（非查詢）
/// <summary>
/// 用提供的參數，在連接字符串所指定的數據庫中執行SQL語句（非查詢）
/// </summary>
/// <remarks>
/// 使用示例:
/// int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
/// </remarks>
/// <param name="connectionString">數據庫連接字符串</param>
/// <param name="commandType">命令類型（存儲過程、文本等）</param>
/// <param name="commandText">存儲過程名或T-SQL語句</param>
/// <param name="commandParameters">用於執行命令的參數數組</param>
/// <returns>受命令所影響的行數</returns>
public static int ExecuteNonQuery(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters) {
SqlCommand cmd = new SqlCommand();
using (SqlConnection conn = new SqlConnection(connectionString)) {
PrepareCommand(cmd, conn, null, commandType, commandText, commandParameters);
int val = cmd.ExecuteNonQuery();
cmd.Parameters.Clear();
return val;
}
}
#endregion
#region 用提供的參數和存在的數據庫連接對象，執行SQL語句（非查詢）
/// <summary>
/// 用提供的參數和存在的數據庫連接對象，執行SQL語句（非查詢）
/// </summary>
/// <remarks>
/// 使用示例:
/// int result = ExecuteNonQuery(connection, 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">用於執行命令的參數數組</param>
/// <returns>受命令所影響的行數</returns>
public static int ExecuteNonQuery(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters) {
SqlCommand cmd = new SqlCommand();
PrepareCommand(cmd, connection, null, commandType, commandText, commandParameters);
int val = cmd.ExecuteNonQuery();
cmd.Parameters.Clear();
return val;
}
#endregion
#region 用提供的參數和存在的事務對象，執行SQL語句（非查詢）
/// <summary>
/// 用提供的參數和存在的事務對象，執行SQL語句（非查詢）
/// </summary>
/// <remarks>
/// 使用示例:
/// int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
/// </remarks>
/// <param name="trans">存在的事務對象</param>
/// <param name="commandType">命令類型（存儲過程、文本等）</param>
/// <param name="commandText">存儲過程名或T-SQL語句</param>
/// <param name="commandParameters">用於執行命令的參數數組</param>
/// <returns>受命令所影響的行數</returns>
public static int ExecuteNonQuery(SqlTransaction trans, CommandType commandType, string commandText, params SqlParameter[] commandParameters) {
SqlCommand cmd = new SqlCommand();
PrepareCommand(cmd, trans.Connection, trans, commandType, commandText, commandParameters);
int val = cmd.ExecuteNonQuery();
cmd.Parameters.Clear();
return val;
}
#endregion
#region 用提供的參數，在連接字符串所指定的數據庫中執行SQL查詢，並返回結果集（SqlDataReader）
/// <summary>
/// 用提供的參數，在連接字符串所指定的數據庫中執行SQL查詢，並返回結果集（SqlDataReader）
/// </summary>
/// <remarks>
/// 使用示例:
/// SqlDataReader r = ExecuteReader(connectionString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
/// </remarks>
/// <param name="connectionString">數據庫連接字符串</param>
/// <param name="commandType">命令類型（存儲過程、文本等）</param>
/// <param name="commandText">存儲過程名或T-SQL語句</param>
/// <param name="commandParameters">用於執行命令的參數數組</param>
/// <returns>一個包含結果的SqlDataReader對象</returns>
public static SqlDataReader ExecuteReader(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters) {
SqlCommand cmd = new SqlCommand();
SqlConnection conn = new SqlConnection(connectionString);
// 之所以這裏用 try/catch，是因爲：
// 如果方法拋出異常時，我們希望關閉連接並拋出異常
// 因爲此時不會返回 DataReader，故 commandBehaviour.CloseConnection 也不起作用
try {
PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
SqlDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
cmd.Parameters.Clear();
return rdr;
} catch {
conn.Close();
throw;
}
}
#endregion
#region 用提供的參數，在連接字符串所指定的數據庫中執行SQL查詢，並返回查詢結果的第一行第一列的值
/// <summary>
/// 用提供的參數，在連接字符串所指定的數據庫中執行SQL查詢，並返回查詢結果的第一行第一列的值
/// </summary>
/// <remarks>
/// 使用示例:
/// Object obj = ExecuteScalar(connectionString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
/// </remarks>
/// <param name="connectionString">數據庫連接字符串</param>
/// <param name="commandType">命令類型（存儲過程、文本等）</param>
/// <param name="commandText">存儲過程名或T-SQL語句</param>
/// <param name="commandParameters">用於執行命令的參數數組</param>
/// <returns>一個 object 對象，可用 Convert.To{Type} 轉換爲所需類型</returns>
public static object ExecuteScalar(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters) {
SqlCommand cmd = new SqlCommand();
using (SqlConnection connection = new SqlConnection(connectionString)) {
PrepareCommand(cmd, connection, null, commandType, commandText, commandParameters);
object val = cmd.ExecuteScalar();
cmd.Parameters.Clear();
return val;
}
}
#endregion
#region 用提供的參數和存在的數據庫連接對象，執行SQL查詢，並返回查詢結果的第一行第一列的值
/// <summary>
/// 用提供的參數和存在的數據庫連接對象，執行SQL查詢，並返回查詢結果的第一行第一列的值
/// </summary>
/// <remarks>
/// 使用示例:
/// Object obj = ExecuteScalar(connection, 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">用於執行命令的參數數組</param>
/// <returns>一個 object 對象，可用 Convert.To{Type} 轉換爲所需類型</returns>
public static object ExecuteScalar(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters) {
SqlCommand cmd = new SqlCommand();
PrepareCommand(cmd, connection, null, commandType, commandText, commandParameters);
object val = cmd.ExecuteScalar();
cmd.Parameters.Clear();
return val;
}
#endregion
#region 用提供的參數和存在的數據庫連接對象，執行SQL查詢，並返回查詢結果的DatSet結果集
/// <summary>
/// 用提供的參數和存在的數據庫連接對象，執行SQL查詢，並返回查詢結果的DatSet結果集
/// </summary>
/// <param name="connectionString">鏈接語句</param>
/// <param name="commandText">sql語句</param>
/// <param name="commandType">查詢模式</param>
/// <param name="commandParameters">Parameter參數</param>
/// <returns></returns>
static public DataSet ExecuteDataSet(string connectionString, string commandText, CommandType commandType, params SqlParameter[] commandParameters) {
DataSet ds = new DataSet();
using (SqlConnection con = new SqlConnection(ConnectionString)) {
SqlDataAdapter adapter = new SqlDataAdapter();
SqlCommand cmd = new SqlCommand();
PrepareCommand(cmd, con, null, commandType, commandText, commandParameters);
adapter.SelectCommand = cmd;
adapter.Fill(ds);
}
return ds;
}
#endregion
#region 構建一個用於執行的命令對象
/// <summary>
/// 構建一個用於執行的命令對象
/// </summary>
/// <param name="cmd">SqlCommand 對象</param>
/// <param name="conn">SqlConnection 對象</param>
/// <param name="trans">SqlTransaction 對象</param>
/// <param name="cmdType">命令類型（存儲過程、文本等）</param>
/// <param name="cmdText">存儲過程名或T-SQL語句</param>
/// <param name="cmdParms">用於執行命令的參數數組</param>
private static void PrepareCommand(SqlCommand cmd, SqlConnection conn, SqlTransaction trans, CommandType cmdType, string cmdText, SqlParameter[] cmdParms) {
if (conn.State != ConnectionState.Open)
conn.Open();
cmd.Connection = conn;
cmd.CommandText = cmdText;
if (trans != null)
cmd.Transaction = trans;
cmd.CommandType = cmdType;
if (cmdParms != null) {
foreach (SqlParameter parm in cmdParms)
cmd.Parameters.Add(parm);
}
}
#endregion
}
}
|
