1、引用程序集System.Data.SQLite
2、創建數據訪問基礎類(基於SQLite) DbHelperSqlite
3、創建數據庫操作類DataHelper
4、創建共同函數類CommonHelper
/// <summary>
/// 數據訪問基礎類(基於SQLite)
/// </summary>
public class DbHelperSqlite
{
/// <summary>
/// 提示信息
/// </summary>
public static string StrLastError = string.Empty;
/// <summary>
/// 命令
/// </summary>
public enum SdaCmd
{
/// <summary>
/// 查詢
/// </summary>
Select,
/// <summary>
/// 刪除
/// </summary>
Delete,
/// <summary>
/// 更新
/// </summary>
Update,
/// <summary>
/// 插入
/// </summary>
Insert
}
/// <summary>
/// 連接字符串
/// </summary>
/// <value>
/// The connection string.
/// </value>
public static string ConnString = @"Data Source=(localdb)\MSSQLLocalDB;Initial Catalog=MoviesDemo;Integrated Security=True;";
/// <summary>
/// 創建數據庫文件及數據庫表
/// </summary>
/// <param name="strDbpath">數據庫文件包含文件名的全路徑信息</param>
/// <param name="sql">創建數據庫表的SQL語句</param>
/// <param name="alwaysCreate">if set to <c>true</c> [always create].</param>
public static void CreateDbTable(string strDbpath, string sql, bool alwaysCreate = false)
{
if (!File.Exists(strDbpath) || alwaysCreate)
{
//ConnString = $"Data Source={strDbpath};Pooling=false;FailIfMissing=false;syncchronous=normal;";
SQLiteConnection conn = new SQLiteConnection(ConnString);
SQLiteCommand cmd = new SQLiteCommand();
conn.Open();
cmd.CommandText = sql;
cmd.Connection = conn;
cmd.ExecuteNonQuery();
conn.Close();
FileInfo fileInfo = new FileInfo(strDbpath);
if (fileInfo.Length == 0)
{
File.Delete(strDbpath);
conn = new SQLiteConnection(ConnString);
cmd = new SQLiteCommand();
conn.Open();
cmd.CommandText = sql;
cmd.Connection = conn;
cmd.ExecuteNonQuery();
conn.Close();
}
}
else
{
ConnString = $"Data Source={strDbpath};Pooling=false;FailIfMissing=false;syncchronous=normal;";
}
}
/// <summary>
/// DataAdapter方法 返回DataSet數據集
/// </summary>
/// <param name="sSqlCmd">SQL語句</param>
/// <param name="command">操作參數 枚舉類型</param>
/// <param name="tabName">DataSet中的表名</param>
/// <param name="paraList">命令參數集合</param>
/// <returns></returns>
public static DataSet DataAdapter(string sSqlCmd, SdaCmd command, string tabName, params SQLiteParameter[] paraList)
{
DataSet ds = new DataSet();
try
{
SQLiteConnection con = new SQLiteConnection(ConnString);
SQLiteCommand cmd = new SQLiteCommand
{
Connection = con,
CommandText = sSqlCmd
};
if (paraList != null)
{
cmd.CommandType = CommandType.Text;
foreach (SQLiteParameter para in paraList)
{
cmd.Parameters.Add(para);
}
}
SQLiteDataAdapter sda = new SQLiteDataAdapter();
switch (command)
{
case SdaCmd.Select:
sda.SelectCommand = cmd;
break;
case SdaCmd.Insert:
sda.InsertCommand = cmd;
break;
case SdaCmd.Update:
sda.UpdateCommand = cmd;
break;
case SdaCmd.Delete:
sda.DeleteCommand = cmd;
break;
}
sda.Fill(ds, tabName);
con.Close();
SQLiteConnection.ClearAllPools();
}
catch (Exception ex)
{
LogHelper.Error($"執行sql輸出錯誤：{ex.Message}\r\nSql語句：{sSqlCmd}");
StrLastError = ex.Message;
}
return ds;
}
/// <summary>
/// 執行一個查詢語句，返回一個包含查詢結果的DataTable
/// </summary>
/// <param name="strSql">要執行的查詢語句</param>
/// <param name="parameters">執行SQL查詢語句所需要的參數，參數必須以它們在SQL語句中的順序爲準</param>
/// <returns></returns>
public static DataTable ExecuteDataTable(string strSql, SQLiteParameter[] parameters)
{
try
{
using (SQLiteConnection connection = new SQLiteConnection(ConnString))
{
using (SQLiteCommand command = new SQLiteCommand(strSql, connection))
{
if (parameters != null)
{
command.Parameters.AddRange(parameters);
}
SQLiteDataAdapter adapter = new SQLiteDataAdapter(command);
DataTable data = new DataTable();
adapter.Fill(data);
SQLiteConnection.ClearAllPools();
return data;
}
}
}
catch (Exception ex)
{
LogHelper.Error($"執行sql輸出錯誤：{ex.Message}\r\nSql語句：{strSql}");
StrLastError = ex.Message;
return null;
}
}
/// <summary>
/// 執行一個查詢語句，返回一個包含查詢結果的DataTable
/// </summary>
/// <param name="strSql">要執行的查詢語句</param>
/// <returns></returns>
public static DataTable ExecuteDataTable(string strSql)
{
try
{
using (SQLiteConnection connection = new SQLiteConnection(ConnString))
{
using (SQLiteCommand command = new SQLiteCommand(strSql, connection))
{
SQLiteDataAdapter adapter = new SQLiteDataAdapter(command);
DataTable data = new DataTable("ResultData");
adapter.Fill(data);
SQLiteConnection.ClearAllPools();
return data;
}
}
}
catch (Exception ex)
{
LogHelper.Error($"執行sql輸出錯誤：{ex.Message}\r\nSql語句：{strSql}");
StrLastError = ex.Message;
return null;
}
}
/// <summary>
/// 對SQLite數據庫執行增刪改操作，返回受影響的行數。
/// </summary>
/// <param name="strSql">要執行的增刪改的SQL語句</param>
/// <param name="parameters">>執行增刪改語句所需要的參數，參數必須以它們在SQL語句中的順序爲準</param>
/// <returns></returns>
public static int ExecuteNonQuery(string strSql, SQLiteParameter[] parameters)
{
try
{
int affectedRows;
using (SQLiteConnection connection = new SQLiteConnection(ConnString))
{
connection.Open();
using (DbTransaction transaction = connection.BeginTransaction())
{
using (SQLiteCommand command = new SQLiteCommand(connection))
{
command.CommandText = strSql;
if (parameters != null && parameters.Length > 0)
{
command.Parameters.AddRange(parameters);
}
affectedRows = command.ExecuteNonQuery();
}
transaction.Commit();
}
}
SQLiteConnection.ClearAllPools();
return affectedRows;
}
catch (Exception ex)
{
LogHelper.Error($"執行sql輸出錯誤：{ex.Message}\r\nSql語句：{strSql}");
StrLastError = ex.Message;
return 0;
}
}
/// <summary>
/// 對SQLite數據庫執行增刪改操作，返回受影響的行數。
/// </summary>
/// <param name="strSql">要執行的增刪改的SQL語句</param>
/// <returns></returns>
public static int ExecuteNonQuery(string strSql)
{
try
{
int affectedRows;
using (SQLiteConnection connection = new SQLiteConnection(ConnString))
{
connection.Open();
using (DbTransaction transaction = connection.BeginTransaction())
{
using (SQLiteCommand command = new SQLiteCommand(connection))
{
command.CommandText = strSql;
affectedRows = command.ExecuteNonQuery();
}
transaction.Commit();
}
}
SQLiteConnection.ClearAllPools();
return affectedRows;
}
catch (Exception ex)
{
LogHelper.Error($"執行sql輸出錯誤：{ex.Message}\r\nSql語句：{strSql}");
StrLastError = ex.Message;
return 0;
}
}
/// <summary>
/// 執行一個查詢語句，返回一個關聯的SQLiteDataReader實例
/// </summary>
/// <param name="strSql">要執行的查詢語句</param>
/// <param name="parameters">執行SQL查詢語句所需要的參數，參數必須以它們在SQL語句中的順序爲準</param>
/// <returns></returns>
public static SQLiteDataReader ExecuteReader(string strSql, SQLiteParameter[] parameters)
{
try
{
using (SQLiteConnection connection = new SQLiteConnection(ConnString))
{
SQLiteCommand command = new SQLiteCommand(strSql, connection);
if (parameters != null)
{
command.Parameters.AddRange(parameters);
}
connection.Open();
return command.ExecuteReader(CommandBehavior.CloseConnection);
}
}
catch (Exception ex)
{
LogHelper.Error($"執行sql輸出錯誤：{ex.Message}\r\nSql語句：{strSql}");
StrLastError = ex.Message;
return null;
}
}
/// <summary>
/// 執行一個查詢語句，返回一個關聯的SQLiteDataReader實例
/// </summary>
/// <param name="strSql">要執行的查詢語句</param>
/// <returns></returns>
public static SQLiteDataReader ExecuteReader(string strSql)
{
try
{
using (SQLiteConnection connection = new SQLiteConnection(ConnString))
{
SQLiteCommand command = new SQLiteCommand(strSql, connection);
connection.Open();
return command.ExecuteReader(CommandBehavior.CloseConnection);
}
}
catch (Exception ex)
{
LogHelper.Error($"執行sql輸出錯誤：{ex.Message}\r\nSql語句：{strSql}");
StrLastError = ex.Message;
return null;
}
}
/// <summary>
/// 執行一個查詢語句，返回查詢結果的第一行第一列
/// </summary>
/// <param name="strSql">要執行的查詢語句</param>
/// <param name="parameters">執行SQL查詢語句所需要的參數，參數必須以它們在SQL語句中的順序爲準</param>
/// <returns></returns>
public static object ExecuteScalar(string strSql, SQLiteParameter[] parameters)
{
try
{
using (SQLiteConnection connection = new SQLiteConnection(ConnString))
{
using (SQLiteCommand command = new SQLiteCommand(strSql, connection))
{
if (parameters != null)
{
command.Parameters.AddRange(parameters);
}
SQLiteDataAdapter adapter = new SQLiteDataAdapter(command);
DataTable data = new DataTable();
adapter.Fill(data);
SQLiteConnection.ClearAllPools();
return data;
}
}
}
catch (Exception ex)
{
LogHelper.Error($"執行sql輸出錯誤：{ex.Message}\r\nSql語句：{strSql}");
StrLastError = ex.Message;
return null;
}
}
/// <summary>
/// 執行一個查詢語句，返回查詢結果的第一行第一列
/// </summary>
/// <param name="strSql">要執行的查詢語句</param>
/// <returns></returns>
public static object ExecuteScalar(string strSql)
{
try
{
using (SQLiteConnection connection = new SQLiteConnection(ConnString))
{
using (SQLiteCommand command = new SQLiteCommand(strSql, connection))
{
SQLiteDataAdapter adapter = new SQLiteDataAdapter(command);
DataTable data = new DataTable();
adapter.Fill(data);
SQLiteConnection.ClearAllPools();
return data;
}
}
}
catch (Exception ex)
{
LogHelper.Error($"執行sql輸出錯誤：{ex.Message}\r\nSql語句：{strSql}");
StrLastError = ex.Message;
return null;
}
}
/// <summary>
/// 執行多條SQL語句，實現數據庫事務。
/// </summary>
/// <param name="sqlStringList">SQL語句的哈希表（key爲strSql語句，value是該語句的SQLiteParameter[]）</param>
/// <returns></returns>
public static bool ExecuteSqlTran(Hashtable sqlStringList)
{
SQLiteConnection conn = new SQLiteConnection(ConnString);
conn.Open();
using (SQLiteTransaction trans = conn.BeginTransaction())
{
SQLiteCommand cmd = new SQLiteCommand();
try
{
foreach (DictionaryEntry myDe in sqlStringList)
{
string cmdText = myDe.Key.ToString();
SQLiteParameter[] cmdParms = (SQLiteParameter[])myDe.Value;
PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
cmd.ExecuteNonQuery();
cmd.Parameters.Clear();
}
trans.Commit();
return true;
}
catch (Exception ex)
{
trans.Rollback();
StrLastError = ex.Message;
LogHelper.Error($"執行sql輸出錯誤：{ex.Message}\r\nSql語句：{sqlStringList}");
return false;
}
finally
{
conn.Close();
}
}
}
/// <summary>
/// 執行壓縮數據庫
/// </summary>
public static void ExecuteZip()
{
using (SQLiteConnection connection = new SQLiteConnection(ConnString))
{
using (SQLiteCommand cmd = new SQLiteCommand("VACUUM", connection))
{
try
{
connection.Open();
cmd.ExecuteNonQuery();
}
catch (SQLiteException e)
{
connection.Close();
StrLastError = e.Message;
}
}
}
}
/// <summary>
/// 取dataset
/// </summary>
/// <param name="strSql">strSql語句</param>
/// <returns>
/// 返回dataset
/// </returns>
public static DataSet GetDataSet(string strSql)
{
DataSet ds = null;
try
{
using (SQLiteConnection connection = new SQLiteConnection(ConnString))
{
using (SQLiteCommand cmd = new SQLiteCommand(strSql, connection))
{
try
{
SQLiteDataAdapter dao = new SQLiteDataAdapter(cmd);
ds = new DataSet();
dao.Fill(ds);
connection.Close();
}
catch (SQLiteException e)
{
connection.Close();
StrLastError = e.Message;
}
}
}
}
catch (Exception ex)
{
StrLastError = ex.Message;
LogHelper.Error($"執行sql輸出錯誤：{ex.Message}\r\nSql語句：{strSql}");
}
finally
{
SQLiteConnection.ClearAllPools();
}
return ds;
}
/// <summary>
/// 取dataset
/// </summary>
/// <param name="strSql">strSql語句</param>
/// <param name="paraList">命令參數集合</param>
/// <returns>
/// 返回dataset
/// </returns>
public static DataSet GetDataSet(string strSql, params SQLiteParameter[] paraList)
{
DataSet ds = null;
try
{
using (SQLiteConnection connection = new SQLiteConnection(ConnString))
{
using (SQLiteCommand cmd = new SQLiteCommand(strSql, connection))
{
try
{
if (paraList != null && paraList.Length > 0)
{
cmd.Parameters.AddRange(paraList);
}
SQLiteDataAdapter dao = new SQLiteDataAdapter(cmd);
ds = new DataSet();
dao.Fill(ds);
connection.Close();
}
catch (SQLiteException e)
{
connection.Close();
StrLastError = e.Message;
}
}
}
}
catch (Exception ex)
{
LogHelper.Error($"執行sql輸出錯誤：{ex.Message}\r\nSql語句：{strSql}");
StrLastError = ex.Message;
}
finally
{
SQLiteConnection.ClearAllPools();
}
return ds;
}
/// <summary>
/// 取datatable
/// </summary>
/// <param name="strSql">SQL語句</param>
/// <returns>
/// 返回DataTable
/// </returns>
public static DataTable GetDataTable(string strSql)
{
DataTable dt = null;
try
{
using (SQLiteConnection connection = new SQLiteConnection(ConnString))
{
using (SQLiteCommand cmd = new SQLiteCommand(strSql, connection))
{
try
{
SQLiteDataAdapter dao = new SQLiteDataAdapter(cmd);
dt = new DataTable();
dao.Fill(dt);
connection.Close();
}
catch (SQLiteException e)
{
connection.Close();
StrLastError = e.Message;
}
}
}
}
catch (Exception ex)
{
LogHelper.Error($"執行sql輸出錯誤：{ex.Message}\r\nSql語句：{strSql}");
StrLastError = ex.Message;
}
finally
{
SQLiteConnection.ClearAllPools();
}
return dt;
}
/// <summary>
/// 取datatable
/// </summary>
/// <param name="strSql">SQL語句</param>
/// <param name="paraList">命令參數集合</param>
/// <returns>
/// 返回DataTable
/// </returns>
public static DataTable GetDataTable(string strSql, params SQLiteParameter[] paraList)
{
DataTable dt = null;
try
{
using (SQLiteConnection connection = new SQLiteConnection(ConnString))
{
using (SQLiteCommand cmd = new SQLiteCommand(strSql, connection))
{
try
{
if (paraList != null && paraList.Length > 0)
{
cmd.Parameters.AddRange(paraList);
}
SQLiteDataAdapter dao = new SQLiteDataAdapter(cmd);
dt = new DataTable();
dao.Fill(dt);
connection.Close();
}
catch (SQLiteException e)
{
connection.Close();
StrLastError = e.Message;
}
}
}
}
catch (Exception ex)
{
LogHelper.Error($"執行sql輸出錯誤：{ex.Message}\r\nSql語句：{strSql}");
StrLastError = ex.Message;
}
finally
{
SQLiteConnection.ClearAllPools();
}
return dt;
}
/// <summary>
/// 取最大的ID
/// </summary>
/// <param name="sKeyField">字段</param>
/// <param name="sTableName">表名</param>
/// <returns></returns>
public static int GetMaxId(string sKeyField, string sTableName)
{
DataTable dt = GetDataTable("select ifnull(max([" + sKeyField + "]),0) as MaxID from [" + sTableName + "]");
if (dt != null && dt.Rows.Count > 0)
{
return Convert.ToInt32(dt.Rows[0][0].ToString());
}
return 0;
}
/// <summary>
/// 取最大的ID
/// </summary>
/// <param name="sKeyField">字段</param>
/// <param name="sTableName">表名</param>
/// <param name="paraList">命令參數集合</param>
/// <returns></returns>
public static int GetMaxId(string sKeyField, string sTableName, params SQLiteParameter[] paraList)
{
DataTable dt = GetDataTable("select ifnull(max([" + sKeyField + "]),0) as MaxID from [" + sTableName + "]",
paraList);
if (dt != null && dt.Rows.Count > 0)
{
return Convert.ToInt32(dt.Rows[0][0].ToString());
}
return 0;
}
/// <summary>
/// 查詢數據庫中的所有數據類型信息
/// </summary>
/// <returns></returns>
public static DataTable GetSchema()
{
using (SQLiteConnection connection = new SQLiteConnection(ConnString))
{
connection.Open();
DataTable data = connection.GetSchema("TABLES");
connection.Close();
SQLiteConnection.ClearAllPools();
return data;
}
}
/// <summary>
/// 取某個單一的元素
/// </summary>
/// <param name="strSql">strSql語句</param>
/// <param name="paraList">命令參數集合</param>
/// <returns>
/// 返回dataset的第一行第一列的元素
/// </returns>
public static object GetSingle(string strSql, params SQLiteParameter[] paraList)
{
DataTable dt = GetDataTable(strSql, paraList);
if (dt != null && dt.Rows.Count > 0)
{
return dt.Rows[0][0];
}
return null;
}
/// <summary>
/// 取某個單一的元素
/// </summary>
/// <param name="strSql">strSql語句</param>
/// <returns>
/// 返回dataset的第一行第一列的元素
/// </returns>
public static object GetSingle(string strSql)
{
DataTable dt = GetDataTable(strSql);
if (dt != null && dt.Rows.Count > 0)
{
return dt.Rows[0][0];
}
return null;
}
/// <summary>
/// 判斷是否存在
/// </summary>
/// <param name="strSql">SQL</param>
/// <param name="paraList">命令參數集合</param>
/// <returns>
/// <c>true</c> if the specified string SQL is exist; otherwise, <c>false</c>.
/// </returns>
public static bool IsExist(string strSql, params SQLiteParameter[] paraList)
{
DataTable dt;
try
{
using (SQLiteConnection connection = new SQLiteConnection(ConnString))
{
SQLiteCommand cmd = new SQLiteCommand
{
CommandText = strSql
};
if (paraList != null && paraList.Length > 0)
{
cmd.Parameters.AddRange(paraList);
}
cmd.Connection = connection;
SQLiteDataAdapter dao = new SQLiteDataAdapter(cmd);
dt = new DataTable();
dao.Fill(dt);
connection.Close();
SQLiteConnection.ClearAllPools();
}
}
catch (Exception ex)
{
LogHelper.Error($"執行sql輸出錯誤：{ex.Message}\r\nSql語句：{strSql}");
StrLastError = ex.Message;
return false;
}
if (dt.Rows.Count > 0)
{
if (Convert.ToInt32(dt.Rows[0][0]) > 0)
{
return true;
}
}
return false;
}
/// <summary>
/// 執行insert,update,delete 動作，也可以使用事務
/// </summary>
/// <param name="strSql">strSql語句</param>
/// <param name="bUseTransaction">是否使用事務，默認不使用事務</param>
/// <returns></returns>
public static bool UpdateData(string strSql, bool bUseTransaction)
{
int iResult;
if (!bUseTransaction)
{
try
{
using (SQLiteConnection connection = new SQLiteConnection(ConnString))
{
SQLiteCommand comm = new SQLiteCommand(connection)
{
CommandText = strSql
};
iResult = comm.ExecuteNonQuery();
connection.Close();
}
}
catch (Exception ex)
{
LogHelper.Error($"執行sql輸出錯誤：{ex.Message}\r\nSql語句：{strSql}");
StrLastError = ex.Message;
iResult = -1;
}
}
else // 使用事務
{
SQLiteConnection conn = new SQLiteConnection(ConnString);
conn.Open();
DbTransaction trans = conn.BeginTransaction();
try
{
SQLiteCommand comm = new SQLiteCommand(conn)
{
CommandText = strSql
};
iResult = comm.ExecuteNonQuery();
trans.Commit();
conn.Close();
}
catch (Exception ex)
{
LogHelper.Error($"執行sql輸出錯誤：{ex.Message}\r\nSql語句：{strSql}");
iResult = -1;
trans.Rollback();
StrLastError = ex.Message;
}
}
SQLiteConnection.ClearAllPools();
return iResult > 0;
}
/// <summary>
/// 執行insert,update,delete 動作，也可以使用事務
/// </summary>
/// <param name="strSql">strSql語句</param>
/// <param name="bUseTransaction">是否使用事務，默認不使用事務</param>
/// <param name="paraList">命令參數集合</param>
/// <returns></returns>
public static bool UpdateData(string strSql, bool bUseTransaction, params SQLiteParameter[] paraList)
{
int iResult;
if (!bUseTransaction)
{
try
{
SQLiteConnection conn = new SQLiteConnection(ConnString);
conn.Open();
SQLiteCommand cmd = new SQLiteCommand(conn)
{
CommandText = strSql
};
if (paraList != null && paraList.Length > 0)
{
cmd.Parameters.AddRange(paraList);
}
iResult = cmd.ExecuteNonQuery();
conn.Close();
}
catch (Exception ex)
{
LogHelper.Error($"執行sql輸出錯誤：{ex.Message}\r\nSql語句：{strSql}");
iResult = -1;
StrLastError = ex.Message;
}
}
else // 使用事務
{
SQLiteConnection conn = new SQLiteConnection(ConnString);
conn.Open();
DbTransaction trans = conn.BeginTransaction();
try
{
SQLiteCommand cmd = new SQLiteCommand(conn)
{
CommandText = strSql
};
if (paraList != null && paraList.Length > 0)
{
cmd.Parameters.AddRange(paraList);
}
iResult = cmd.ExecuteNonQuery();
trans.Commit();
conn.Close();
}
catch (Exception ex)
{
LogHelper.Error($"執行sql輸出錯誤：{ex.Message}\r\nSql語句：{strSql}");
iResult = -1;
trans.Rollback();
StrLastError = ex.Message;
}
}
SQLiteConnection.ClearAllPools();
return iResult > 0;
}
/// <summary>
/// Prepares the command.
/// </summary>
/// <param name="cmd">The command.</param>
/// <param name="conn">The connection.</param>
/// <param name="trans">The trans.</param>
/// <param name="cmdText">The command text.</param>
/// <param name="cmdParms">The command parms.</param>
public static void PrepareCommand(SQLiteCommand cmd, SQLiteConnection conn, SQLiteTransaction trans, string cmdText, SQLiteParameter[] cmdParms)
{
if (conn.State != ConnectionState.Open)
{
conn.Open();
}
cmd.Connection = conn;
cmd.CommandText = cmdText;
if (trans != null)
{
cmd.Transaction = trans;
}
cmd.CommandType = CommandType.Text;
if (cmdParms != null)
{
foreach (SQLiteParameter parm in cmdParms)
{
cmd.Parameters.Add(parm);
}
}
}
/// <summary>
/// Existses the specified string SQL.
/// </summary>
/// <param name="strSql">The string SQL.</param>
/// <returns></returns>
public static bool Exists(string strSql)
{
object obj = GetSingle(strSql);
int cmdresult;
if (Equals(obj, null) || Equals(obj, DBNull.Value))
{
cmdresult = 0;
}
else
{
cmdresult = int.Parse(obj.ToString());
}
if (cmdresult == 0)
{
return false;
}
return true;
}
/// <summary>
/// Existses the specified string SQL.
/// </summary>
/// <param name="strSql">The string SQL.</param>
/// <param name="cmdParms">The command parms.</param>
/// <returns></returns>
public static bool Exists(string strSql, params SQLiteParameter[] cmdParms)
{
object obj = GetSingle(strSql, cmdParms);
int cmdresult;
if (Equals(obj, null) || Equals(obj, DBNull.Value))
{
cmdresult = 0;
}
else
{
cmdresult = int.Parse(obj.ToString());
}
if (cmdresult == 0)
{
return false;
}
return true;
}
/// <summary>
/// Adds the column.
/// </summary>
/// <param name="tableName">Name of the table.</param>
/// <param name="columnName">Name of the column.</param>
/// <param name="dataType">Type of the data.</param>
/// <returns></returns>
public static bool AddColumn(string tableName, string columnName, string dataType)
{
string pragmaSql = $"PRAGMA table_info(\"{tableName}\")";
DataSet ds = GetDataSet(pragmaSql);
List<string> nameList = new List<string>();
if (!Equals(ds, null) && ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
{
foreach (DataRow dataRow in ds.Tables[0].Rows)
{
if (dataRow["name"] != null)
{
nameList.Add(dataRow["name"].ToString());
}
}
}
if (!nameList.Contains(columnName))
{
string alterSql = $"ALTER TABLE {tableName} ADD {columnName} {dataType}";
int iResult = ExecuteNonQuery(alterSql);
return iResult > 0;
}
return true;
}
/// <summary>
/// Exists the column.
/// </summary>
/// <param name="fieldname">The fieldname.</param>
/// <returns></returns>
public static bool ExistColumn(string fieldname)
{
string sql = $"select * from sqlite_master where name='tablename' and sql like '%{fieldname}%'; ";
DataTable dataTable = ExecuteDataTable(sql);
if (!dataTable.Equals(null))
{
return dataTable.Rows.Count > 0;
}
return false;
}
/// <summary>
/// Exists the column.
/// </summary>
/// <param name="fieldname">The fieldname.</param>
/// <returns></returns>
public static bool ExistColumn(string tablename, string fieldname)
{
string sql = $"select * from sqlite_master where name='{tablename}' and sql like '%{fieldname}%'; ";
DataTable dataTable = ExecuteDataTable(sql);
if (!dataTable.Equals(null))
{
return dataTable.Rows.Count > 0;
}
return false;
}
/// <summary>
/// Adds the colum.
/// </summary>
/// <param name="tabel">The tabel.</param>
/// <param name="column">The column.</param>
/// <param name="type">The type.</param>
/// <returns></returns>
public static bool AddColum(string tabel, string column, string type)
{
string sql = $"ALTER TABLE {tabel} ADD {column} {type};";
return ExecuteNonQuery(sql) > 0;
}
}
----------------------------------------------------------------------------------------------------------------------------------------------
/// <summary>
/// 數據庫操作類
/// </summary>
public partial class DataHelper
{
static string _createTableStudent = "CREATE TABLE [student]([id] NVARCHAR(50) PRIMARY KEY,[name] NVARCHAR(50)," +
"[sex] INT DEFAULT 男, [age] INT DEFAULT 30, [dept] NVARCHAR(50));";
/// <summary>
/// Initializes static members of the <see cref="Client.Data.DataHelper"/> class.
/// </summary>
static DataHelper()
{
try
{
string strDbSql = _createTableStudent;
DbHelperSqlite.CreateDbTable(CommonHelper.GetFilePathAtCurrentDirectory("CoreData.dll"), strDbSql);
if (!DbHelperSqlite.ExistColumn("student", "score"))
{
DbHelperSqlite.AddColum("student", "score", "INT");
}
}
catch (Exception exception)
{
LogHelper.Error("創建數據文件出現錯誤：" + exception.Message);
}
}
/// <summary>
/// 是否存在該記錄
/// </summary>
public static bool ExistsStudent()
{
StringBuilder strSql = new StringBuilder();
strSql.Append("select count(1) from student");
return DbHelperSqlite.Exists(strSql.ToString(), null);
}
/// <summary>
/// 增加一條數據
/// </summary>
public static bool InsertStudent(Student model)
{
StringBuilder strSql = new StringBuilder();
strSql.Append("insert into student(");
strSql.Append("name,sex,age,dept,score)");
strSql.Append(" values (");
strSql.Append("@Name,@Sex,@Age,@Dept,@Score)");
SQLiteParameter[] parameters = {
new SQLiteParameter("@Name", DbType.String,4),
new SQLiteParameter("@Sex", DbType.Int32,4),
new SQLiteParameter("@Age", DbType.String,4),
new SQLiteParameter("@Dept", DbType.String,4),
new SQLiteParameter("@Score", DbType.Decimal)
};
parameters[0].Value = model.Name;
parameters[1].Value = model.Age;
parameters[2].Value = model.Sex;
parameters[3].Value = model.Dept;
parameters[4].Value = model.Score;
int rows = DbHelperSqlite.ExecuteNonQuery(strSql.ToString(), parameters);
return rows > 0;
}
/// <summary>
/// 更新一條數據
/// </summary>
public static bool UpdateStudent(Student model)
{
StringBuilder strSql = new StringBuilder();
strSql.Append("update config set ");
strSql.Append("Name=@Name,");
strSql.Append("Age=@Age,");
strSql.Append("Sex=@Sex,");
strSql.Append("Dept=@Dept,");
strSql.Append("Score=@Score,");
SQLiteParameter[] parameters = {
new SQLiteParameter("@Name", DbType.String,4),
new SQLiteParameter("@Age", DbType.Int32,4),
new SQLiteParameter("@Sex", DbType.String,4),
new SQLiteParameter("@Dept", DbType.String,4),
new SQLiteParameter("@Score", DbType.Decimal)
};
parameters[0].Value = model.Name;
parameters[1].Value = model.Age;
parameters[2].Value = model.Sex;
parameters[3].Value = model.Dept;
parameters[4].Value = model.Score;
int rows = DbHelperSqlite.ExecuteNonQuery(strSql.ToString(), parameters);
return rows > 0;
}
/// <summary>
/// 得到一個對象實體
/// </summary>
public static Student GetModelStudent()
{
StringBuilder strSql = new StringBuilder();
strSql.Append("select name,sex,age,dept,score from student ");
DataSet ds = DbHelperSqlite.GetDataSet(strSql.ToString(), null);
return ds.Tables[0].Rows.Count > 0 ? DataRowToModelStudent(ds.Tables[0].Rows[0]) : new Student();
}
/// <summary>
/// 得到一個對象實體
/// </summary>
public static Student DataRowToModelStudent(DataRow row)
{
Student model = new Student();
if (row != null)
{
if (row["name"] != null && row["name"].ToString() != "")
{
model.Name = row["name"].ToString();
}
if (row["sex"] != null && row["sex"].ToString() != "")
{
model.Sex = row["sex"].ToString();
}
if (row["age"] != null && row["age"].ToString() != "")
{
model.Age = int.Parse(row["age"].ToString());
}
if (row["dept"] != null && row["dept"].ToString() != "")
{
model.Dept = row["dept"].ToString();
}
if (row["score"] != null)
{
model.Score = decimal.Parse(row["score"].ToString());
}
}
return model;
}
}
----------------------------------------------------------------------------------------------------------------------------------------------
3、通用方法類
/// <summary>
/// 通用工具函數類
/// </summary>
public class CommonHelper
{
/// <summary>
/// Converts the string to decimal.
/// </summary>
/// <param name="strValue">The string value.</param>
/// <returns></returns>
public static decimal ConvertStringToDecimal(string strValue)
{
decimal decimalValue;
try
{
decimalValue = Convert.ToDecimal(strValue);
}
catch
{
decimalValue = 0;
}
return decimalValue;
}
/// <summary>
/// 獲取公用桌面路徑
/// </summary>
/// <returns></returns>
public static string GetAllUsersDesktopFolderPath()
{
LogHelper.Info("###open註冊表");
RegistryKey folders = OpenRegistryPath(Registry.LocalMachine, @"/software/microsoft/windows/currentversion/explorer/shell folders");
LogHelper.Info("###註冊表open完成");
string desktopPath = folders.GetValue("Common Desktop").ToString();
LogHelper.Info("###退出【獲取公用桌面路徑】方法");
return desktopPath;
}
/// <summary>
/// 根據Xpath獲取CDATA中的值
/// </summary>
/// <param name="strXmlText">xml字符串</param>
/// <param name="strXpath">Xpath表達式</param>
/// <returns></returns>
public static string GetCDataInnerText(string strXmlText, string strXpath)
{
string strResult = string.Empty;
XmlDocument doc = new XmlDocument
{
InnerXml = strXmlText
};
XmlNode nDataNode = doc.SelectSingleNode(strXpath);
if (!Equals(nDataNode, null))
{
if (nDataNode.HasChildNodes)
{
if (nDataNode.FirstChild is XmlCDataSection nDataSection)
{
strResult = nDataSection.InnerText;
}
}
}
return strResult;
}
/// <summary>
/// 獲得當前工作路徑
/// </summary>
/// <returns></returns>
public static string GetCurrentDirectory()
{
AssemblyName assemblyName = Assembly.GetExecutingAssembly().GetName();
string fullAppName = assemblyName.CodeBase;
string fullAppPath = Path.GetDirectoryName(fullAppName);
if (string.IsNullOrEmpty(fullAppPath))
{
return string.Empty;
}
if (fullAppPath.StartsWith("file:", StringComparison.Ordinal))
{
fullAppPath = fullAppPath.Substring(6);
}
return fullAppPath + "\\";
}
/// <summary>
/// 獲取執行路徑的文件名和擴展名
/// </summary>
/// <param name="fileFullPath">The file full path.</param>
/// <returns></returns>
public static string GetFileName(string fileFullPath)
{
return Path.GetFileName(fileFullPath);
}
/// <summary>
/// 獲取文件路徑
/// </summary>
/// <param name="filename">文件名稱</param>
/// <returns></returns>
public static string GetFilePathAtCurrentDirectory(string filename)
{
return GetCurrentDirectory() + filename;
}
/// <summary>
/// 執行程序名稱
/// </summary>
/// <returns></returns>
public static string GetMainExeName()
{
return AppDomain.CurrentDomain.FriendlyName;
}
/// <summary>
/// 根據Xpath獲取CDATA中的值
/// </summary>
/// <param name="strXmlText">xml字符串</param>
/// <param name="strCdataXpath">查找CDATA</param>
/// <param name="strNodeXpath">查找NODE</param>
/// <returns></returns>
public static string GetNodeFromCDataInnerText(string strXmlText, string strCdataXpath, string strNodeXpath)
{
try
{
string nodeValue = string.Empty;
string strResult = GetCDataInnerText(strXmlText, strCdataXpath);
if (!string.IsNullOrEmpty(strResult))
{
XmlDocument doc = new XmlDocument
{
InnerXml = strResult
};
XmlNode nDataNode = doc.SelectSingleNode(strNodeXpath);
if (!Equals(nDataNode, null))
{
nodeValue = nDataNode.InnerXml;
}
}
return nodeValue;
}
catch
{
return string.Empty;
}
}
/// <summary>
/// 獲取節點的值
/// </summary>
/// <param name="strXmlText">The string XML text.</param>
/// <param name="xpath">The xpath.</param>
/// <returns></returns>
public static string GetNodeInnerTextByXpath(string strXmlText, string xpath)
{
string strReslt = string.Empty;
if (!string.IsNullOrEmpty(strXmlText))
{
XmlDocument doc = new XmlDocument
{
InnerXml = strXmlText
};
XmlNode node = doc.SelectSingleNode(xpath);
if (!Equals(node, null))
{
strReslt = node.InnerText;
}
}
return strReslt;
}
/// <summary>
/// 獲取節點的值
/// </summary>
/// <param name="strXmlText">The string XML text.</param>
/// <param name="xpath">The xpath.</param>
/// <returns></returns>
public static string GetNodeOuterXmlByXpath(string strXmlText, string xpath)
{
string strReslt = string.Empty;
if (!string.IsNullOrEmpty(strXmlText))
{
XmlDocument doc = new XmlDocument
{
InnerXml = strXmlText
};
XmlNode node = doc.SelectSingleNode(xpath);
if (!Equals(node, null))
{
strReslt = node.InnerText;
}
}
return strReslt;
}
/// <summary>
/// 獲取節點的值
/// </summary>
/// <param name="strXmlText">The string XML text.</param>
/// <param name="xpath">The xpath.</param>
/// <returns></returns>
public static XmlNode GetNodeByXpath(string strXmlText, string xpath)
{
if (!string.IsNullOrEmpty(strXmlText))
{
XmlDocument doc = new XmlDocument
{
InnerXml = strXmlText
};
XmlNode node = doc.SelectSingleNode(xpath);
return node;
}
return null;
}
/// <summary>
/// 獲取節點的值
/// </summary>
/// <param name="nodeVNode">The node v node.</param>
/// <param name="xpath">The xpath.</param>
/// <returns></returns>
public static object GetNodeInnerTextFromNodeByXpath(XmlNode nodeVNode, string xpath)
{
object strReslt = string.Empty;
if (!Equals(nodeVNode, null))
{
XmlDocument doc = new XmlDocument
{
InnerXml = nodeVNode.OuterXml
};
XmlNode node = doc.SelectSingleNode(xpath);
if (!Equals(node, null))
{
strReslt = node.InnerText;
}
}
return strReslt;
}
/// <summary>
/// 獲取目錄信息
/// </summary>
/// <param name="fileFullPath">The file full path.</param>
/// <returns></returns>
public static string GetPath(string fileFullPath)
{
return Path.GetDirectoryName(fileFullPath);
}
/// <summary>
/// 獲得臨時數據目錄
/// </summary>
/// <returns></returns>
public static string GetTempDirectory()
{
string path = GetCurrentDirectory();
path = path + "tempfiles";
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
return path;
}
/// <summary>
/// 啓動新實例
/// </summary>
/// <param name="appName">Name of the application.</param>
public static void StartExe(string appName)
{
if (!string.IsNullOrEmpty(appName))
{
string path = Path.GetDirectoryName(appName);
if (path != null)
{
Process ps = new Process
{
StartInfo = new ProcessStartInfo
{
FileName = appName,
Arguments = "T",
CreateNoWindow = true,
WorkingDirectory = path
}
};
ps.Start();
}
}
}
/// <summary>
/// Opens the registry path.
/// </summary>
/// <param name="root">The root.</param>
/// <param name="s">The s.</param>
/// <returns></returns>
private static RegistryKey OpenRegistryPath(RegistryKey root, string s)
{
s = s.Remove(0, 1) + @"/";
while (s.IndexOf(@"/", StringComparison.Ordinal) != -1)
{
if (root != null)
{
root = root.OpenSubKey(s.Substring(0, s.IndexOf(@"/", StringComparison.Ordinal)));
s = s.Remove(0, s.IndexOf(@"/", StringComparison.Ordinal) + 1);
}
}
return root;
}
/// <summary>
/// Gets the quarter.
/// </summary>
/// <returns></returns>
public static string GetQuarter()
{
string period = string.Empty;
switch (DateTime.Now.Month)
{
case 1:
period = DateTime.Now.AddYears(-1).ToString("yyyy-04");
break;
case 4:
period = DateTime.Now.ToString("yyyy-01");
break;
case 7:
period = DateTime.Now.ToString("yyyy-02");
break;
case 10:
period = DateTime.Now.ToString("yyyy-03");
break;
}
return period;
}
/// <summary>
/// Checks the quarter.
/// </summary>
/// <returns></returns>
public static string CheckQuarter()
{
switch (DateTime.Now.Month)
{
case 1:
return DateTime.Now.AddYears(-1).ToString("yyyy年第四季度");
case 4:
return DateTime.Now.ToString("yyyy年第一季度");
case 7:
return DateTime.Now.ToString("yyyy年第二季度");
case 10:
return DateTime.Now.ToString("yyyy年第三季度");
}
return "當前不是納稅期";
}
/// <summary>
/// 當前是否爲整季度
/// </summary>
/// <returns>
/// <c>true</c> if this instance is quarter; otherwise, <c>false</c>.
/// </returns>
public static bool IsQuarter()
{
int month = DateTime.Now.Month;
return month == 1 || month == 4 || month == 7 || month == 10;
}
/// <summary>
/// 獲取html頁面
/// </summary>
/// <param name="url">The URL.</param>
/// <param name="encoding">The encoding.</param>
/// <param name="message">The message.</param>
/// <returns></returns>
public static string GetWebPageData(string url, Encoding encoding, out string message)
{
string sRslt = null;
message = string.Empty;
WebResponse oWebRps = null;
WebRequest oWebRqst = WebRequest.Create(url);
oWebRqst.Timeout = 50000;
try
{
oWebRps = oWebRqst.GetResponse();
}
catch (WebException e)
{
message = e.Message;
}
catch (Exception e)
{
message = e.ToString();
}
finally
{
if (oWebRps != null)
{
StreamReader oStreamRd = new StreamReader(oWebRps.GetResponseStream() ?? throw new InvalidOperationException(), encoding);
sRslt = oStreamRd.ReadToEnd();
oStreamRd.Close();
oWebRps.Close();
}
}
return sRslt;
}
/// <summary>
/// 運行DOS命令
/// DOS關閉進程命令(ntsd -c q -p PID )PID爲進程的ID
/// </summary>
/// <param name="command"></param>
/// <returns></returns>
public static string RunCmd(string command)
{
Process p = new Process();
p.StartInfo.FileName = "cmd.exe";
p.StartInfo.Arguments = "/c " + command;
p.StartInfo.UseShellExecute = false;
p.StartInfo.RedirectStandardInput = true;
p.StartInfo.RedirectStandardOutput = true;
p.StartInfo.RedirectStandardError = true;
p.StartInfo.CreateNoWindow = true;
p.Start();
return p.StandardOutput.ReadToEnd();
}
/// <summary>
/// 關閉應用程序
/// </summary>
/// <param name="applicationName">應用程序名稱，不包含.exe後綴</param>
/// <returns></returns>
public static bool ExitProcess(string applicationName)
{
try
{
Process[] processList = Process.GetProcessesByName(applicationName);
foreach (Process item in processList)
{
if (item.MainModule.FileName.EndsWith(applicationName + ".exe"))
{
RunCmd("taskkill /im " + applicationName + ".exe" + " /f ");
}
}
return true;
}
catch (Exception exception)
{
LogHelper.Info($"關閉進程出現錯誤：{exception}");
return false;
}
}
/// <summary>
/// 獲取時間戳
/// </summary>
/// <returns></returns>
public static string GetTimeStamp()
{
TimeSpan ts = DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0);
return Convert.ToInt64(ts.TotalSeconds).ToString();
}
public static string ReturnResult(object data, int code, string message)
{
Result result = new Result
{
Code = code,
Data = data,
Message = message
};
string strResult = JsonConvert.SerializeObject(result);
//LogHelper.Info(strResult);
return strResult;
}
public static string ReturnResult(object data, int code)
{
return ReturnResult(data, code, string.Empty);
}
public static string ReturnResult(object data)
{
return ReturnResult(data, 0, string.Empty);
}
public static string ReturnResultError(int code, string message)
{
return ReturnResult(null, code, message);
}
public static string ReturnResultError(string message)
{
return ReturnResult(null, -99, message);
}
/// <summary>
/// Automatics the reg COM.
/// </summary>
/// <param name="strCmd">The string command.</param>
/// <returns></returns>
public static string AutoRegCom(string strCmd)
{
try
{
Process myProcess = new Process();
ProcessStartInfo myProcessStartInfo = new ProcessStartInfo("cmd.exe")
{
UseShellExecute = false,
CreateNoWindow = true,
RedirectStandardOutput = true
};
myProcess.StartInfo = myProcessStartInfo;
myProcessStartInfo.Arguments = "/c " + strCmd;
myProcess.Start();
StreamReader myStreamReader = myProcess.StandardOutput;
string rInfo = myStreamReader.ReadToEnd();
myProcess.Close();
rInfo = strCmd + "\r\n" + rInfo;
return rInfo;
}
catch (Exception ex)
{
return ex.Message;
}
}
/// <summary>
/// 運行控制檯程序，獲取程序的輸出結果
/// </summary>
/// <param name="exePath">The executable path.</param>
/// <param name="parameters">The parameters.</param>
/// <returns></returns>
public static string GetRunOtherApplicationResult(string exePath, string parameters)
{
ProcessStartInfo psi = new ProcessStartInfo
{
RedirectStandardOutput = true,
RedirectStandardError = true,
WindowStyle = ProcessWindowStyle.Hidden,
UseShellExecute = false,
FileName = exePath,
Arguments = parameters
};
Process process = Process.Start(psi);
if (process != null)
{
StreamReader outputStreamReader = process.StandardOutput;
StreamReader errStreamReader = process.StandardError;
process.WaitForExit(2000);
if (process.HasExited)
{
string output = outputStreamReader.ReadToEnd();
string error = errStreamReader.ReadToEnd();
return output.Replace("\r\n", string.Empty);
}
}
return string.Empty;
}
/// <summary>
/// 根據進程名，關閉系統
/// add by shenxue
/// </summary>
/// <param name="name">進行名</param>
public static void KillProcess(string name)
{
if (string.IsNullOrWhiteSpace(name))
{
return;
}
Process[] arrayProcess = Process.GetProcessesByName(name);
foreach (Process v in arrayProcess)
{
LogHelper.Info(v.ProcessName);
v.Kill();
}
}
internal class NsrsbhEntity
{
public string msg { get; set; }
public string code { get; set; }
public IList<Datum> data { get; set; }
}
internal class Datum
{
public string id { get; set; }
public string enterpriseName { get; set; }
public string taxpayerNum { get; set; }
public bool registry { get; set; }
public long ts { get; set; }
}
}
/// <summary>
/// 通用結果類
/// </summary>
public class Result<T>
{
#region 數據屬性
/// <summary>
/// 狀態碼
/// </summary>
public int Code { get; set; }
/// <summary>
/// 消息
/// </summary>
public string Message { get; set; }
/// <summary>
/// 數據
/// </summary>
public T Data { get; set; }
#endregion
}
/// <summary>
/// 默認結果類
/// </summary>
public class Result : Result<object>
{
}