SQLite-C#-帮助类

  public static class SQLiteHelper
     {
         private static string connectionString = string.Empty;

         #region void SetConnectionString(string datasource, string password, int version = 3) 根据数据源、密码、版本号设置连接字符串
         /// <summary>
         /// 根据数据源、密码、版本号设置连接字符串。
         /// </summary>
         /// <param name="datasource">数据源。</param>
         /// <param name="password">密码。</param>
         /// <param name="version">版本号（缺省为3）。</param>
         public static void SetConnectionString(string datasource, string password, int version = )
         {
             connectionString = string.Format("Data Source={0};Version={1};password={2};Pooling=true;FailIfMissing=false",
                 datasource, version, password);
         }
         #endregion

         #region void CreateDB(string dbName) 创建一个数据库文件。如果存在同名数据库文件，则会覆盖。
         /// <summary>
         /// 创建一个数据库文件。如果存在同名数据库文件，则会覆盖。
         /// </summary>
         /// <param name="dbName">数据库文件名。为null或空串时不创建。</param>
         /// <param name="password">（可选）数据库密码，默认为空。</param>
         /// <exception cref="Exception"></exception>
         public static void CreateDB(string dbName)
         {
             if (!string.IsNullOrEmpty(dbName))
             {
                 try { SQLiteConnection.CreateFile(dbName); }
                 catch (Exception) { throw; }
             }
         }
         #endregion

         #region void PrepareCommand(SQLiteCommand cmd, SQLiteConnection conn, string cmdText, params SQLiteParameter[] parameters)准备操作命令参数
         /// <summary>
         /// 准备操作命令参数
         /// </summary>
         /// <param name="cmd">SQLiteCommand</param>
         /// <param name="conn">SQLiteConnection</param>
         /// <param name="cmdText">Sql命令文本</param>
         private static void PrepareCommand(SQLiteCommand cmd, SQLiteConnection conn, string cmdText, params SQLiteParameter[] parameters)
         {
             if (conn.State != ConnectionState.Open)
                 conn.Open();
             cmd.Parameters.Clear();
             cmd.Connection = conn;
             cmd.CommandText = cmdText;
             cmd.CommandType = CommandType.Text;
             cmd.CommandTimeout = ;
             if (parameters.Length != )
             {
                 cmd.Parameters.AddRange(parameters);
             }
         }
         #endregion

         #region ExecuteNonQuery(string sql, params SQLiteParameter[] parameters) 对SQLite数据库执行增删改操作，返回受影响的行数。
         /// <summary>
         /// 对SQLite数据库执行增删改操作，返回受影响的行数。
         /// </summary>
         /// <param name="sql">要执行的增删改的SQL语句。</param>
         /// <param name="parameters">执行增删改语句所需要的参数，参数必须以它们在SQL语句中的顺序为准。</param>
         /// <returns></returns>
         /// <exception cref="Exception"></exception>
         public static int ExecuteNonQuery(string sql, params SQLiteParameter[] parameters)
         {
             int affectedRows = ;
             using (SQLiteConnection connection = new SQLiteConnection(connectionString))
             {
                 using (SQLiteCommand command = new SQLiteCommand())
                 {
                     try
                     {
                         PrepareCommand(command, connection, sql, parameters);
                         affectedRows = command.ExecuteNonQuery();
                     }
                     catch (Exception) { throw; }
                 }
             }
             return affectedRows;
         }
         #endregion

         #region void ExecuteNonQueryBatch(List<KeyValuePair<string, SQLiteParameter[]>> list) 批量处理数据操作语句
         /// <summary>
         /// 批量处理数据操作语句。
         /// </summary>
         /// <param name="list">SQL语句集合。</param>
         /// <exception cref="Exception"></exception>
         public static void ExecuteNonQueryBatch(List<KeyValuePair<string, SQLiteParameter[]>> list)
         {
             using (SQLiteConnection conn = new SQLiteConnection(connectionString))
             {
                 if (conn.State != ConnectionState.Open)
                     conn.Open();
                 using (SQLiteTransaction tran = conn.BeginTransaction())
                 {
                     using (SQLiteCommand cmd = new SQLiteCommand(conn))
                     {
                         try
                         {
                             foreach (var item in list)
                             {
                                 cmd.CommandText = item.Key;
                                 if (item.Value != null)
                                 {
                                     cmd.Parameters.AddRange(item.Value);
                                 }
                                 cmd.ExecuteNonQuery();
                             }
                             tran.Commit();
                         }
                         catch (Exception) { tran.Rollback(); throw; }
                     }
                 }
             }
         }
         #endregion

         #region object ExecuteScalar(string sql, params SQLiteParameter[] parameters) 执行查询语句，并返回第一个结果。
         /// <summary>
         /// 执行查询语句，并返回第一个结果。
         /// </summary>
         /// <param name="sql">查询语句。</param>
         /// <returns>查询结果。</returns>
         /// <exception cref="Exception"></exception>
         public static object ExecuteScalar(string sql, params SQLiteParameter[] parameters)
         {
             using (SQLiteConnection connection = new SQLiteConnection(connectionString))
             {
                 using (SQLiteCommand command = new SQLiteCommand())
                 {
                     try
                     {
                         PrepareCommand(command, connection, sql, parameters);

                         return command.ExecuteScalar();
                     }
                     catch (Exception) { throw; }
                 }
             }
         }
         #endregion

         #region DataTable ExecuteQuery(string sql, params SQLiteParameter[] parameters)执行一个查询语句，返回一个包含查询结果的DataTable。
         /// <summary>
         /// 执行一个查询语句，返回一个包含查询结果的DataTable。
         /// </summary>
         /// <param name="sql">要执行的查询语句。</param>
         /// <param name="parameters">执行SQL查询语句所需要的参数，参数必须以它们在SQL语句中的顺序为准。</param>
         /// <returns></returns>
         /// <exception cref="Exception"></exception>
         public static DataTable ExecuteQuery(string sql, params SQLiteParameter[] parameters)
         {
             using (SQLiteConnection connection = new SQLiteConnection(connectionString))
             {
                 using (SQLiteCommand command = new SQLiteCommand())
                 {
                     PrepareCommand(command, connection, sql, parameters);

                     SQLiteDataAdapter adapter = new SQLiteDataAdapter(command);
                     DataTable data = new DataTable();
                     try { adapter.Fill(data); }
                     catch (Exception) { throw; }
                     return data;
                 }
             }
         }

         #endregion

         #region SQLiteDataReader ExecuteReader(string sql, params SQLiteParameter[] parameters) 执行一个查询语句，返回一个关联的SQLiteDataReader实例。
         /// <summary>
         /// 执行一个查询语句，返回一个关联的SQLiteDataReader实例。
         /// </summary>
         /// <param name="sql">要执行的查询语句。</param>
         /// <param name="parameters">执行SQL查询语句所需要的参数，参数必须以它们在SQL语句中的顺序为准。</param>
         /// <returns></returns>
         /// <exception cref="Exception"></exception>
         public static SQLiteDataReader ExecuteReader(string sql, params SQLiteParameter[] parameters)
         {
             using (SQLiteConnection connection = new SQLiteConnection(connectionString))
             {
                 using (SQLiteCommand command = new SQLiteCommand())
                 {
                     try
                     {
                         PrepareCommand(command, connection, sql, parameters);
                         return command.ExecuteReader(CommandBehavior.CloseConnection);
                     }
                     catch (Exception) { throw; }
                 }
             }
         }

         #endregion

         #region DataSet ExecutePager(ref int recordCount, int pageIndex, int pageSize, string cmdText, string countText, params SQLiteParameter[] parameters)分页查询
         /// <summary>
         /// 分页查询
         /// </summary>
         /// <param name="recordCount">总记录数</param>
         /// <param name="pageIndex">页牵引</param>
         /// <param name="pageSize">页大小</param>
         /// <param name="cmdText">Sql命令文本</param>
         /// <param name="countText">查询总记录数的Sql文本</param>
         /// <param name="parameters">命令参数</param>
         /// <returns>DataSet</returns>
         public static DataSet ExecutePager(ref int recordCount, int pageIndex, int pageSize, string cmdText, string countText, params SQLiteParameter[] parameters)
         {
             if (recordCount < )
                 recordCount = int.Parse(ExecuteScalar(countText).ToString());
             var ds = new DataSet();
             using (SQLiteConnection connection = new SQLiteConnection(connectionString))
             {
                 using (SQLiteCommand command = new SQLiteCommand())
                 {
                     PrepareCommand(command, connection, cmdText, parameters);

                     SQLiteDataAdapter adapter = new SQLiteDataAdapter(command);
                     adapter.Fill(ds, (pageIndex - ) * pageSize, pageSize, "result");
                 }
                 return ds;
             }
         }
         #endregion

         #region DataTable GetSchema()查询数据库中的所有数据类型信息
         /// <summary>
         /// 查询数据库中的所有数据类型信息。
         /// </summary>
         /// <returns></returns>
         /// <exception cref="Exception"></exception>
         public static DataTable GetSchema()
         {
             using (SQLiteConnection connection = new SQLiteConnection(connectionString))
             {
                 try
                 {
                     connection.Open();
                     return connection.GetSchema("TABLES");
                 }
                 catch (Exception) { throw; }
             }
         }
         #endregion

         #region int ResetDataBass() 重置自动增长列，如果执行了删除操作，自动增长列就会变的不连续，通过使用VACUUM方式重置
         /// <summary>
         /// 重置自动增长列，如果执行了删除操作，自动增长列就会变的不连续，通过使用VACUUM方式重置
         /// </summary>
         public static int ResetDataBass()
         {
             using (SQLiteConnection conn = new SQLiteConnection(connectionString))
             {
                 using (SQLiteCommand command = new SQLiteCommand())
                 {
                     PrepareCommand(command, conn, "vacuum");

                     return command.ExecuteNonQuery();
                 }
             }
         }
         #endregion
     }