一個控制台程序，MSSQL 2008 數據庫，其中一個大表數據超過6000千萬，開發時間有限不可能花很多時間設計、架構。使用控制台一是為了實現高效運行，二是程序是在服務器上定時運行無人干預。要保證程序可維護性和快速開發和程序高效運行，沒時間去分層開發，直接使用了entity framework並結合ado.net對EF進行了擴展。不折騰是因為怕EF有性能問題使用了sqlbuckcopy進行批量插入數據，使用DB FIRST。重構是因為原來是oracle數據庫，數據庫已經改為MSSQL 2008。
1、解決方案、架構
解決方案：
2、業務說明
程序主要業務是讀取指定目錄下面的XML文件，將里面的文件里的記錄整理拼湊為數據庫里對應表的datatable,然后使用SqlBulkCopy批量插入數據庫。文件是遠程計算機通過FTP上傳的。XML里面的記錄和需要存儲的數據庫里對應表的表結構不一致，需要轉換和補全。程序是定時運行，使用操作系統的計划任務進行調度。日志組件使用了log4net，來實現控制台顯示和數據庫記錄日志。
3、關鍵代碼和編碼思路
1、業務邏輯實現
2、EF擴展類
using System.Data;
using System.Data.EntityClient;
using System;
using System.Data.SqlClient;
using System.Configuration;
namespace XXX_App
{
public partial class XXX_DBEntities : global::System.Data.Objects.ObjectContext
{
Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
/// <summary>
/// 使用ado.net執行sqlbulkcopy
/// </summary>
/// <param name="dt"></param>
/// <param name="efConnectStr">webconfig里的數據庫連接字符串</param>
/// <returns></returns>
public bool ExecuteSqlBulkCopy(DataTable dt)
{
string dbConnStr = this.GetEF_ConnectStr2Ado_ConnectStr();
bool result = false;
#region ado.net execute sqlbulkcopy
using (SqlConnection dbConn = new SqlConnection(dbConnStr))
{
try
{
#region 執行sqlbulkcopy
dbConn.Open();
SqlCommand cmd = dbConn.CreateCommand();
cmd.CommandText = "delete sc_productsource_temp";
cmd.ExecuteNonQuery();
new SqlBulkCopy(dbConn)
{
DestinationTableName = "sc_productsource_temp",
BatchSize = dt.Rows.Count,
BulkCopyTimeout = 1800
}.WriteToServer(dt);
#endregion
result = true;
}
catch (Exception ex)
{
result = false;
throw new Exception(ex.Message);
}
finally
{
if (result)
{
#region 臨時表流量明細記錄轉正式 SC_PRODUCTSOURCE
SqlCommand cmd = dbConn.CreateCommand();
cmd.CommandText = " INSERT INTO SC_PRODUCTSOURCE (PRODUCTSOURCEID,FACTORYID,PRDLINEID "+
" ,MACRANDOMCODE ,PRODUCTBATCHIDX ,LASERDNA_CODE ,PRODUCTNO ,PRODUCTNAME,PRODUCTTYPENAME"+
" ,PRODUCTDATE ,PRINTCODEDT ,FACTORYSHIFTNO ,OUTBOX_DNACODE ,VIRTUALBALECODE" +
" ,SENDTONDC_DT,FAC_NO,PRODUCTVERSION) " +
" SELECT NEWID() PRODUCTSOURCEID,FACTORYID,PRDLINEID,MACRANDOMCODE,PRODUCTBATCHIDX " +
" ,LASERDNA_CODE,PRODUCTNO,PRODUCTNAME,PRODUCTTYPENAME,PRODUCTDATE,PRINTCODEDT " +
" ,FACTORYSHIFTNO,OUTBOX_DNACODE,VIRTUALBALECODE,SENDTONDC_DT,FAC_NO,PRODUCTVERSION " +
" FROM sc_productsource_temp";
cmd.ExecuteNonQuery();
#endregion
}
dbConn.Close();
}
}
#endregion
return result;
}
/// <summary>
/// 准備臨時表
/// </summary>
/// <param name="efConnectStr"></param>
/// <returns></returns>
public DataTable GetTmpNewDataTable()
{
return this.GetDbHelperSQL_Instance().Query("select * from sc_productsource_temp where 1=2").Tables[0];
}
/// <summary>
/// 將EF的連接字符串轉為Ado.net的連接字符串
/// </summary>
/// <param name="efConnectStr"></param>
/// <returns></returns>
private string GetEF_ConnectStr2Ado_ConnectStr()
{
string[] tmpStr = config.ConnectionStrings.ConnectionStrings["XXX_DBEntities"].ConnectionString.Split(";".ToCharArray());
string dbConnStr = string.Empty;
if (tmpStr.Length == 8)
{
//拼接出新的可用的ado.net連接字符串
dbConnStr = string.Join(";", new string[] { "Data Source =" + base.Connection.DataSource, tmpStr[3], tmpStr[4], tmpStr[5], tmpStr[6].TrimEnd(new char[] { '"' }) });
return dbConnStr;
}
else
{
return string.Empty;
throw new Exception("請配置數據庫連接方式為：sql認證方式;不支持WinNT集成安全方式。");
}
}
/// <summary>
/// 獲取第一行第一列數據
/// </summary>
/// <param name="efConnectStr"></param>
/// <param name="sqlTxt"></param>
/// <returns></returns>
public string AdoExecuteScalar(string sqlTxt)
{
string dbConnStr = this.GetEF_ConnectStr2Ado_ConnectStr();
using (DbHelperSQL db = new DbHelperSQL(dbConnStr))
{
return db.GetSingle(sqlTxt).ToString();
}
}
public DbHelperSQL GetDbHelperSQL_Instance()
{
string dbConnStr = this.GetEF_ConnectStr2Ado_ConnectStr();
return new DbHelperSQL(dbConnStr);
}
}
}
3、修改過的動軟DbHelper，Ado.net存儲類
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Data;
using System.Data.SqlClient;
using System.Configuration;
using System.Data.Common;
using System.Collections.Generic;
namespace XXX_App
{
/// <summary>
/// 數據訪問抽象基礎類
/// Copyright (C) Maticsoft
/// </summary>
public class DbHelperSQL : IDisposable
{
//數據庫連接字符串(web.config來配置)，多數據庫可使用DbHelperSQLP來實現.
private string connectionString;
/// <summary>
/// 數據庫連接字符串
/// </summary>
public string ConnectionString
{
get { return connectionString; }
}
public DbHelperSQL(string connStr)
{
connectionString = connStr;
}
#region 公用方法
/// <summary>
/// 判斷是否存在某表的某個字段
/// </summary>
/// <param name="tableName">表名稱</param>
/// <param name="columnName">列名稱</param>
/// <returns>是否存在</returns>
public bool ColumnExists(string tableName, string columnName)
{
string sql = "select count(1) from syscolumns where [id]=object_id('" + tableName + "') and [name]='" + columnName + "'";
object res = GetSingle(sql);
if (res == null)
{
return false;
}
return Convert.ToInt32(res) > 0;
}
public int GetMaxID(string FieldName, string TableName)
{
string strsql = "select max(" + FieldName + ")+1 from " + TableName;
object obj = GetSingle(strsql);
if (obj == null)
{
return 1;
}
else
{
return int.Parse(obj.ToString());
}
}
public bool Exists(string strSql)
{
object obj = GetSingle(strSql);
int cmdresult;
if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
{
cmdresult = 0;
}
else
{
cmdresult = int.Parse(obj.ToString()); //也可能=0
}
if (cmdresult == 0)
{
return false;
}
else
{
return true;
}
}
/// <summary>
/// 表是否存在
/// </summary>
/// <param name="TableName"></param>
/// <returns></returns>
public bool TabExists(string TableName)
{
string strsql = "select count(*) from sysobjects where id = object_id(N'[" + TableName + "]') and OBJECTPROPERTY(id, N'IsUserTable') = 1";
//string strsql = "SELECT count(*) FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[" + TableName + "]') AND type in (N'U')";
object obj = GetSingle(strsql);
int cmdresult;
if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
{
cmdresult = 0;
}
else
{
cmdresult = int.Parse(obj.ToString());
}
if (cmdresult == 0)
{
return false;
}
else
{
return true;
}
}
public bool Exists(string strSql, params SqlParameter[] cmdParms)
{
object obj = GetSingle(strSql, cmdParms);
int cmdresult;
if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
{
cmdresult = 0;
}
else
{
cmdresult = int.Parse(obj.ToString());
}
if (cmdresult == 0)
{
return false;
}
else
{
return true;
}
}
#endregion
#region 執行簡單SQL語句
/// <summary>
/// 執行SQL語句，返回影響的記錄數
/// </summary>
/// <param name="SQLString">SQL語句</param>
/// <returns>影響的記錄數</returns>
public int ExecuteSql(string SQLString)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
using (SqlCommand cmd = new SqlCommand(SQLString, connection))
{
try
{
connection.Open();
int rows = cmd.ExecuteNonQuery();
return rows;
}
catch (System.Data.SqlClient.SqlException e)
{
connection.Close();
throw e;
}
}
}
}
public int ExecuteSqlByTime(string SQLString, int Times)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
using (SqlCommand cmd = new SqlCommand(SQLString, connection))
{
try
{
connection.Open();
cmd.CommandTimeout = Times;
int rows = cmd.ExecuteNonQuery();
return rows;
}
catch (System.Data.SqlClient.SqlException e)
{
connection.Close();
throw e;
}
}
}
}
/// <summary>
/// 執行多條SQL語句，實現數據庫事務。
/// </summary>
/// <param name="SQLStringList">多條SQL語句</param>
public int ExecuteSqlTran(List<String> SQLStringList)
{
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
SqlCommand cmd = new SqlCommand();
cmd.Connection = conn;
SqlTransaction tx = conn.BeginTransaction();
cmd.Transaction = tx;
try
{
int count = 0;
for (int n = 0; n < SQLStringList.Count; n++)
{
string strsql = SQLStringList[n];
if (strsql.Trim().Length > 1)
{
cmd.CommandText = strsql;
count += cmd.ExecuteNonQuery();
}
}
tx.Commit();
return count;
}
catch
{
tx.Rollback();
return 0;
}
}
}
/// <summary>
/// 執行帶一個存儲過程參數的的SQL語句。
/// </summary>
/// <param name="SQLString">SQL語句</param>
/// <param name="content">參數內容,比如一個字段是格式復雜的文章，有特殊符號，可以通過這個方式添加</param>
/// <returns>影響的記錄數</returns>
public int ExecuteSql(string SQLString, string content)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
SqlCommand cmd = new SqlCommand(SQLString, connection);
System.Data.SqlClient.SqlParameter myParameter = new System.Data.SqlClient.SqlParameter("@content", SqlDbType.NText);
myParameter.Value = content;
cmd.Parameters.Add(myParameter);
try
{
connection.Open();
int rows = cmd.ExecuteNonQuery();
return rows;
}
catch (System.Data.SqlClient.SqlException e)
{
throw e;
}
finally
{
cmd.Dispose();
connection.Close();
}
}
}
/// <summary>
/// 執行帶一個存儲過程參數的的SQL語句。
/// </summary>
/// <param name="SQLString">SQL語句</param>
/// <param name="content">參數內容,比如一個字段是格式復雜的文章，有特殊符號，可以通過這個方式添加</param>
/// <returns>影響的記錄數</returns>
public object ExecuteSqlGet(string SQLString, string content)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
SqlCommand cmd = new SqlCommand(SQLString, connection);
System.Data.SqlClient.SqlParameter myParameter = new System.Data.SqlClient.SqlParameter("@content", SqlDbType.NText);
myParameter.Value = content;
cmd.Parameters.Add(myParameter);
try
{
connection.Open();
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 e;
}
finally
{
cmd.Dispose();
connection.Close();
}
}
}
/// <summary>
/// 向數據庫里插入圖像格式的字段(和上面情況類似的另一種實例)
/// </summary>
/// <param name="strSQL">SQL語句</param>
/// <param name="fs">圖像字節,數據庫的字段類型為image的情況</param>
/// <returns>影響的記錄數</returns>
public int ExecuteSqlInsertImg(string strSQL, byte[] fs)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
SqlCommand cmd = new SqlCommand(strSQL, connection);
System.Data.SqlClient.SqlParameter myParameter = new System.Data.SqlClient.SqlParameter("@fs", SqlDbType.Image);
myParameter.Value = fs;
cmd.Parameters.Add(myParameter);
try
{
connection.Open();
int rows = cmd.ExecuteNonQuery();
return rows;
}
catch (System.Data.SqlClient.SqlException e)
{
throw e;
}
finally
{
cmd.Dispose();
connection.Close();
}
}
}
/// <summary>
/// 執行一條計算查詢結果語句，返回查詢結果（object）。
/// </summary>
/// <param name="SQLString">計算查詢結果語句</param>
/// <returns>查詢結果（object）</returns>
public object GetSingle(string SQLString)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
using (SqlCommand cmd = new SqlCommand(SQLString, connection))
{
try
{
connection.Open();
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)
{
connection.Close();
throw e;
}
}
}
}
public object GetSingle(string SQLString, int Times)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
using (SqlCommand cmd = new SqlCommand(SQLString, connection))
{
try
{
connection.Open();
cmd.CommandTimeout = Times;
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)
{
connection.Close();
throw e;
}
}
}
}
/// <summary>
/// 執行查詢語句，返回SqlDataReader ( 注意：調用該方法后，一定要對SqlDataReader進行Close )
/// </summary>
/// <param name="strSQL">查詢語句</param>
/// <returns>SqlDataReader</returns>
public SqlDataReader ExecuteReader(string strSQL)
{
SqlConnection connection = new SqlConnection(connectionString);
SqlCommand cmd = new SqlCommand(strSQL, connection);
try
{
connection.Open();
SqlDataReader myReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
return myReader;
}
catch (System.Data.SqlClient.SqlException e)
{
throw e;
}
}
/// <summary>
/// 執行查詢語句，返回DataSet
/// </summary>
/// <param name="SQLString">查詢語句</param>
/// <returns>DataSet</returns>
public DataSet Query(string SQLString)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
DataSet ds = new DataSet();
try
{
connection.Open();
SqlDataAdapter command = new SqlDataAdapter(SQLString, connection);
command.Fill(ds, "ds");
}
catch (System.Data.SqlClient.SqlException ex)
{
throw new Exception(ex.Message);
}
return ds;
}
}
public DataSet Query(string SQLString, int Times)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
DataSet ds = new DataSet();
try
{
connection.Open();
SqlDataAdapter command = new SqlDataAdapter(SQLString, connection);
command.SelectCommand.CommandTimeout = Times;
command.Fill(ds, "ds");
}
catch (System.Data.SqlClient.SqlException ex)
{
throw new Exception(ex.Message);
}
return ds;
}
}
#endregion
#region 執行帶參數的SQL語句
/// <summary>
/// 執行SQL語句，返回影響的記錄數
/// </summary>
/// <param name="SQLString">SQL語句</param>
/// <returns>影響的記錄數</returns>
public int ExecuteSql(string SQLString, params SqlParameter[] cmdParms)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
using (SqlCommand cmd = new SqlCommand())
{
try
{
PrepareCommand(cmd, connection, null, SQLString, cmdParms);
int rows = cmd.ExecuteNonQuery();
cmd.Parameters.Clear();
return rows;
}
catch (System.Data.SqlClient.SqlException e)
{
throw e;
}
}
}
}
/// <summary>
/// 執行多條SQL語句，實現數據庫事務。
/// </summary>
/// <param name="SQLStringList">SQL語句的哈希表（key為sql語句，value是該語句的SqlParameter[]）</param>
public void ExecuteSqlTran(Hashtable SQLStringList)
{
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
using (SqlTransaction trans = conn.BeginTransaction())
{
SqlCommand cmd = new SqlCommand();
try
{
//循環
foreach (DictionaryEntry myDE in SQLStringList)
{
string cmdText = myDE.Key.ToString();
SqlParameter[] cmdParms = (SqlParameter[])myDE.Value;
PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
int val = cmd.ExecuteNonQuery();
cmd.Parameters.Clear();
}
trans.Commit();
}
catch
{
trans.Rollback();
throw;
}
}
}
}
/// <summary>
/// 執行多條SQL語句，實現數據庫事務。
/// </summary>
/// <param name="SQLStringList">SQL語句的哈希表（key為sql語句，value是該語句的SqlParameter[]）</param>
public int ExecuteSqlTran(System.Collections.Generic.List<CommandInfo> cmdList)
{
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
using (SqlTransaction trans = conn.BeginTransaction())
{
SqlCommand cmd = new SqlCommand();
try
{
int count = 0;
//循環
foreach (CommandInfo myDE in cmdList)
{
string cmdText = myDE.CommandText;
SqlParameter[] cmdParms = (SqlParameter[])myDE.Parameters;
PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
if (myDE.EffentNextType == EffentNextType.WhenHaveContine || myDE.EffentNextType == EffentNextType.WhenNoHaveContine)
{
if (myDE.CommandText.ToLower().IndexOf("count(") == -1)
{
trans.Rollback();
return 0;
}
object obj = cmd.ExecuteScalar();
bool isHave = false;
if (obj == null && obj == DBNull.Value)
{
isHave = false;
}
isHave = Convert.ToInt32(obj) > 0;
if (myDE.EffentNextType == EffentNextType.WhenHaveContine && !isHave)
{
trans.Rollback();
return 0;
}
if (myDE.EffentNextType == EffentNextType.WhenNoHaveContine && isHave)
{
trans.Rollback();
return 0;
}
continue;
}
int val = cmd.ExecuteNonQuery();
count += val;
if (myDE.EffentNextType == EffentNextType.ExcuteEffectRows && val == 0)
{
trans.Rollback();
return 0;
}
cmd.Parameters.Clear();
}
trans.Commit();
return count;
}
catch
{
trans.Rollback();
throw;
}
}
}
}
/// <summary>
/// 執行多條SQL語句，實現數據庫事務。
/// </summary>
/// <param name="SQLStringList">SQL語句的哈希表（key為sql語句，value是該語句的SqlParameter[]）</param>
public void ExecuteSqlTranWithIndentity(System.Collections.Generic.List<CommandInfo> SQLStringList)
{
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
using (SqlTransaction trans = conn.BeginTransaction())
{
SqlCommand cmd = new SqlCommand();
try
{
int indentity = 0;
//循環
foreach (CommandInfo myDE in SQLStringList)
{
string cmdText = myDE.CommandText;
SqlParameter[] cmdParms = (SqlParameter[])myDE.Parameters;
foreach (SqlParameter q in cmdParms)
{
if (q.Direction == ParameterDirection.InputOutput)
{
q.Value = indentity;
}
}
PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
int val = cmd.ExecuteNonQuery();
foreach (SqlParameter q in cmdParms)
{
if (q.Direction == ParameterDirection.Output)
{
indentity = Convert.ToInt32(q.Value);
}
}
cmd.Parameters.Clear();
}
trans.Commit();
}
catch
{
trans.Rollback();
throw;
}
}
}
}
/// <summary>
/// 執行多條SQL語句，實現數據庫事務。
/// </summary>
/// <param name="SQLStringList">SQL語句的哈希表（key為sql語句，value是該語句的SqlParameter[]）</param>
public void ExecuteSqlTranWithIndentity(Hashtable SQLStringList)
{
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
using (SqlTransaction trans = conn.BeginTransaction())
{
SqlCommand cmd = new SqlCommand();
try
{
int indentity = 0;
//循環
foreach (DictionaryEntry myDE in SQLStringList)
{
string cmdText = myDE.Key.ToString();
SqlParameter[] cmdParms = (SqlParameter[])myDE.Value;
foreach (SqlParameter q in cmdParms)
{
if (q.Direction == ParameterDirection.InputOutput)
{
q.Value = indentity;
}
}
PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
int val = cmd.ExecuteNonQuery();
foreach (SqlParameter q in cmdParms)
{
if (q.Direction == ParameterDirection.Output)
{
indentity = Convert.ToInt32(q.Value);
}
}
cmd.Parameters.Clear();
}
trans.Commit();
}
catch
{
trans.Rollback();
throw;
}
}
}
}
/// <summary>
/// 執行一條計算查詢結果語句，返回查詢結果（object）。
/// </summary>
/// <param name="SQLString">計算查詢結果語句</param>
/// <returns>查詢結果（object）</returns>
public object GetSingle(string SQLString, params SqlParameter[] cmdParms)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
using (SqlCommand cmd = new SqlCommand())
{
try
{
PrepareCommand(cmd, connection, null, SQLString, cmdParms);
object obj = cmd.ExecuteScalar();
cmd.Parameters.Clear();
if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
{
return null;
}
else
{
return obj;
}
}
catch (System.Data.SqlClient.SqlException e)
{
throw e;
}
}
}
}
/// <summary>
/// 執行查詢語句，返回SqlDataReader ( 注意：調用該方法后，一定要對SqlDataReader進行Close )
/// </summary>
/// <param name="strSQL">查詢語句</param>
/// <returns>SqlDataReader</returns>
public SqlDataReader ExecuteReader(string SQLString, params SqlParameter[] cmdParms)
{
SqlConnection connection = new SqlConnection(connectionString);
SqlCommand cmd = new SqlCommand();
try
{
PrepareCommand(cmd, connection, null, SQLString, cmdParms);
SqlDataReader myReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
cmd.Parameters.Clear();
return myReader;
}
catch (System.Data.SqlClient.SqlException e)
{
throw e;
}
}
/// <summary>
/// 執行查詢語句，返回DataSet
/// </summary>
/// <param name="SQLString">查詢語句</param>
/// <returns>DataSet</returns>
public DataSet Query(string SQLString, params SqlParameter[] cmdParms)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
SqlCommand cmd = new SqlCommand();
PrepareCommand(cmd, connection, null, SQLString, cmdParms);
using (SqlDataAdapter da = new SqlDataAdapter(cmd))
{
DataSet ds = new DataSet();
try
{
da.Fill(ds, "ds");
cmd.Parameters.Clear();
}
catch (System.Data.SqlClient.SqlException ex)
{
throw new Exception(ex.Message);
}
return ds;
}
}
}
private void PrepareCommand(SqlCommand cmd, SqlConnection conn, SqlTransaction trans, 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 = 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 存儲過程操作
/// <summary>
/// 執行存儲過程，返回SqlDataReader ( 注意：調用該方法后，一定要對SqlDataReader進行Close )
/// </summary>
/// <param name="storedProcName">存儲過程名</param>
/// <param name="parameters">存儲過程參數</param>
/// <returns>SqlDataReader</returns>
public SqlDataReader RunProcedure(string storedProcName, IDataParameter[] parameters)
{
SqlConnection connection = new SqlConnection(connectionString);
SqlDataReader returnReader;
connection.Open();
SqlCommand command = BuildQueryCommand(connection, storedProcName, parameters);
command.CommandType = CommandType.StoredProcedure;
returnReader = command.ExecuteReader(CommandBehavior.CloseConnection);
return returnReader;
}
/// <summary>
/// 執行存儲過程
/// </summary>
/// <param name="storedProcName">存儲過程名</param>
/// <param name="parameters">存儲過程參數</param>
/// <param name="tableName">DataSet結果中的表名</param>
/// <returns>DataSet</returns>
public DataSet RunProcedure(string storedProcName, IDataParameter[] parameters, string tableName)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
DataSet dataSet = new DataSet();
connection.Open();
SqlDataAdapter sqlDA = new SqlDataAdapter();
sqlDA.SelectCommand = BuildQueryCommand(connection, storedProcName, parameters);
sqlDA.Fill(dataSet, tableName);
connection.Close();
return dataSet;
}
}
public DataSet RunProcedure(string storedProcName, IDataParameter[] parameters, string tableName, int Times)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
DataSet dataSet = new DataSet();
connection.Open();
SqlDataAdapter sqlDA = new SqlDataAdapter();
sqlDA.SelectCommand = BuildQueryCommand(connection, storedProcName, parameters);
sqlDA.SelectCommand.CommandTimeout = Times;
sqlDA.Fill(dataSet, tableName);
connection.Close();
return dataSet;
}
}
/// <summary>
/// 構建 SqlCommand 對象(用來返回一個結果集，而不是一個整數值)
/// </summary>
/// <param name="connection">數據庫連接</param>
/// <param name="storedProcName">存儲過程名</param>
/// <param name="parameters">存儲過程參數</param>
/// <returns>SqlCommand</returns>
private SqlCommand BuildQueryCommand(SqlConnection connection, string storedProcName, IDataParameter[] parameters)
{
SqlCommand command = new SqlCommand(storedProcName, connection);
command.CommandType = CommandType.StoredProcedure;
foreach (SqlParameter parameter in parameters)
{
if (parameter != null)
{
// 檢查未分配值的輸出參數,將其分配以DBNull.Value.
if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) &&
(parameter.Value == null))
{
parameter.Value = DBNull.Value;
}
command.Parameters.Add(parameter);
}
}
return command;
}
/// <summary>
/// 執行存儲過程，返回影響的行數
/// </summary>
/// <param name="storedProcName">存儲過程名</param>
/// <param name="parameters">存儲過程參數</param>
/// <param name="rowsAffected">影響的行數</param>
/// <returns></returns>
public int RunProcedure(string storedProcName, IDataParameter[] parameters, out int rowsAffected)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
int result;
connection.Open();
SqlCommand command = BuildIntCommand(connection, storedProcName, parameters);
rowsAffected = command.ExecuteNonQuery();
result = (int)command.Parameters["ReturnValue"].Value;
return result;
}
}
/// <summary>
/// 創建 SqlCommand 對象實例(用來返回一個整數值)
/// </summary>
/// <param name="storedProcName">存儲過程名</param>
/// <param name="parameters">存儲過程參數</param>
/// <returns>SqlCommand 對象實例</returns>
private SqlCommand BuildIntCommand(SqlConnection connection, string storedProcName, IDataParameter[] parameters)
{
SqlCommand command = BuildQueryCommand(connection, storedProcName, parameters);
command.Parameters.Add(new SqlParameter("ReturnValue",
SqlDbType.Int, 4, ParameterDirection.ReturnValue,
false, 0, 0, string.Empty, DataRowVersion.Default, null));
return command;
}
#endregion
#region IDisposable 成員
public void Dispose()
{
connectionString = string.Empty;
}
#endregion
}
}
4、EF的使用和擴展類的使用
/// <summary>
/// 解析並入數據庫
/// </summary>
/// <param name="ds"></param>
/// <param name="factoryNo"></param>
/// <param name="db"></param>
public static void XmlFile2DataBase(ref DataSet ds, string factoryNo, XXX_DBEntities db)
{
var dtProductLine = ds.Tables["line"];
var dtLinkData = ds.Tables["bc"];
//出現過xml缺少字段的情況，84K大小的zip包里的xml bc表只有3個字段，沒有批號和日期。如果是這個文件跳過。
if (dtLinkData.Columns.Count != 5)
return;
string outBoxNo = dtLinkData.Rows[0]["out"].ToString();
//檢測是否有重復記錄，有則忽略,該文件只要有一個箱碼重復，說明此文件是重復上傳。事務控制到文件。
decimal cnt = decimal.Parse(db.AdoExecuteScalar(string.Format("select count(*) as cnt from SC_PRODUCTSOURCE s where s.outbox_dnacode = '{0}'", outBoxNo)).ToString());
if (cnt > 0)
{
return;
}
var dt = db.GetTmpNewDataTable();
#region 准備臨時數據,並使用OracleBulkCopy批量插入，每產線插一次
foreach (DataRow dr in dtProductLine.Rows)
{
if (!string.IsNullOrEmpty(dr["pid"].ToString()))
{
dt.Rows.Clear();
int prdCode = int.Parse(dr["psid"].ToString());
var product = db.ProductInfo.Where(p => p.PRODUCT_CODE == prdCode).FirstOrDefault();
string prdName = product.PRODUCT_CNNAME;
string prdBrandName = product.PRD_BRAND;
DataView dv = dtLinkData.DefaultView;
dv.RowFilter = string.Format("data_Id={0}", dr["line_Id"].ToString());
foreach (DataRowView itemRow in dv)
{
string[] itemList = itemRow["bc_Text"].ToString().Split(",".ToCharArray());
string batchNo = itemRow["batchno"].ToString();
string outBoxNoSub = itemRow["out"].ToString();
for (int idx = 0; idx < itemList.Length; idx++)
{
DateTime dtProduct = new DateTime(1901, 01, 01);
DateTime.TryParse(itemRow["maketime"].ToString(), out dtProduct);
var drProductLinkData = dt.NewRow();
#region 一盒的生產數據
drProductLinkData["PRODUCTSOURCEID"] = Guid.NewGuid().ToString("N").ToUpper();
drProductLinkData["FACTORYID"] = factoryNo;
drProductLinkData["PRDLINEID"] = dr["no"].ToString();
drProductLinkData["MACRANDOMCODE"] = itemList[idx];
drProductLinkData["PRODUCTBATCHIDX"] = batchNo;
drProductLinkData["LASERDNA_CODE"] = "";
drProductLinkData["PRODUCTNO"] = int.Parse(dr["psid"].ToString());
drProductLinkData["PRODUCTNAME"] = prdName;
drProductLinkData["PRODUCTTYPENAME"] = prdBrandName;
drProductLinkData["PRODUCTDATE"] = dtProduct;
drProductLinkData["PRINTCODEDT"] = dtProduct;
drProductLinkData["FACTORYSHIFTNO"] = "";
drProductLinkData["OUTBOX_DNACODE"] = outBoxNoSub;
drProductLinkData["VIRTUALBALECODE"] = "";
drProductLinkData["SENDTONDC_DT"] = DateTime.Now;
drProductLinkData["FAC_NO"] = factoryNo;
drProductLinkData["PRODUCTVERSION"] = DateTime.Now;
#endregion
dt.Rows.Add(drProductLinkData);
}
}
if (dt.Rows.Count > 0)
{
db.ExecuteSqlBulkCopy(dt);
}
}
}
#endregion
}
4、程序運行效果及截圖
1、日志
2、截圖
暫無，因為程序效率太高，一時沒有文件需要解析了。呵呵
結束語：做項目不需要定勢的思維，比如一定要分層架構，一定要什么牛X的技術，一定要高可擴展性、高可重用性。小項目，快速、穩定、高效和可維護性才是需要考量的要點。天下武功，唯快不破。呵呵...