/// <Summary>
/// database general procedure class
/// </ Summary>
public abstract class the DbHelper
{
#region "connect string"
// connection string
// public static string ConnString = ConfigurationManager.ConnectionStrings [ "CommonSqlConnectionString "] .ConnectionString;
public static String DefaultConnString = string.Empty;
public int const = 180 [defaultCommandTimeout;
public int const = defaultdbconfig. 1;
#endregion
#region" GetSqlCommand "
/// <Summary>
/// Get Command object initialization good
/// </ Summary>
/// <param name = "Conn">Connection object </ param>
/// <param name = "cmdText" > text command </ param>
/// <param name = "cmdType"> command type </ param>
/// <param name = "Parameters"> Parameter List </ param >
/// <Returns> Command object initialization good </ Returns>
Private GetSqlCommand the SqlCommand static (the SqlConnection Conn, cmdText The String, the CommandType cmdType, the SqlParameter [] Parameters)
{
the SqlCommand the SqlCommand cmd = new new (cmdText The, Conn);
cmd.CommandType cmdType =;
cmd.CommandTimeout = defaultCommandTimeout;
IF (! Parameters = null)
{
cmd.Parameters.AddRange (Parameters);
}
return cmd;
}
#endregion
#region " ExecSqlDataSet "
public static DataTable ExecSqlDataSet(string strSQL)
{
return ExecSqlDataSet(strSQL, null);
}
public static DataTable ExecSqlDataSet(string strSQL, SqlParameter[] parameters)
{
return ExecSqlDataSet(strSQL, parameters, DefaultConnString);
}
public static DataTable ExecSqlDataSet(string strSQL, SqlParameter[] parameters, string connStr)
{
if (string.IsNullOrWhiteSpace(connStr))
{
return new DataTable();
}
using (SqlConnection conn = new SqlConnection(connStr))
{
Conn.Open ();
the SqlCommand cmd = GetSqlCommand (Conn, strSQL, CommandType.Text, Parameters);
the SqlDataAdapter new new DA = the SqlDataAdapter (cmd);
the DataSet the DataSet new new DS = ();
da.Fill (DS);
cmd.Dispose ();
da.Dispose ();
return ds.Tables [0];
}
}
#endregion
#region "ExecSqlNonQuerry"
/// <Summary>
/// execute the SQL query non
/// </ Summary>
/// <param name = "strSQL"> SQL statements to be executed </ param>
/// <returns a> the number of rows affected </returns>
static int ExecSqlNonQuerry public (String strSQL)
{
ExecSqlNonQuerry return (strSQL, null);
}
/// <Summary>
/// performed with non-parametric queries the SQL statement
/// </ Summary>
/// <param name = "strSQL"> SQL statement to be executed < / param>
/// <Returns> number of rows affected </ Returns>
public static int ExecSqlNonQuerry (String strSQL, the SqlParameter [] Parameters)
{
return ExecSqlNonQuerry (strSQL, Parameters, DefaultConnString);
}
public static int ExecSqlNonQuerry (String strSQL , the SqlParameter [] Parameters, String connStr)
{
the using (Conn the SqlConnection the SqlConnection new new = (connStr))
{
conn.Open ();
The SqlCommand cmd = GetSqlCommand (Conn, strSQL, CommandType.Text, Parameters);
cmd.CommandTimeout = 0;
int the cmd.ExecuteNonQuery Result = ();
cmd.Dispose ();
return Result;
}
}
#endregion
#region "ExecSqlScalar"
/// <the Summary>
/// perform statistical inquiry
/// </ the Summary>
/// <param name = "strSQL"> SQL statements to be executed </ param>
/// <returns a> the results of the first row the value of a </ returns>
public static object ExecSqlScalar(string strSQL)
{
return ExecSqlScalar(strSQL, null);
}
/// <Summary>
Statistical query execution with parameters ///
/// </ Summary>
/// <param name = "strSQL"> SQL statement to be executed </ param>
/// <param name = "Parameters"> parameter array </ param>
/// <Returns> the first row value </ returns> a first execution result of
public static Object ExecSqlScalar (String strSQL, the SqlParameter [] Parameters)
{
return ExecSqlScalar (strSQL, Parameters, DefaultConnString);
}
/// <Summary>
/// performed statistical queries with parameters
/// </ the Summary>
/// <param name = "strSQL"> be </ param> execute SQL statements
/// <param name = "parameters" > parameter array </ param>
// / <returns> value of the execution result of the first row of the first column </returns>
Object ExecSqlScalar static public (String strSQL, the SqlParameter [] Parameters, String connStr)
/// <param name = "procName" > stored procedure to be performed </ param>SqlParameter[] parameters, string connStr)
{
the using (Conn the SqlConnection the SqlConnection new new = (connStr))
{
conn.Open ();
the SqlCommand cmd = GetSqlCommand (Conn, strSQL, CommandType.Text, Parameters);
Object cmd.ExecuteScalar Result = ();
cmd.Dispose ();
return result;
}
}
#endregion
#region "ExecProcDataSet"
/// <Summary>
/// executes a stored procedure to return an execution result
/// </ Summary>
/// <returns> results </ returns>
public static ExecProcDataSet the DataSet (String procName)
{
return ExecProcDataSet (procName, null);
}
/// <Summary>
/// performed with parameters stored procedure to return an execution result
/ // </ Summary>
/// <param name = "procName"> stored procedure to be performed </ param>
/// <param name = "parameters"> parameter array </ param>
/// <Returns> results </ Returns>
public static ExecProcDataSet the DataSet (String procName, the SqlParameter [] Parameters)
{
return ExecProcDataSet (procName, Parameters, DefaultConnString);
}
/// <Summary>
/// performed with parameters stored procedure to return an execution result
/// </ Summary>
/// <param name = "procName"> stored procedure to be performed </ param>
/// <param name = "parameters"> parameter array </ param>
/// <returns>查询结果</returns>
public static DataSet ExecProcDataSet(string procName, SqlParameter[] parameters, string connStr)
{
using (SqlConnection conn = new SqlConnection(connStr))
{
conn.Open();
SqlCommand cmd = GetSqlCommand(conn, procName, CommandType.StoredProcedure, parameters);
cmd.CommandTimeout = 0;
SqlDataAdapter da = new SqlDataAdapter(cmd);
DataSet ds = new DataSet();
da.Fill(ds);
cmd.Dispose();
return ds;
}
}
#endregion
/// <returns> results </ returns>
#region "ExecProcDataTable"
/// <Summary>
/// executes a stored procedure to return an execution result
/// </ Summary>
/// <param name = "procName"> stored procedure to be performed </ param>
/// <returns> results </ returns>
public static ExecProcDataTable the DataTable (String procName)
{
return ExecProcDataSet (procName) .Tables [0];
}
/// <Summary>
/// performed with parameters stored procedure to return an execution result
/ // </ Summary>
/// <param name = "procName"> stored procedure to be performed </ param>
/// <param name = "parameters"> parameter array </ param>
{
the DataTable ExecProcDataTable static public (String procName, the SqlParameter [] Parameters)
public static int ExecProcNonQuerry(string procName)
ExecProcDataSet return (procName, Parameters) .Tables [0];
}
public static ExecProcDataTable the DataTable (String procName, the SqlParameter [] Parameters, String connStr)
{
return ExecProcDataSet (procName, Parameters, connStr) .Tables [0];
}
#endregion
# Region "ExecProcNonQuerry"
/// <Summary>
/// query stored procedure to perform non
/// </ Summary>
/// <param name = "procName"> stored procedure to be performed </ param>
/// <Returns> the number of rows affected </ Returns>
/// <Summary>
/// execute queries with parameters of non-stored procedures
{
Return ExecProcNonQuerry (procName);
}
/// </ Summary>
/// <param name = "procName"> stored procedure to be performed </ param>
/// <Returns> number of rows affected </ Returns>
public int ExecProcNonQuerry static (String procName, the SqlParameter [] parameters)
{
return ExecProcNonQuerry (procName, parameters, DefaultConnString);
}
/// <Summary>
/// performed with non-parametric queries stored procedure
/// </ Summary>
/ // <param name = "procName" > stored procedure to be performed </ param>
/// <Returns> number of rows affected </ Returns>
public static int ExecProcNonQuerry (String procName,SqlParameter[] parameters, string connStr)
{
The using (Conn the SqlConnection the SqlConnection new new = (connStr))
{
conn.Open ();
the SqlCommand cmd = GetSqlCommand (Conn, procName, CommandType.StoredProcedure, Parameters);
int the cmd.ExecuteNonQuery Result = ();
cmd.Dispose ();
return Result;
}
}
#endregion
#region "ExecSqlDataReader"
/// <Summary>
/// execute SQL statements, the execution result returned
/// </ Summary>
/// <param name = "strSQL"> SQL statement to be executed </ param>
/// <returns> results </ returns>
public static SqlDataReader ExecSqlDataReader(string strSQL)
{
ExecSqlDataReader return (strSQL, null);
}
/// <summary>
/// performed with parameters SQL statement that returns an execution result
/// </ Summary>
/// <param name = "strSQL"> SQL statement to be executed </ param>
/// <param name = "parameters"> parameter array </ param>
/// <Returns> results </ Returns>
public static ExecSqlDataReader the SqlDataReader (String strSQL, the SqlParameter [] parameters)
{
return ExecSqlDataReader (strSQL, parameters, DefaultConnString);
}
/// <Summary>
/// SQL statement execution parameters, returns the execution result
/// </ Summary>
/// <param name = "strSQL"> be </ param> execute SQL statements
/// < param name = "parameters "> parameter array </ param>
/// <Returns> Results </ returns>
public static SqlDataReader ExecSqlDataReader(string strSQL, SqlParameter[] parameters, string connStr)
{
using (SqlConnection conn = new SqlConnection(connStr))
{
conn.Open();
SqlCommand cmd = GetSqlCommand(conn, strSQL, CommandType.Text, parameters);
SqlDataReader result = cmd.ExecuteReader(CommandBehavior.CloseConnection);
cmd.Dispose();
return result;
}
}
#endregion
#region " ExecProcDataReader "
/// <summary>
/// 执行存储过程，返回执行结果
/// </summary>
/// <param name = "procName" > stored procedure to be performed </ param>
/// <Returns> Results </ Returns>
public static ExecProcDataReader the SqlDataReader (String procName)
{
return ExecProcDataReader (procName, null);
}
/ // <Summary>
/// performed with parameters stored procedure to return an execution result
/// </ Summary>
/// <param name = "procName"> stored procedure to be performed </ param>
/// <param name = "parameters"> parameter array </ param>
/// <Returns> results </ Returns>
public static ExecProcDataReader the SqlDataReader (String procName,SqlParameter[] parameters)
{
return ExecProcDataReader(procName, parameters, DefaultConnString);
}
/// <Summary>
/// performed with parameters stored procedure to return an execution result
/// </ Summary>
/// <param name = "procName"> stored procedure to be performed </ param>
/// <param name = "parameters"> parameter array </ param>
/// <Returns> results </ Returns>
public static ExecProcDataReader the SqlDataReader (String procName, the SqlParameter [] parameters, String connStr)
{
the using (Conn the SqlConnection the SqlConnection new new = (connStr ))
{
conn.Open ();
the SqlCommand cmd = GetSqlCommand (Conn, procName, CommandType.StoredProcedure, Parameters);
the SqlDataReader cmd.ExecuteReader Result = (the CommandBehavior.CloseConnection);
cmd.Dispose();
Result return;
}
}
#endregion
#region "DtToSqlServer"
/// <Summary>
/// The bulk import DataTable SqlServer
/// </ Summary>
/// <param name = "dtExcel"> Data Table </ param>
/// <param name = "tableName" > target table name </ param>
/// <param name = "dtColName"> data sets corresponding column </ param>
public static void DtToSqlServer (dtExcel the DataTable, String tableName, dtColName the DataTable)
{
DtToSqlServer (dtExcel, tableName, dtColName, DefaultConnString);
}
/// <Summary>
/// The bulk import DataTable SqlServer
/// </ Summary>
/// <param name = "dtExcel" > Data Table </ param>
/// <param name = "tableName"> target table name </ param>
/// <param name = "dtColName"> corresponding column datasets </ param>
public static void DtToSqlServer (dtExcel the DataTable, String tableName, the DataTable dtColName, String connStr)
{
the using (Conn the SqlConnection the SqlConnection new new = (connStr))
{
conn.Open ();
the using (the SqlBulkCopy bulkcopy the SqlBulkCopy new new = ( Conn))
{
the try
{
bulkCopy.DestinationTableName = tableName; // table to insert a table name
for (int i = 0;i < dtColName.Rows.Count; i++)
{
bulkCopy.ColumnMappings.Add(dtColName.Rows[i][0].ToString().Trim(), dtColName.Rows[i][1].ToString().Trim());
}
bulkCopy.WriteToServer(dtExcel);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
}
}
#endregion
#region
/// <summary>
///
/// </summary>
/// <param name="dbconfig">目标连接字符</param>
/// <param name="tablename">Destination table </ param>
/// <param name="dt">源数据</param>
public static string SqlBulkCopyByDatatable(string tablename, DataTable table, string connStr, SqlConnection m_clsSqlConn)
{
string dataBaseStr = "";
if (tablename.Contains("."))
{
dataBaseStr = tablename.Substring(0, tablename.LastIndexOf(".") + 1);
tablename = tablename.Substring(tablename.LastIndexOf(".") + 1);
}
try
{
string result = "";
SqlBulkCopy sqlBulkCopy = null;
if (m_clsSqlConn != null)
{
sqlBulkCopy = new SqlBulkCopy(m_clsSqlConn);
if (m_clsSqlConn.State == ConnectionState.Closed)
{
m_clsSqlConn.Open();
}
}
else
{
sqlBulkCopy = new SqlBulkCopy(connStr);
}
sqlBulkCopy.DestinationTableName = dataBaseStr + ((tablename.IndexOf("[") > -1 && tablename.IndexOf("]") > -1) ? tablename : "[" + tablename + "]");
sqlBulkCopy.BulkCopyTimeout = 500;
//sqlBulkCopy.BatchSize = 800;
for (int i = 0; i < table.Columns.Count; i++)
{
sqlBulkCopy.ColumnMappings.Add(table.Columns[i].ColumnName, table.Columns[i].ColumnName);
}
if (table.Rows.Count > 0)
{
sqlBulkCopy.WriteToServer(table);
}
else
{
result = "表为空";
}
sqlBulkCopy.Close();
return result;
}
catch (Exception e)
{
return e.Message;
}
finally
{
try
{
if (m_clsSqlConn != null)
{
try
{
if (m_clsSqlConn.State == ConnectionState.Open)
{
m_clsSqlConn.Close();
}
}
catch (Exception)
{
}
}
}
catch (Exception)
{
}
}
}
public static string SqlBulkCopyByDatatable(string tablename, DataTable table, SqlConnection m_clsSqlConn)
{
return SqlBulkCopyByDatatable(tablename, table, string.Empty, m_clsSqlConn);
}
public static string SqlBulkCopyByDatatable(string tablename, DataTable table, string connStr)
{
return SqlBulkCopyByDatatable(tablename, table, connStr, null);
}
public static string SqlBulkCopyByDatatable(string tablename, DataTable table)
{
return SqlBulkCopyByDatatable(tablename, table, DefaultConnString, null);
}
public static string CreateTempTable(string tablename, DataTable table, string connStr)
{
return CreateTempTable(tablename, table, new SqlConnection(connStr));
}
public static string CreateTempTable(string tablename, DataTable table, SqlConnection connStr)
{
try
{
string sqlstr = "CREATE TABLE [" + tablename + "](";
for (int i = 0; i < table.Columns.Count; i++)
{
switch (table.Columns[i].DataType.FullName)
{
case "System.String":
{
sqlstr += "[" + table.Columns[i].ColumnName + "] [nvarchar](4000) NULL,";
}
break;
case "System.Int32":
{
sqlstr += "[" + table.Columns[i].ColumnName + "] [int] NULL,";
}
break;
case "System.Double":
{
sqlstr += "[" + table.Columns[i].ColumnName + "] [numeric](24,2) NULL,";
}
break;
case "System.DateTime":
{
sqlstr += "[" + table.Columns[i].ColumnName + "] [datetime] NULL,";
}
break;
default:
{
sqlstr += "[" + table.Columns[i].ColumnName + "] [nvarchar](4000) NULL,";
}
break;
}
}
sqlstr = sqlstr.Substring(0, sqlstr.Length - 1) + ")";
if (connStr.State != ConnectionState.Open)
{
connStr.Open();
}
SqlCommand cmd = GetSqlCommand(connStr, sqlstr, CommandType.Text, null);
int result = cmd.ExecuteNonQuery();
cmd.Dispose();
return "";
}
catch (Exception e)
{
return e.ToString();
}
}
#endregion
}