C# SQLite 创建数据库的方法增删查改语法和命令

SQLite介绍

SQLite是一个开源、免费的小型RDBMS(关系型数据库)，能独立运行、无服务器、零配置、支持事物，用C实现，内存占用较小，支持绝大数的SQL92标准。

SQLite数据库官方主页：http://www.sqlite.org/index.html

 

cmd下sqlite的使用网

1：选择下载对应自己系统的sqlite.3exe文件

2：解压后使用cmd命令进入sqlite3.exe文件所在的路径执行命令就可以操作做相应的操作。

在进入数据库之后如果需要退出的话windows下摁ctrl+c就能退出

例如：

创建数据库命令：sqlite3.exe 【数据库名字.后缀名】

　　这里比较牛一点的感觉就是创建的数据库后缀名是任意的、不过注意一点就是：在命令框下执行创建数据库的时候。

如果没有为数据库创建表格、则看不见数据库文件，所以必须创建表格。

　　例如：在CMD命令提示符下输入sqlite3.exe test.db(test.db是数据库名)回车，执行完后，命令提示符自动跳转

到"SQLITE>"状态。这时还是看不到这个数据库！等表格创建或关闭sqlite3

例如：create table user(’用户名‘); 这时可以看到sqlite3.exe所在文件夹下的这个数据库文件了

如果下次还要使用此数据库时仍然使用sqlite3.exe test.db即可进入此数据库

基础命令（增删改查）

创建表格命令：create table tablename(字段，字段）

这里从命令上可以清楚的看到、在sqlite数据库中创建表格字段的时候、允许不为字段申明数据类型。

这是区别于其它关系型数据库的。

执行插入命令：insert into tablename values(value,values)

在、前面我们可以看出、sqlite的操作上和sqlserver没什么太大区别、值得注意的是、insert时区别于sqlserver中、因为sqlserver中允许使用 "insert table  name values(value,value)"这样的省略式擦入。但是sqlite中是不允许使用省略式插入语句的。

执行删除语句：delete  from tablename where <条件>

删除数据语法和sqlserver相同、

删除表则命令为：drop table tablename

数据更新命令：update tablename set 字段=值 如果需要条件的话、添加上where语句。

执行查询语句：select *from tablename 可跟随where语句

以上就是基础的sqlite的增删查改语法和命令。

C#操作SQLite Database

C#下SQLite操作驱动dll下载：System.Data.SQLite

C#使用SQLite步骤：

（1）新建一个project

（2）添加SQLite dll引用（操作驱动）

（3）使用API操作SQLite DataBase

操作SQLite Database的C#帮助类SQLite Helper

 using System;
 using System.Data.SQLite;
  
 namespace SQLiteSamples
 {
     class Program
     {
         //数据库连接
         SQLiteConnection m_dbConnection;
  
         static void Main(string[] args)
         {
             Program p = new Program();
         }
  
         public Program()
         {
             createNewDatabase();
             connectToDatabase();
             createTable();
             fillTable();
             printHighscores();
         }
  
         //创建一个空的数据库
         void createNewDatabase()
         {
             SQLiteConnection.CreateFile("MyDatabase.sqlite");
         }
  
         //创建一个连接到指定数据库
         void connectToDatabase()
         {
             m_dbConnection = new SQLiteConnection("Data Source=MyDatabase.sqlite;Version=3;");
             m_dbConnection.Open();
         }
  
         //在指定数据库中创建一个table
         void createTable()
         {
             string sql = "create table highscores (name varchar(20), score int)";
             SQLiteCommand command = new SQLiteCommand(sql, m_dbConnection);
             command.ExecuteNonQuery();
         }
  
         //插入一些数据
         void fillTable()
         {
             string sql = "insert into highscores (name, score) values ('Me', 3000)";
             SQLiteCommand command = new SQLiteCommand(sql, m_dbConnection);
             command.ExecuteNonQuery();
  
             sql = "insert into highscores (name, score) values ('Myself', 6000)";
             command = new SQLiteCommand(sql, m_dbConnection);
             command.ExecuteNonQuery();
  
             sql = "insert into highscores (name, score) values ('And I', 9001)";
             command = new SQLiteCommand(sql, m_dbConnection);
             command.ExecuteNonQuery();
         }
  
         //使用sql查询语句，并显示结果
         void printHighscores()
         {
             string sql = "select * from highscores order by score desc";
             SQLiteCommand command = new SQLiteCommand(sql, m_dbConnection);
             SQLiteDataReader reader = command.ExecuteReader();
             while (reader.Read())
                 Console.WriteLine("Name: " + reader["name"] + "\tScore: " + reader["score"]);
             Console.ReadLine();
         }
     }
 }

SQLite Helper类

将一些常用的功能封装一下，封装成SQLite Helper类

 using System;
 using System.Data;
 using System.Text.RegularExpressions;
 using System.Xml;
 using System.IO;
 using System.Collections;
 using System.Data.SQLite;
  
 namespace DBUtility.SQLite
 {
     /// <summary>
     /// SQLiteHelper is a utility class similar to "SQLHelper" in MS
     /// Data Access Application Block and follows similar pattern.
     /// </summary>
     public class SQLiteHelper
     {
         /// <summary>
         /// Creates a new <see cref="SQLiteHelper"/> instance. The ctor is marked private since all members are static.
         /// </summary>
         private SQLiteHelper()
         {
         }
         /// <summary>
         /// Creates the command.
         /// </summary>
         /// <param name="connection">Connection.</param>
         /// <param name="commandText">Command text.</param>
         /// <param name="commandParameters">Command parameters.</param>
         /// <returns>SQLite Command</returns>
         public static SQLiteCommand CreateCommand(SQLiteConnection connection, string commandText, params SQLiteParameter[] commandParameters)
         {
             SQLiteCommand cmd = new SQLiteCommand(commandText, connection);
             if (commandParameters.Length > )
             {
                 foreach (SQLiteParameter parm in commandParameters)
                     cmd.Parameters.Add(parm);
             }
             return cmd;
         }
  
         /// <summary>
         /// Creates the command.
         /// </summary>
         /// <param name="connectionString">Connection string.</param>
         /// <param name="commandText">Command text.</param>
         /// <param name="commandParameters">Command parameters.</param>
         /// <returns>SQLite Command</returns>
         public static SQLiteCommand CreateCommand(string connectionString, string commandText, params SQLiteParameter[] commandParameters)
         {
             SQLiteConnection cn = new SQLiteConnection(connectionString);
  
             SQLiteCommand cmd = new SQLiteCommand(commandText, cn);
  
             if (commandParameters.Length > )
             {
                 foreach (SQLiteParameter parm in commandParameters)
                     cmd.Parameters.Add(parm);
             }
             return cmd;
         }
         /// <summary>
         /// Creates the parameter.
         /// </summary>
         /// <param name="parameterName">Name of the parameter.</param>
         /// <param name="parameterType">Parameter type.</param>
         /// <param name="parameterValue">Parameter value.</param>
         /// <returns>SQLiteParameter</returns>
         public static SQLiteParameter CreateParameter(string parameterName, System.Data.DbType parameterType, object parameterValue)
         {
             SQLiteParameter parameter = new SQLiteParameter();
             parameter.DbType = parameterType;
             parameter.ParameterName = parameterName;
             parameter.Value = parameterValue;
             return parameter;
         }
  
         /// <summary>
         /// Shortcut method to execute dataset from SQL Statement and object[] arrray of parameter values
         /// </summary>
         /// <param name="connectionString">SQLite Connection string</param>
         /// <param name="commandText">SQL Statement with embedded "@param" style parameter names</param>
         /// <param name="paramList">object[] array of parameter values</param>
         /// <returns></returns>
         public static DataSet ExecuteDataSet(string connectionString, string commandText, object[] paramList)
         {
             SQLiteConnection cn = new SQLiteConnection(connectionString);
             SQLiteCommand cmd = cn.CreateCommand();
  
  
             cmd.CommandText = commandText;
             if (paramList != null)
             {
                 AttachParameters(cmd,commandText, paramList);
             }
             DataSet ds = new DataSet();
             if (cn.State == ConnectionState.Closed)
                 cn.Open();
             SQLiteDataAdapter da = new SQLiteDataAdapter(cmd);
             da.Fill(ds);
             da.Dispose();
             cmd.Dispose();
             cn.Close();
             return ds;
         }
         /// <summary>
         /// Shortcut method to execute dataset from SQL Statement and object[] arrray of  parameter values
         /// </summary>
         /// <param name="cn">Connection.</param>
         /// <param name="commandText">Command text.</param>
         /// <param name="paramList">Param list.</param>
         /// <returns></returns>
         public static DataSet ExecuteDataSet(SQLiteConnection cn, string commandText, object[] paramList)
         {
  
             SQLiteCommand cmd = cn.CreateCommand();
  
  
             cmd.CommandText = commandText;
             if (paramList != null)
             {
                 AttachParameters(cmd,commandText, paramList);
             }
             DataSet ds = new DataSet();
             if (cn.State == ConnectionState.Closed)
                 cn.Open();
             SQLiteDataAdapter da = new SQLiteDataAdapter(cmd);
             da.Fill(ds);
             da.Dispose();
             cmd.Dispose();
             cn.Close();
             return ds;
         }
         /// <summary>
         /// Executes the dataset from a populated Command object.
         /// </summary>
         /// <param name="cmd">Fully populated SQLiteCommand</param>
         /// <returns>DataSet</returns>
         public static DataSet ExecuteDataset(SQLiteCommand cmd)
         {
             if (cmd.Connection.State == ConnectionState.Closed)
                 cmd.Connection.Open();
             DataSet ds = new DataSet();
             SQLiteDataAdapter da = new SQLiteDataAdapter(cmd);
             da.Fill(ds);
             da.Dispose();
             cmd.Connection.Close();
             cmd.Dispose();
             return ds;
         }
  
         /// <summary>
         /// Executes the dataset in a SQLite Transaction
         /// </summary>
         /// <param name="transaction">SQLiteTransaction. Transaction consists of Connection, Transaction,  /// and Command, all of which must be created prior to making this method call. </param>
         /// <param name="commandText">Command text.</param>
         /// <param name="commandParameters">Sqlite Command parameters.</param>
         /// <returns>DataSet</returns>
         /// <remarks>user must examine Transaction Object and handle transaction.connection .Close, etc.</remarks>
         public static DataSet ExecuteDataset(SQLiteTransaction transaction, string commandText, params SQLiteParameter[] commandParameters)
         {
  
             if (transaction == null) throw new ArgumentNullException("transaction");
             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rolled back or committed, please provide an open transaction.", "transaction");
             IDbCommand cmd = transaction.Connection.CreateCommand();
             cmd.CommandText = commandText;
             foreach (SQLiteParameter parm in commandParameters)
             {
                 cmd.Parameters.Add(parm);
             }
             if (transaction.Connection.State == ConnectionState.Closed)
                 transaction.Connection.Open();
             DataSet ds = ExecuteDataset((SQLiteCommand)cmd);
             return ds;
         }
  
         /// <summary>
         /// Executes the dataset with Transaction and object array of parameter values.
         /// </summary>
         /// <param name="transaction">SQLiteTransaction. Transaction consists of Connection, Transaction,    /// and Command, all of which must be created prior to making this method call. </param>
         /// <param name="commandText">Command text.</param>
         /// <param name="commandParameters">object[] array of parameter values.</param>
         /// <returns>DataSet</returns>
         /// <remarks>user must examine Transaction Object and handle transaction.connection .Close, etc.</remarks>
         public static DataSet ExecuteDataset(SQLiteTransaction transaction, string commandText, object[] commandParameters)
         {
  
             if (transaction == null) throw new ArgumentNullException("transaction");
             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rolled back or committed,                                                          please provide an open transaction.", "transaction");
             IDbCommand cmd = transaction.Connection.CreateCommand();
             cmd.CommandText = commandText;
             AttachParameters((SQLiteCommand)cmd,cmd.CommandText, commandParameters);
             if (transaction.Connection.State == ConnectionState.Closed)
                 transaction.Connection.Open();
  
             DataSet ds = ExecuteDataset((SQLiteCommand)cmd);
             return ds;
         }
  
         #region UpdateDataset
         /// <summary>
         /// Executes the respective command for each inserted, updated, or deleted row in the DataSet.
         /// </summary>
         /// <remarks>
         /// e.g.: 
         ///  UpdateDataset(conn, insertCommand, deleteCommand, updateCommand, dataSet, "Order");
         /// </remarks>
         /// <param name="insertCommand">A valid SQL statement  to insert new records into the data source</param>
         /// <param name="deleteCommand">A valid SQL statement to delete records from the data source</param>
         /// <param name="updateCommand">A valid SQL statement used to update records in the data source</param>
         /// <param name="dataSet">The DataSet used to update the data source</param>
         /// <param name="tableName">The DataTable used to update the data source.</param>
         public static void UpdateDataset(SQLiteCommand insertCommand, SQLiteCommand deleteCommand, SQLiteCommand updateCommand, DataSet dataSet, string tableName)
         {
             if (insertCommand == null) throw new ArgumentNullException("insertCommand");
             if (deleteCommand == null) throw new ArgumentNullException("deleteCommand");
             if (updateCommand == null) throw new ArgumentNullException("updateCommand");
             if (tableName == null || tableName.Length == ) throw new ArgumentNullException("tableName");
  
             // Create a SQLiteDataAdapter, and dispose of it after we are done
             using (SQLiteDataAdapter dataAdapter = new SQLiteDataAdapter())
             {
                 // Set the data adapter commands
                 dataAdapter.UpdateCommand = updateCommand;
                 dataAdapter.InsertCommand = insertCommand;
                 dataAdapter.DeleteCommand = deleteCommand;
  
                 // Update the dataset changes in the data source
                 dataAdapter.Update(dataSet, tableName);
  
                 // Commit all the changes made to the DataSet
                 dataSet.AcceptChanges();
             }
         }
         #endregion
  
  
  
  
         /// <summary>
         /// ShortCut method to return IDataReader
         /// NOTE: You should explicitly close the Command.connection you passed in as
         /// well as call Dispose on the Command  after reader is closed.
         /// We do this because IDataReader has no underlying Connection Property.
         /// </summary>
         /// <param name="cmd">SQLiteCommand Object</param>
         /// <param name="commandText">SQL Statement with optional embedded "@param" style parameters</param>
         /// <param name="paramList">object[] array of parameter values</param>
         /// <returns>IDataReader</returns>
         public static IDataReader ExecuteReader(SQLiteCommand cmd, string commandText, object[] paramList)
         {
             if (cmd.Connection == null)
                 throw new ArgumentException("Command must have live connection attached.", "cmd");
             cmd.CommandText = commandText;
             AttachParameters(cmd,commandText, paramList);
             if (cmd.Connection.State == ConnectionState.Closed)
                 cmd.Connection.Open();
             IDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
             return rdr;
         }
  
         /// <summary>
         /// Shortcut to ExecuteNonQuery with SqlStatement and object[] param values
         /// </summary>
         /// <param name="connectionString">SQLite Connection String</param>
         /// <param name="commandText">Sql Statement with embedded "@param" style parameters</param>
         /// <param name="paramList">object[] array of parameter values</param>
         /// <returns></returns>
         public static int ExecuteNonQuery(string connectionString, string commandText, params object[] paramList)
         {
             SQLiteConnection cn = new SQLiteConnection(connectionString);
             SQLiteCommand cmd = cn.CreateCommand();
             cmd.CommandText = commandText;
             AttachParameters(cmd,commandText, paramList);
             if (cn.State == ConnectionState.Closed)
                 cn.Open();
             int result = cmd.ExecuteNonQuery();
             cmd.Dispose();
             cn.Close();
  
             return result;
         }
  
  
  
         public static int ExecuteNonQuery(SQLiteConnection cn, string commandText, params  object[] paramList)
         {
  
             SQLiteCommand cmd = cn.CreateCommand();
             cmd.CommandText = commandText;
             AttachParameters(cmd,commandText, paramList);
             if (cn.State == ConnectionState.Closed)
                 cn.Open();
             int result = cmd.ExecuteNonQuery();
             cmd.Dispose();
             cn.Close();
  
             return result;
         }
  
         /// <summary>
         /// Executes  non-query sql Statment with Transaction
         /// </summary>
         /// <param name="transaction">SQLiteTransaction. Transaction consists of Connection, Transaction,   /// and Command, all of which must be created prior to making this method call. </param>
         /// <param name="commandText">Command text.</param>
         /// <param name="paramList">Param list.</param>
         /// <returns>Integer</returns>
         /// <remarks>user must examine Transaction Object and handle transaction.connection .Close, etc.</remarks>
         public static int ExecuteNonQuery(SQLiteTransaction transaction, string commandText, params  object[] paramList)
         {
             if (transaction == null) throw new ArgumentNullException("transaction");
             if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rolled back or committed,                                                        please provide an open transaction.", "transaction");
             IDbCommand cmd = transaction.Connection.CreateCommand();
             cmd.CommandText = commandText;
             AttachParameters((SQLiteCommand)cmd,cmd.CommandText, paramList);
             if (transaction.Connection.State == ConnectionState.Closed)
                 transaction.Connection.Open();
             int result = cmd.ExecuteNonQuery();
             cmd.Dispose();
             return result;
         }
  
  
         /// <summary>
         /// Executes the non query.
         /// </summary>
         /// <param name="cmd">CMD.</param>
         /// <returns></returns>
         public static int ExecuteNonQuery(IDbCommand cmd)
         {
             if (cmd.Connection.State == ConnectionState.Closed)
                 cmd.Connection.Open();
             int result = cmd.ExecuteNonQuery();
             cmd.Connection.Close();
             cmd.Dispose();
             return result;
         }
  
         /// <summary>
         /// Shortcut to ExecuteScalar with Sql Statement embedded params and object[] param values
         /// </summary>
         /// <param name="connectionString">SQLite Connection String</param>
         /// <param name="commandText">SQL statment with embedded "@param" style parameters</param>
         /// <param name="paramList">object[] array of param values</param>
         /// <returns></returns>
         public static object ExecuteScalar(string connectionString, string commandText, params  object[] paramList)
         {
             SQLiteConnection cn = new SQLiteConnection(connectionString);
             SQLiteCommand cmd = cn.CreateCommand();
             cmd.CommandText = commandText;
             AttachParameters(cmd,commandText, paramList);
             if (cn.State == ConnectionState.Closed)
                 cn.Open();
             object result = cmd.ExecuteScalar();
             cmd.Dispose();
             cn.Close();
  
             return result;
         }
  
         /// <summary>
         /// Execute XmlReader with complete Command
         /// </summary>
         /// <param name="command">SQLite Command</param>
         /// <returns>XmlReader</returns>
         public static XmlReader ExecuteXmlReader(IDbCommand command)
         { // open the connection if necessary, but make sure we
             // know to close it when we�re done.
             if (command.Connection.State != ConnectionState.Open)
             {
                 command.Connection.Open();
             }
  
             // get a data adapter 
             SQLiteDataAdapter da = new SQLiteDataAdapter((SQLiteCommand)command);
             DataSet ds = new DataSet();
             // fill the data set, and return the schema information
             da.MissingSchemaAction = MissingSchemaAction.AddWithKey;
             da.Fill(ds);
             // convert our dataset to XML
             StringReader stream = new StringReader(ds.GetXml());
             command.Connection.Close();
             // convert our stream of text to an XmlReader
             return new XmlTextReader(stream);
         }
  
  
  
         /// <summary>
         /// Parses parameter names from SQL Statement, assigns values from object array ,   /// and returns fully populated ParameterCollection.
         /// </summary>
         /// <param name="commandText">Sql Statement with "@param" style embedded parameters</param>
         /// <param name="paramList">object[] array of parameter values</param>
         /// <returns>SQLiteParameterCollection</returns>
         /// <remarks>Status experimental. Regex appears to be handling most issues. Note that parameter object array must be in same ///order as parameter names appear in SQL statement.</remarks>
         private static SQLiteParameterCollection AttachParameters(SQLiteCommand cmd, string commandText, params  object[] paramList)
         {
             if (paramList == null || paramList.Length == ) return null;
  
             SQLiteParameterCollection coll = cmd.Parameters;
             string parmString = commandText.Substring(commandText.IndexOf("@"));
             // pre-process the string so always at least 1 space after a comma.
             parmString = parmString.Replace(",", " ,");
             // get the named parameters into a match collection
             string pattern = @"(@)\S*(.*?)\b";
             Regex ex = new Regex(pattern, RegexOptions.IgnoreCase);
             MatchCollection mc = ex.Matches(parmString);
             string[] paramNames = new string[mc.Count];
             int i = ;
             foreach (Match m in mc)
             {
                 paramNames[i] = m.Value;
                 i++;
             }
  
             // now let's type the parameters
             int j = ;
             Type t = null;
             foreach (object o in paramList)
             {
                 t = o.GetType();
  
                 SQLiteParameter parm = new SQLiteParameter();
                 switch (t.ToString())
                 {
  
                     case ("DBNull"):
                     case ("Char"):
                     case ("SByte"):
                     case ("UInt16"):
                     case ("UInt32"):
                     case ("UInt64"):
                         throw new SystemException("Invalid data type");
  
  
                     case ("System.String"):
                         parm.DbType = DbType.String;
                         parm.ParameterName = paramNames[j];
                         parm.Value = (string)paramList[j];
                         coll.Add(parm);
                         break;
  
                     case ("System.Byte[]"):
                         parm.DbType = DbType.Binary;
                         parm.ParameterName = paramNames[j];
                         parm.Value = (byte[])paramList[j];
                         coll.Add(parm);
                         break;
  
                     case ("System.Int32"):
                         parm.DbType = DbType.Int32;
                         parm.ParameterName = paramNames[j];
                         parm.Value = (int)paramList[j];
                         coll.Add(parm);
                         break;
  
                     case ("System.Boolean"):
                         parm.DbType = DbType.Boolean;
                         parm.ParameterName = paramNames[j];
                         parm.Value = (bool)paramList[j];
                         coll.Add(parm);
                         break;
  
                     case ("System.DateTime"):
                         parm.DbType = DbType.DateTime;
                         parm.ParameterName = paramNames[j];
                         parm.Value = Convert.ToDateTime(paramList[j]);
                         coll.Add(parm);
                         break;
  
                     case ("System.Double"):
                         parm.DbType = DbType.Double;
                         parm.ParameterName = paramNames[j];
                         parm.Value = Convert.ToDouble(paramList[j]);
                         coll.Add(parm);
                         break;
  
                     case ("System.Decimal"):
                         parm.DbType = DbType.Decimal;
                         parm.ParameterName = paramNames[j];
                         parm.Value = Convert.ToDecimal(paramList[j]);
                         break;
  
                     case ("System.Guid"):
                         parm.DbType = DbType.Guid;
                         parm.ParameterName = paramNames[j];
                         parm.Value = (System.Guid)(paramList[j]);
                         break;
  
                     case ("System.Object"):
  
                         parm.DbType = DbType.Object;
                         parm.ParameterName = paramNames[j];
                         parm.Value = paramList[j];
                         coll.Add(parm);
                         break;
  
                     default:
                         throw new SystemException("Value is of unknown data type");
  
                 } // end switch
  
                 j++;
             }
             return coll;
         }
  
         /// <summary>
         /// Executes non query typed params from a DataRow
         /// </summary>
         /// <param name="command">Command.</param>
         /// <param name="dataRow">Data row.</param>
         /// <returns>Integer result code</returns>
         public static int ExecuteNonQueryTypedParams(IDbCommand command, DataRow dataRow)
         {
             int retVal = ;
  
             // If the row has values, the store procedure parameters must be initialized
             if (dataRow != null && dataRow.ItemArray.Length > )
             {
                 // Set the parameters values
                 AssignParameterValues(command.Parameters, dataRow);
  
                 retVal = ExecuteNonQuery(command);
             }
             else
             {
                 retVal = ExecuteNonQuery(command);
             }
  
             return retVal;
         }
  
         /// <summary>
         /// This method assigns dataRow column values to an IDataParameterCollection
         /// </summary>
         /// <param name="commandParameters">The IDataParameterCollection to be assigned values</param>
         /// <param name="dataRow">The dataRow used to hold the command's parameter values</param>
         /// <exception cref="System.InvalidOperationException">Thrown if any of the parameter names are invalid.</exception>
         protected internal static void AssignParameterValues(IDataParameterCollection commandParameters, DataRow dataRow)
         {
             if (commandParameters == null || dataRow == null)
             {
                 // Do nothing if we get no data
                 return;
             }
  
             DataColumnCollection columns = dataRow.Table.Columns;
  
             int i = ;
             // Set the parameters values
             foreach (IDataParameter commandParameter in commandParameters)
             {
                 // Check the parameter name
                 if (commandParameter.ParameterName == null ||
                  commandParameter.ParameterName.Length <= )
                     throw new InvalidOperationException(string.Format(
                            "Please provide a valid parameter name on the parameter #{0},                            the ParameterName property has the following value: '{1}'.",
                      i, commandParameter.ParameterName));
  
                 if (columns.Contains(commandParameter.ParameterName))
                     commandParameter.Value = dataRow[commandParameter.ParameterName];
                 else if (columns.Contains(commandParameter.ParameterName.Substring()))
                     commandParameter.Value = dataRow[commandParameter.ParameterName.Substring()];
  
                 i++;
             }
         }
  
         /// <summary>
         /// This method assigns dataRow column values to an array of IDataParameters
         /// </summary>
         /// <param name="commandParameters">Array of IDataParameters to be assigned values</param>
         /// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values</param>
         /// <exception cref="System.InvalidOperationException">Thrown if any of the parameter names are invalid.</exception>
         protected void AssignParameterValues(IDataParameter[] commandParameters, DataRow dataRow)
         {
             if ((commandParameters == null) || (dataRow == null))
             {
                 // Do nothing if we get no data
                 return;
             }
  
             DataColumnCollection columns = dataRow.Table.Columns;
  
             int i = ;
             // Set the parameters values
             foreach (IDataParameter commandParameter in commandParameters)
             {
                 // Check the parameter name
                 if (commandParameter.ParameterName == null ||
                  commandParameter.ParameterName.Length <= )
                     throw new InvalidOperationException(string.Format(
                      "Please provide a valid parameter name on the parameter #{0}, the ParameterName property has the following value: '{1}'.",
                      i, commandParameter.ParameterName));
  
                 if (columns.Contains(commandParameter.ParameterName))
                     commandParameter.Value = dataRow[commandParameter.ParameterName];
                 else if (columns.Contains(commandParameter.ParameterName.Substring()))
                     commandParameter.Value = dataRow[commandParameter.ParameterName.Substring()];
  
                 i++;
             }
         }
  
         /// <summary>
         /// This method assigns an array of values to an array of IDataParameters
         /// </summary>
         /// <param name="commandParameters">Array of IDataParameters to be assigned values</param>
         /// <param name="parameterValues">Array of objects holding the values to be assigned</param>
         /// <exception cref="System.ArgumentException">Thrown if an incorrect number of parameters are passed.</exception>
         protected void AssignParameterValues(IDataParameter[] commandParameters, params  object[] parameterValues)
         {
             if ((commandParameters == null) || (parameterValues == null))
             {
                 // Do nothing if we get no data
                 return;
             }
  
             // We must have the same number of values as we pave parameters to put them in
             if (commandParameters.Length != parameterValues.Length)
             {
                 throw new ArgumentException("Parameter count does not match Parameter Value count.");
             }
  
             // Iterate through the IDataParameters, assigning the values from the corresponding position in the
             // value array
             for (int i = , j = commandParameters.Length, k = ; i < j; i++)
             {
                 if (commandParameters[i].Direction != ParameterDirection.ReturnValue)
                 {
                     // If the current array value derives from IDataParameter, then assign its Value property
                     if (parameterValues[k] is IDataParameter)
                     {
                         IDataParameter paramInstance;
                         paramInstance = (IDataParameter)parameterValues[k];
                         if (paramInstance.Direction == ParameterDirection.ReturnValue)
                         {
                             paramInstance = (IDataParameter)parameterValues[++k];
                         }
                         if (paramInstance.Value == null)
                         {
                             commandParameters[i].Value = DBNull.Value;
                         }
                         else
                         {
                             commandParameters[i].Value = paramInstance.Value;
                         }
                     }
                     else if (parameterValues[k] == null)
                     {
                         commandParameters[i].Value = DBNull.Value;
                     }
                     else
                     {
                         commandParameters[i].Value = parameterValues[k];
                     }
                     k++;
                 }
             }
         }
     }
 }

Codeproject上的一个封装：http://www.codeproject.com/Articles/746191/SQLite-Helper-Csharp

关于SQLite的connection string说明：http://www.connectionstrings.com/sqlite/

SQLite GUI客户端列表：http://www.sqlite.org/cvstrac/wiki?p=ManagementTools

SQLite Administrator下载地址：http://download.orbmu2k.de/files/sqliteadmin.zip