using System; using System.Collections.Generic; using System.Data; using System.Data.SQLite; using System.IO; using System.Linq; using System.Text; using System.Threading.Tasks; namespace BaseComm { #region SQLiteHelper public class SQLiteHelper { #region DECLARATIONS private SQLiteConnection oConnection; private ConnectionState oConnectionState = ConnectionState.Closed; public SQLiteCommand oCommand; private SQLiteParameter oParameter; private SQLiteTransaction oTransaction; private bool mblTransaction; public int ConnectTimeOut = 10;//CommandTimeout = 180; private string S_CONNECTION; private string S_PROVIDER; #endregion #region ENUMERATORS public enum TransactionType : uint { Open = 1, Commit = 2, Rollback = 3 } public enum CZstatus : uint { New = 1, Edit = 2 } #endregion #region CONSTRUCTOR public SQLiteHelper(string connectionString) { this.S_CONNECTION = connectionString; } #endregion #region DESTRUCTOR ~SQLiteHelper() { //oFactory = null; } #endregion #region CONNECTIONS /// <summary> ///Description : This function is used to Open Database Connection ///Author : AuthorWho ///Date : 2011-11-01 ///Input : NA ///OutPut : NA ///Comments : /// </summary> public void EstablishFactoryConnection() { /* // This check is not required as it will throw "Invalid Provider Exception" on the contructor itself. if (0 == DbProviderFactories.GetFactoryClasses().Select("InvariantName='" + S_PROVIDER + "'").Length) throw new Exception("Invalid Provider"); */ oConnection = new SQLiteConnection(this.S_CONNECTION);////oFactory.CreateConnection(); if (oConnection.State == ConnectionState.Closed) { oConnection.ConnectionString = S_CONNECTION; oConnection.Open(); oConnectionState = ConnectionState.Open; } } /// <summary> ///Description : This function is used to Close Database Connection ///Author : AuthorWho ///Date : 2011-11-01 ///Input : NA ///OutPut : NA ///Comments : /// </summary> public void CloseFactoryConnection() { //check for an open connection try { if (oConnection.State == ConnectionState.Open) { oConnection.Close(); oConnectionState = ConnectionState.Closed; } } catch (SQLiteException oDbErr) { //catch any SQL server data provider generated error messag throw new Exception(oDbErr.Message); } catch (System.NullReferenceException oNullErr) { throw new Exception(oNullErr.Message); } finally { if (null != oConnection) oConnection.Dispose(); } } #endregion #region TRANSACTION /// <summary> ///Description : This function is used to Handle Transaction Events ///Author : AuthorWho ///Date : 2011-11-01 ///Input : Transaction Event Type ///OutPut : NA ///Comments : /// </summary> public void TransactionHandler(TransactionType veTransactionType) { switch (veTransactionType) { case TransactionType.Open: //open a transaction try { oTransaction = oConnection.BeginTransaction(); mblTransaction = true; } catch (InvalidOperationException oErr) { throw new Exception("@TransactionHandler - " + oErr.Message); } break; case TransactionType.Commit: //commit the transaction if (null != oTransaction.Connection) { try { oTransaction.Commit(); mblTransaction = false; } catch (InvalidOperationException oErr) { throw new Exception("@TransactionHandler - " + oErr.Message); } } break; case TransactionType.Rollback: //rollback the transaction try { if (mblTransaction) { oTransaction.Rollback(); } mblTransaction = false; } catch (InvalidOperationException oErr) { throw new Exception("@TransactionHandler - " + oErr.Message); } break; } } #endregion #region COMMANDS #region PARAMETERLESS METHODS /// <summary> ///Description : This function is used to Prepare Command For Execution ///Author : AuthorWho ///Date : 2011-11-01 ///Input : Transaction, Command Type, Command Text, 2-Dimensional Parameter Array ///OutPut : NA ///Comments : Has to be changed/removed if object based array concept is removed. /// </summary> private void PrepareCommand(bool blTransaction, CommandType cmdType, string cmdText) { if (oConnection.State != ConnectionState.Open) { oConnection.ConnectionString = S_CONNECTION; oConnection.Open(); oConnectionState = ConnectionState.Open; } if (null == oCommand) { oCommand = new SQLiteCommand(this.oConnection); oCommand.CommandTimeout = this.ConnectTimeOut; } oCommand.Connection = oConnection; oCommand.CommandText = cmdText; oCommand.CommandType = cmdType; if (blTransaction) oCommand.Transaction = oTransaction; } #endregion #region OBJECT BASED PARAMETER ARRAY /// <summary> ///Description : This function is used to Prepare Command For Execution ///Author : AuthorWho ///Date : 2011-11-01 ///Input : Transaction, Command Type, Command Text, 2-Dimensional Parameter Array ///OutPut : NA ///Comments : /// </summary> private void PrepareCommand(bool blTransaction, CommandType cmdType, string cmdText, object[,] cmdParms) { if (oConnection.State != ConnectionState.Open) { oConnection.ConnectionString = S_CONNECTION; oConnection.Open(); oConnectionState = ConnectionState.Open; } if (null == oCommand) oCommand = new SQLiteCommand(this.oConnection); oCommand.Connection = oConnection; oCommand.CommandText = cmdText; oCommand.CommandType = cmdType; if (blTransaction) oCommand.Transaction = oTransaction; if (null != cmdParms) CreateDBParameters(cmdParms); } #endregion #region STRUCTURE BASED PARAMETER ARRAY /// <summary> ///Description : This function is used to Prepare Command For Execution ///Author : AuthorWho ///Date : 2011-11-01 ///Input : Transaction, Command Type, Command Text, 2-Dimensional Parameter Array ///OutPut : NA ///Comments : /// </summary> private void PrepareCommand(bool blTransaction, CommandType cmdType, string cmdText, Parameters[] cmdParms) { if (oConnection.State != ConnectionState.Open) { oConnection.ConnectionString = S_CONNECTION; oConnection.Open(); oConnectionState = ConnectionState.Open; } oCommand = new SQLiteCommand(this.oConnection); oCommand.Connection = oConnection; oCommand.CommandText = cmdText; oCommand.CommandType = cmdType; if (blTransaction) oCommand.Transaction = oTransaction; if (null != cmdParms) CreateDBParameters(cmdParms); } #endregion #endregion #region PARAMETER METHODS #region OBJECT BASED /// <summary> ///Description : This function is used to Create Parameters for the Command For Execution ///Author : AuthorWho ///Date : 2011-11-01 ///Input : 2-Dimensional Parameter Array ///OutPut : NA ///Comments : /// </summary> private void CreateDBParameters(object[,] colParameters) { for (int i = 0; i < colParameters.Length / 2; i++) { oParameter = oCommand.CreateParameter(); oParameter.ParameterName = colParameters[i, 0].ToString(); oParameter.Value = colParameters[i, 1]; oCommand.Parameters.Add(oParameter); } } #endregion #region STRUCTURE BASED /// <summary> ///Description : This function is used to Create Parameters for the Command For Execution ///Author : AuthorWho ///Date : 2011-11-01 ///Input : 2-Dimensional Parameter Array ///OutPut : NA ///Comments : /// </summary> private void CreateDBParameters(Parameters[] colParameters) { for (int i = 0; i < colParameters.Length; i++) { Parameters oParam = (Parameters)colParameters[i]; oParameter = oCommand.CreateParameter(); oParameter.ParameterName = oParam.ParamName; oParameter.Value = oParam.ParamValue; oParameter.Direction = oParam.ParamDirection; oCommand.Parameters.Add(oParameter); } } #endregion #endregion #region EXCEUTE METHODS #region PARAMETERLESS METHODS /// <summary> ///Description : This function is used to Execute the Command ///Author : AuthorWho ///Date : 2011-11-01 ///Input : Command Type, Command Text, 2-Dimensional Parameter Array ///OutPut : Count of Records Affected ///Comments : /// Has to be changed/removed if object based array concept is removed. /// </summary> public int ExecuteNonQuery(CommandType cmdType, string cmdText) { try { EstablishFactoryConnection(); PrepareCommand(false, cmdType, cmdText); return oCommand.ExecuteNonQuery(); } catch (Exception ex) { throw ex; } finally { if (null != oCommand) oCommand.Dispose(); CloseFactoryConnection(); } } /// <summary> ///Description : This function is used to Execute the Command ///Author : AuthorWho ///Date : 2011-11-01 ///Input : Transaction, Command Type, Command Text, 2-Dimensional Parameter Array, Clear Paramaeters ///OutPut : Count of Records Affected ///Comments : /// Has to be changed/removed if object based array concept is removed. /// </summary> public int ExecuteNonQuery(bool blTransaction, CommandType cmdType, string cmdText) { try { PrepareCommand(blTransaction, cmdType, cmdText); int val = oCommand.ExecuteNonQuery(); return val; } catch (Exception ex) { throw ex; } finally { if (null != oCommand) oCommand.Dispose(); } } #endregion #region OBJECT BASED PARAMETER ARRAY /// <summary> ///Description : This function is used to Execute the Command ///Author : AuthorWho ///Date : 2011-11-01 ///Input : Command Type, Command Text, 2-Dimensional Parameter Array, Clear Parameters ///OutPut : Count of Records Affected ///Comments : /// </summary> public int ExecuteNonQuery(CommandType cmdType, string cmdText, object[,] cmdParms, bool blDisposeCommand) { try { EstablishFactoryConnection(); PrepareCommand(false, cmdType, cmdText, cmdParms); return oCommand.ExecuteNonQuery(); } catch (Exception ex) { throw ex; } finally { if (blDisposeCommand && null != oCommand) oCommand.Dispose(); CloseFactoryConnection(); } } /// <summary> ///Description : This function is used to Execute the Command ///Author : AuthorWho ///Date : 2011-11-01 ///Input : Command Type, Command Text, 2-Dimensional Parameter Array ///OutPut : Count of Records Affected ///Comments : Overloaded method. /// </summary> public int ExecuteNonQuery(CommandType cmdType, string cmdText, object[,] cmdParms) { return ExecuteNonQuery(cmdType, cmdText, cmdParms, true); } /// <summary> ///Description : This function is used to Execute the Command ///Author : AuthorWho ///Date : 2011-11-01 ///Input : Transaction, Command Type, Command Text, 2-Dimensional Parameter Array, Clear Paramaeters ///OutPut : Count of Records Affected ///Comments : /// </summary> public int ExecuteNonQuery(bool blTransaction, CommandType cmdType, string cmdText, object[,] cmdParms, bool blDisposeCommand) { try { PrepareCommand(blTransaction, cmdType, cmdText, cmdParms); return oCommand.ExecuteNonQuery(); } catch (Exception ex) { throw ex; } finally { if (blDisposeCommand && null != oCommand) oCommand.Dispose(); } } /// <summary> ///Description : This function is used to Execute the Command ///Author : AuthorWho ///Date : 2011-11-01 ///Input : Transaction, Command Type, Command Text, 2-Dimensional Parameter Array ///OutPut : Count of Records Affected ///Comments : Overloaded function. /// </summary> public int ExecuteNonQuery(bool blTransaction, CommandType cmdType, string cmdText, object[,] cmdParms) { return ExecuteNonQuery(blTransaction, cmdType, cmdText, cmdParms, true); } #endregion #region STRUCTURE BASED PARAMETER ARRAY /// <summary> ///Description : This function is used to Execute the Command ///Author : AuthorWho ///Date : 2011-11-01 ///Input : Command Type, Command Text, Parameter Structure Array, Clear Parameters ///OutPut : Count of Records Affected ///Comments : /// </summary> public int ExecuteNonQuery(CommandType cmdType, string cmdText, Parameters[] cmdParms, bool blDisposeCommand) { try { EstablishFactoryConnection(); PrepareCommand(false, cmdType, cmdText, cmdParms); return oCommand.ExecuteNonQuery(); } catch (Exception ex) { throw ex; } finally { if (blDisposeCommand && null != oCommand) oCommand.Dispose(); CloseFactoryConnection(); } } /// <summary> ///Description : This function is used to Execute the Command ///Author : AuthorWho ///Date : 2011-11-01 ///Input : Command Type, Command Text, Parameter Structure Array ///OutPut : Count of Records Affected ///Comments : Overloaded method. /// </summary> public int ExecuteNonQuery(CommandType cmdType, string cmdText, Parameters[] cmdParms) { return ExecuteNonQuery(cmdType, cmdText, cmdParms, true); } /// <summary> ///Description : This function is used to Execute the Command ///Author : AuthorWho ///Date : 2011-11-01 ///Input : Transaction, Command Type, Command Text, Parameter Structure Array, Clear Parameters ///OutPut : Count of Records Affected ///Comments : /// </summary> public int ExecuteNonQuery(bool blTransaction, CommandType cmdType, string cmdText, Parameters[] cmdParms, bool blDisposeCommand) { try { PrepareCommand(blTransaction, cmdType, cmdText, cmdParms); return oCommand.ExecuteNonQuery(); } catch (Exception ex) { throw ex; } finally { if (blDisposeCommand && null != oCommand) oCommand.Dispose(); } } /// <summary> ///Description : This function is used to Execute the Command ///Author : AuthorWho ///Date : 2011-11-01 ///Input : Transaction, Command Type, Command Text, Parameter Structure Array ///OutPut : Count of Records Affected ///Comments : /// </summary> public int ExecuteNonQuery(bool blTransaction, CommandType cmdType, string cmdText, Parameters[] cmdParms) { return ExecuteNonQuery(blTransaction, cmdType, cmdText, cmdParms, true); } #endregion #endregion #region READER METHODS #region PARAMETERLESS METHODS /// <summary> ///Description : This function is used to fetch data using Data Reader ///Author : AuthorWho ///Date : 2011-11-01 ///Input : Command Type, Command Text, 2-Dimensional Parameter Array ///OutPut : Data Reader ///Comments : /// Has to be changed/removed if object based array concept is removed. /// </summary> public SQLiteDataReader ExecuteReader(CommandType cmdType, string cmdText) { // we use a try/catch here because if the method throws an exception we want to // close the connection throw code, because no datareader will exist, hence the // commandBehaviour.CloseConnection will not work try { EstablishFactoryConnection(); PrepareCommand(false, cmdType, cmdText); SQLiteDataReader dr = oCommand.ExecuteReader(CommandBehavior.CloseConnection); oCommand.Parameters.Clear(); return dr; } catch (Exception ex) { CloseFactoryConnection(); throw ex; } finally { if (null != oCommand) oCommand.Dispose(); } } #endregion #region OBJECT BASED PARAMETER ARRAY /// <summary> ///Description : This function is used to fetch data using Data Reader ///Author : AuthorWho ///Date : 2011-11-01 ///Input : Command Type, Command Text, 2-Dimensional Parameter Array ///OutPut : Data Reader ///Comments : /// </summary> public SQLiteDataReader ExecuteReader(CommandType cmdType, string cmdText, object[,] cmdParms) { // we use a try/catch here because if the method throws an exception we want to // close the connection throw code, because no datareader will exist, hence the // commandBehaviour.CloseConnection will not work try { EstablishFactoryConnection(); PrepareCommand(false, cmdType, cmdText, cmdParms); SQLiteDataReader dr = oCommand.ExecuteReader(CommandBehavior.CloseConnection); oCommand.Parameters.Clear(); return dr; } catch (Exception ex) { CloseFactoryConnection(); throw ex; } finally { if (null != oCommand) oCommand.Dispose(); } } #endregion #region STRUCTURE BASED PARAMETER ARRAY /// <summary> ///Description : This function is used to fetch data using Data Reader ///Author : AuthorWho ///Date : 2011-11-01 ///Input : Command Type, Command Text, Parameter AStructure Array ///OutPut : Data Reader ///Comments : /// </summary> public SQLiteDataReader ExecuteReader(CommandType cmdType, string cmdText, Parameters[] cmdParms) { // we use a try/catch here because if the method throws an exception we want to // close the connection throw code, because no datareader will exist, hence the // commandBehaviour.CloseConnection will not work try { EstablishFactoryConnection(); PrepareCommand(false, cmdType, cmdText, cmdParms); return oCommand.ExecuteReader(CommandBehavior.CloseConnection); } catch (Exception ex) { CloseFactoryConnection(); throw ex; } finally { if (null != oCommand) oCommand.Dispose(); } } #endregion #endregion #region ADAPTER METHODS #region PARAMETERLESS METHODS /// <summary> ///Description : This function is used to fetch data using Data Adapter ///Author : AuthorWho ///Date : 2011-11-01 ///Input : Command Type, Command Text, 2-Dimensional Parameter Array ///OutPut : Data Set ///Comments : /// Has to be changed/removed if object based array concept is removed. /// </summary> public DataSet DataAdapter(CommandType cmdType, string cmdText) { // we use a try/catch here because if the method throws an exception we want to // close the connection throw code, because no datareader will exist, hence the // commandBehaviour.CloseConnection will not work SQLiteDataAdapter dda = null; try { EstablishFactoryConnection(); dda = new SQLiteDataAdapter(); PrepareCommand(false, cmdType, cmdText); dda.SelectCommand = oCommand; DataSet ds = new DataSet(); dda.Fill(ds); return ds; } catch (Exception ex) { throw ex; } finally { if (null != oCommand) oCommand.Dispose(); CloseFactoryConnection(); } } public DataSet ExecuteDataSet(CommandType cmdType, string cmdText) { return DataAdapter(cmdType, cmdText); } #endregion #region OBJECT BASED PARAMETER ARRAY /// <summary> ///Description : This function is used to fetch data using Data Adapter ///Author : AuthorWho ///Date : 2011-11-01 ///Input : Command Type, Command Text, 2-Dimensional Parameter Array ///OutPut : Data Set ///Comments : /// </summary> public DataSet DataAdapter(CommandType cmdType, string cmdText, object[,] cmdParms) { // we use a try/catch here because if the method throws an exception we want to // close the connection throw code, because no datareader will exist, hence the // commandBehaviour.CloseConnection will not work SQLiteDataAdapter dda = null; try { EstablishFactoryConnection(); dda = new SQLiteDataAdapter(); PrepareCommand(false, cmdType, cmdText, cmdParms); dda.SelectCommand = oCommand; DataSet ds = new DataSet(); dda.Fill(ds); return ds; } catch (Exception ex) { throw ex; } finally { if (null != oCommand) oCommand.Dispose(); CloseFactoryConnection(); } } public DataSet ExecuteDataSet(CommandType cmdType, string cmdText, object[,] cmdParms) { return DataAdapter(cmdType, cmdText, cmdParms); } #endregion #region STRUCTURE BASED PARAMETER ARRAY /// <summary> ///Description : This function is used to fetch data using Data Adapter ///Author : AuthorWho ///Date : 2011-11-01 ///Input : Command Type, Command Text, 2-Dimensional Parameter Array ///OutPut : Data Set ///Comments : /// </summary> public DataSet DataAdapter(CommandType cmdType, string cmdText, Parameters[] cmdParms) { // we use a try/catch here because if the method throws an exception we want to // close the connection throw code, because no datareader will exist, hence the // commandBehaviour.CloseConnection will not work SQLiteDataAdapter dda = null; try { EstablishFactoryConnection(); dda = new SQLiteDataAdapter(); PrepareCommand(false, cmdType, cmdText, cmdParms); dda.SelectCommand = oCommand; DataSet ds = new DataSet(); dda.Fill(ds); return ds; } catch (Exception ex) { throw ex; } finally { if (null != oCommand) oCommand.Dispose(); CloseFactoryConnection(); } } public DataSet ExecuteDataSet(CommandType cmdType, string cmdText, Parameters[] cmdParms) { return DataAdapter(cmdType, cmdText, cmdParms); } #endregion #endregion #region SCALAR METHODS #region PARAMETERLESS METHODS /// <summary> ///Description : This function is used to invoke Execute Scalar Method ///Author : AuthorWho ///Date : 2011-11-01 ///Input : Command Type, Command Text, 2-Dimensional Parameter Array ///OutPut : Object ///Comments : /// </summary> public object ExecuteScalar(CommandType cmdType, string cmdText) { try { EstablishFactoryConnection(); PrepareCommand(false, cmdType, cmdText); object val = oCommand.ExecuteScalar(); return val; } catch (Exception ex) { throw ex; } finally { if (null != oCommand) oCommand.Dispose(); CloseFactoryConnection(); } } #endregion #region OBJECT BASED PARAMETER ARRAY /// <summary> ///Description : This function is used to invoke Execute Scalar Method ///Author : AuthorWho ///Date : 2011-11-01 ///Input : Command Type, Command Text, 2-Dimensional Parameter Array ///OutPut : Object ///Comments : /// </summary> public object ExecuteScalar(CommandType cmdType, string cmdText, object[,] cmdParms, bool blDisposeCommand) { try { EstablishFactoryConnection(); PrepareCommand(false, cmdType, cmdText, cmdParms); return oCommand.ExecuteScalar(); } catch (Exception ex) { throw ex; } finally { if (blDisposeCommand && null != oCommand) oCommand.Dispose(); CloseFactoryConnection(); } } /// <summary> ///Description : This function is used to invoke Execute Scalar Method ///Author : AuthorWho ///Date : 2011-11-01 ///Input : Command Type, Command Text, 2-Dimensional Parameter Array ///OutPut : Object ///Comments : Overloaded Method. /// </summary> public object ExecuteScalar(CommandType cmdType, string cmdText, object[,] cmdParms) { return ExecuteScalar(cmdType, cmdText, cmdParms, true); } /// <summary> ///Description : This function is used to invoke Execute Scalar Method ///Author : AuthorWho ///Date : 2011-11-01 ///Input : Command Type, Command Text, 2-Dimensional Parameter Array ///OutPut : Object ///Comments : /// </summary> public object ExecuteScalar(bool blTransaction, CommandType cmdType, string cmdText, object[,] cmdParms, bool blDisposeCommand) { try { PrepareCommand(blTransaction, cmdType, cmdText, cmdParms); return oCommand.ExecuteScalar(); } catch (Exception ex) { throw ex; } finally { if (blDisposeCommand && null != oCommand) oCommand.Dispose(); } } /// <summary> ///Description : This function is used to invoke Execute Scalar Method ///Author : AuthorWho ///Date : 2011-11-01 ///Input : Command Type, Command Text, 2-Dimensional Parameter Array ///OutPut : Object ///Comments : /// </summary> public object ExecuteScalar(bool blTransaction, CommandType cmdType, string cmdText, object[,] cmdParms) { return ExecuteScalar(blTransaction, cmdType, cmdText, cmdParms, true); } #endregion #region STRUCTURE BASED PARAMETER ARRAY /// <summary> ///Description : This function is used to invoke Execute Scalar Method ///Author : AuthorWho ///Date : 2011-11-01 ///Input : Command Type, Command Text, 2-Dimensional Parameter Array ///OutPut : Object ///Comments : /// </summary> public object ExecuteScalar(CommandType cmdType, string cmdText, Parameters[] cmdParms, bool blDisposeCommand) { try { EstablishFactoryConnection(); PrepareCommand(false, cmdType, cmdText, cmdParms); return oCommand.ExecuteScalar(); } catch (Exception ex) { throw ex; } finally { if (blDisposeCommand && null != oCommand) oCommand.Dispose(); CloseFactoryConnection(); } } /// <summary> ///Description : This function is used to invoke Execute Scalar Method ///Author : AuthorWho ///Date : 2011-11-01 ///Input : Command Type, Command Text, 2-Dimensional Parameter Array ///OutPut : Object ///Comments : Overloaded Method. /// </summary> public object ExecuteScalar(CommandType cmdType, string cmdText, Parameters[] cmdParms) { return ExecuteScalar(cmdType, cmdText, cmdParms, true); } /// <summary> ///Description : This function is used to invoke Execute Scalar Method ///Author : AuthorWho ///Date : 2011-11-01 ///Input : Command Type, Command Text, 2-Dimensional Parameter Array ///OutPut : Object ///Comments : /// </summary> public object ExecuteScalar(bool blTransaction, CommandType cmdType, string cmdText, Parameters[] cmdParms, bool blDisposeCommand) { try { PrepareCommand(blTransaction, cmdType, cmdText, cmdParms); return oCommand.ExecuteScalar(); } catch (Exception ex) { throw ex; } finally { if (blDisposeCommand && null != oCommand) oCommand.Dispose(); } } /// <summary> ///Description : This function is used to invoke Execute Scalar Method ///Author : AuthorWho ///Date : 2011-11-01 ///Input : Command Type, Command Text, 2-Dimensional Parameter Array ///OutPut : Object ///Comments : /// </summary> public object ExecuteScalar(bool blTransaction, CommandType cmdType, string cmdText, Parameters[] cmdParms) { return ExecuteScalar(blTransaction, cmdType, cmdText, cmdParms, true); } #endregion public SQLiteParameter GetParameter(string parameterName) { return oCommand.Parameters[parameterName]; } #endregion #region edit by lhl 2016-10-17 23:39:59 /// <summary> /// 如果数据库不存在,则创建数据库 /// </summary> /// <param name="iName"></param> public void CreatDataBase(string iName) { try { string dbName = string.Format("{0}.sqlite", iName); //,如果数据库不存在,则创建数据库 MyDatabase if (!File.Exists(dbName)) SQLiteConnection.CreateFile(dbName); } catch (Exception) { throw; } } #endregion } #region STRUCTURES /// <summary> ///Description : This function is used to Execute the Command ///Author : AuthorWho ///Date : 2011-11-01 ///Input : ///OutPut : ///Comments : /// </summary> public struct Parameters { public string ParamName; public object ParamValue; public DbType ParamDbType; public ParameterDirection ParamDirection; public Parameters(string Name, object Value, ParameterDirection Direction) { ParamName = Name; ParamValue = Value; ParamDbType = DbType.Object; ParamDirection = Direction; } public Parameters(string Name, object Value) { ParamName = Name; ParamValue = Value; ParamDbType = DbType.Object; ParamDirection = ParameterDirection.Input; } public Parameters(string Name, object Value, DbType dbType) { ParamName = Name; ParamValue = Value; ParamDbType = dbType; ParamDirection = ParameterDirection.Input; } } #endregion #endregion }