SQLite的使用

通常在大型系统和网站一般使用的数据基本上就是Oracle，MySQL，MSSqlServer三种。但是在某些情况下会相对麻烦，如果仅仅需要在客户端保存一些数据。SQLite无疑是最佳选择之一。他是一种轻量级数据库。不用安装任何插件或者软件来辅助，只是一个简单的文件。直接打包在客户端程序内即可。

1，创建Sqlite。

为了方便程序开发，一般把Sqlite签入Vs内部当做一个插件来使用。默认Vs是不支持Sqlite的，为了让其支持我们需要下载SQLite-1.0.66.0-setup.exe  进行安装，这时候你会发现vs的的数据源连接中多了一项：

为了及时观察sqlite数据中数据变化，每次都打开vs连接再查看很费时间，只需要下载一个特小的软件即可轻松搞定。下载地址： SQLite Database Browser.exe    下载后解压到桌面，+98

aaarticlea/png;base64,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" alt="" />

选择此数据源。确定

aaarticlea/png;base64,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" alt="" />

点击New用来创建一个sqlite的数据库文件。  点击Browse用来打开已存在的数据库文件。

现在数据库已经创建，然后就是创建表，

aaarticlea/png;base64,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" alt="" />

右键Tables选择创建表，接下来的操作和mssqlserver基本一样。这里不具体描述。可能会在后面章节详细介绍。只能说可能会介绍，但是如何在代码中对sqlite数据操作肯定会介绍的。如果你想使用sqlite。后面的内容一定会帮到你。

2.操作数据库

和其他数据库类似，既然要对数据库进行一系列的操作（增删改查）少不了一套方法， 和其他数据库的命令大同小异。

下面封装的一个SqliteHelper类。

 using System;
    using System.Collections;
    using System.Collections.Specialized;
   using System.Data;
   using System.Data.SQLite;
   using System.Configuration;

   namespace Test
   {
       public class SqliteHelper
       {
           //数据库连接字符串(web.config来配置)，可以动态更改SQLString支持多数据库.
           public static string connectionString = "Data Source=test";

           public SqliteHelper() { }

           #region 公用方法

           public static int GetMaxID(string FieldName, string TableName)
           {
               string strsql = "select max(" + FieldName + ")+1 from " + TableName;
               object obj = GetSingle(strsql);
               if (obj == null)
               {
                   return ;
               }
               else
               {
                   return int.Parse(obj.ToString());
               }
           }

           public static bool Exists(string strSql)
           {
               object obj = GetSingle(strSql);
               int cmdresult;
               if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
               {
                   cmdresult = ;
               }
               else
               {
                   cmdresult = int.Parse(obj.ToString());
               }
               if (cmdresult == )
               {
                   return false;
               }
               else
               {
                   return true;
               }
           }

           public static bool Exists(string strSql, params SQLiteParameter[] cmdParms)
           {
               object obj = GetSingle(strSql, cmdParms);
               int cmdresult;
               if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
               {
                   cmdresult = ;
               }
               else
               {
                   cmdresult = int.Parse(obj.ToString());
               }
               if (cmdresult == )
               {
                   return false;
               }
               else
               {
                   return true;
               }
           }

           #endregion

           #region  执行简单SQL语句

           /// <summary>
           /// 执行SQL语句，返回影响的记录数
           /// </summary>
           /// <param name="SQLString">SQL语句</param>
           /// <returns>影响的记录数</returns>
           public static int ExecuteSql(string SQLString)
           {
               using (SQLiteConnection connection = new SQLiteConnection(connectionString))
               {
                   using (SQLiteCommand cmd = new SQLiteCommand(SQLString, connection))
                   {
                      try
                      {
                          connection.Open();
                          int rows = cmd.ExecuteNonQuery();
                          return rows;
                      }
                      catch (System.Data.SQLite.SQLiteException E)
                      {
                          connection.Close();
                          throw new Exception(E.Message);
                      }
                  }
              }
          }

          /// <summary>
          /// 执行SQL语句，设置命令的执行等待时间
          /// </summary>
          /// <param name="SQLString"></param>
          /// <param name="Times"></param>
          /// <returns></returns>
          public static int ExecuteSqlByTime(string SQLString, int Times)
          {
              using (SQLiteConnection connection = new SQLiteConnection(connectionString))
              {
                  using (SQLiteCommand cmd = new SQLiteCommand(SQLString, connection))
                  {
                      try
                      {
                          connection.Open();
                          cmd.CommandTimeout = Times;
                          int rows = cmd.ExecuteNonQuery();
                          return rows;
                      }
                      catch (System.Data.SQLite.SQLiteException E)
                      {
                          connection.Close();
                          throw new Exception(E.Message);
                      }
                  }
              }
          }

          /// <summary>
          /// 执行多条SQL语句，实现数据库事务。
          /// </summary>
          /// <param name="SQLStringList">多条SQL语句</param>
          public static void ExecuteSqlTran(ArrayList SQLStringList)
          {
              using (SQLiteConnection conn = new SQLiteConnection(connectionString))
              {
                  conn.Open();
                  SQLiteCommand cmd = new SQLiteCommand();
                  cmd.Connection = conn;
                  SQLiteTransaction tx = conn.BeginTransaction();
                  cmd.Transaction = tx;
                  try
                  {
                      for (int n = ; n < SQLStringList.Count; n++)
                      {
                          string strsql = SQLStringList[n].ToString();
                          if (strsql.Trim().Length > )
                          {
                              cmd.CommandText = strsql;
                              cmd.ExecuteNonQuery();
                          }
                      }
                      tx.Commit();
                  }
                  catch (System.Data.SQLite.SQLiteException E)
                  {
                      tx.Rollback();
                      throw new Exception(E.Message);
                  }
              }
          }

          /// <summary>
          /// 执行带一个存储过程参数的的SQL语句。
          /// </summary>
          /// <param name="SQLString">SQL语句</param>
          /// <param name="content">参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加</param>
          /// <returns>影响的记录数</returns>
          public static int ExecuteSql(string SQLString, string content)
          {
              using (SQLiteConnection connection = new SQLiteConnection(connectionString))
              {
                  SQLiteCommand cmd = new SQLiteCommand(SQLString, connection);
                  SQLiteParameter myParameter = new SQLiteParameter("@content", DbType.String);
                  myParameter.Value = content;
                  cmd.Parameters.Add(myParameter);
                  try
                  {
                      connection.Open();
                      int rows = cmd.ExecuteNonQuery();
                      return rows;
                  }
                  catch (System.Data.SQLite.SQLiteException E)
                  {
                      throw new Exception(E.Message);
                  }
                  finally
                  {
                      cmd.Dispose();
                      connection.Close();
                  }
              }
          }

          /// <summary>
          /// 执行带一个存储过程参数的的SQL语句。
          /// </summary>
          /// <param name="SQLString">SQL语句</param>
          /// <param name="content">参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加</param>
          /// <returns>影响的记录数</returns>
          public static object ExecuteSqlGet(string SQLString, string content)
          {
              using (SQLiteConnection connection = new SQLiteConnection(connectionString))
              {
                  SQLiteCommand cmd = new SQLiteCommand(SQLString, connection);
                  SQLiteParameter myParameter = new SQLiteParameter("@content", DbType.String);
                  myParameter.Value = content;
                  cmd.Parameters.Add(myParameter);
                  try
                  {
                      connection.Open();
                      object obj = cmd.ExecuteScalar();
                      if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
                      {
                          return null;
                      }
                      else
                      {
                          return obj;
                      }
                  }
                  catch (System.Data.SQLite.SQLiteException E)
                  {
                      throw new Exception(E.Message);
                  }
                  finally
                  {
                      cmd.Dispose();
                      connection.Close();
                  }
              }
          }

          /// <summary>
          /// 向数据库里插入图像格式的字段(和上面情况类似的另一种实例)
          /// </summary>
          /// <param name="strSQL">SQL语句</param>
          /// <param name="fs">图像字节,数据库的字段类型为image的情况</param>
          /// <returns>影响的记录数</returns>
          public static int ExecuteSqlInsertImg(string strSQL, byte[] fs)
          {
              using (SQLiteConnection connection = new SQLiteConnection(connectionString))
              {
                  SQLiteCommand cmd = new SQLiteCommand(strSQL, connection);
                  SQLiteParameter myParameter = new SQLiteParameter("@fs", DbType.Binary);
                  myParameter.Value = fs;
                  cmd.Parameters.Add(myParameter);
                  try
                  {
                      connection.Open();
                      int rows = cmd.ExecuteNonQuery();
                      return rows;
                  }
                  catch (System.Data.SQLite.SQLiteException E)
                  {
                      throw new Exception(E.Message);
                  }
                  finally
                  {
                      cmd.Dispose();
                      connection.Close();
                  }
              }
          }

          /// <summary>
          /// 执行一条计算查询结果语句，返回查询结果（object）。
          /// </summary>
          /// <param name="SQLString">计算查询结果语句</param>
          /// <returns>查询结果（object）</returns>
          public static object GetSingle(string SQLString)
          {
              using (SQLiteConnection connection = new SQLiteConnection(connectionString))
              {
                  using (SQLiteCommand cmd = new SQLiteCommand(SQLString, connection))
                  {
                      try
                      {
                          connection.Open();
                          object obj = cmd.ExecuteScalar();
                          if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
                          {
                              return null;
                          }
                          else
                          {
                              return obj;
                          }
                      }
                      catch (System.Data.SQLite.SQLiteException e)
                      {
                          connection.Close();
                          throw new Exception(e.Message);
                      }
                  }
              }
          }

          /// <summary>
          /// 执行查询语句，返回SQLiteDataReader(使用该方法切记要手工关闭SQLiteDataReader和连接)
          /// </summary>
          /// <param name="strSQL">查询语句</param>
          /// <returns>SQLiteDataReader</returns>
          public static SQLiteDataReader ExecuteReader(string strSQL)
          {
              SQLiteConnection connection = new SQLiteConnection(connectionString);
              SQLiteCommand cmd = new SQLiteCommand(strSQL, connection);
              try
              {
                  connection.Open();
                  SQLiteDataReader myReader = cmd.ExecuteReader();
                  return myReader;
              }
              catch (System.Data.SQLite.SQLiteException e)
              {
                  throw new Exception(e.Message);
              }
              //finally //不能在此关闭，否则，返回的对象将无法使用
              //{
              //    cmd.Dispose();
              //    connection.Close();
              //}
          }

          /// <summary>
          /// 执行查询语句，返回DataSet
          /// </summary>
          /// <param name="SQLString">查询语句</param>
          /// <returns>DataSet</returns>
          public static DataSet Query(string SQLString)
          {
              using (SQLiteConnection connection = new SQLiteConnection(connectionString))
              {
                  DataSet ds = new DataSet();
                  try
                  {
                      connection.Open();
                      SQLiteDataAdapter command = new SQLiteDataAdapter(SQLString, connection);
                      command.Fill(ds, "ds");
                  }
                  catch (System.Data.SQLite.SQLiteException ex)
                  {
                      throw new Exception(ex.Message);
                  }
                  return ds;
              }
          }

          public static DataSet Query(string SQLString, string TableName)
          {
              using (SQLiteConnection connection = new SQLiteConnection(connectionString))
              {
                  DataSet ds = new DataSet();
                  try
                  {
                      connection.Open();
                      SQLiteDataAdapter command = new SQLiteDataAdapter(SQLString, connection);
                      command.Fill(ds, TableName);
                  }
                  catch (System.Data.SQLite.SQLiteException ex)
                  {
                      throw new Exception(ex.Message);
                  }
                  return ds;
              }
          }

          /// <summary>
          /// 执行查询语句，返回DataSet,设置命令的执行等待时间
          /// </summary>
          /// <param name="SQLString"></param>
          /// <param name="Times"></param>
          /// <returns></returns>
          public static DataSet Query(string SQLString, int Times)
          {
              using (SQLiteConnection connection = new SQLiteConnection(connectionString))
              {
                  DataSet ds = new DataSet();
                  try
                  {
                      connection.Open();
                      SQLiteDataAdapter command = new SQLiteDataAdapter(SQLString, connection);
                      command.SelectCommand.CommandTimeout = Times;
                      command.Fill(ds, "ds");
                  }
                  catch (System.Data.SQLite.SQLiteException ex)
                  {
                      throw new Exception(ex.Message);
                  }
                  return ds;
              }
          }

          #endregion

          #region 执行带参数的SQL语句

          /// <summary>
          /// 执行SQL语句，返回影响的记录数
          /// </summary>
          /// <param name="SQLString">SQL语句</param>
          /// <returns>影响的记录数</returns>
          public static int ExecuteSql(string SQLString, params SQLiteParameter[] cmdParms)
          {
              using (SQLiteConnection connection = new SQLiteConnection(connectionString))
              {
                  using (SQLiteCommand cmd = new SQLiteCommand())
                  {
                      try
                      {
                          PrepareCommand(cmd, connection, null, SQLString, cmdParms);
                          int rows = cmd.ExecuteNonQuery();
                          cmd.Parameters.Clear();
                          return rows;
                      }
                      catch (System.Data.SQLite.SQLiteException E)
                      {
                          throw new Exception(E.Message);
                      }
                  }
              }
          }

          /// <summary>
          /// 执行多条SQL语句，实现数据库事务。
          /// </summary>
          /// <param name="SQLStringList">SQL语句的哈希表（key为sql语句，value是该语句的SQLiteParameter[]）</param>
          public static void ExecuteSqlTran(Hashtable SQLStringList)
          {
              using (SQLiteConnection conn = new SQLiteConnection(connectionString))
              {
                  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);
                              int val = cmd.ExecuteNonQuery();
                              cmd.Parameters.Clear();

                              trans.Commit();
                          }
                      }
                      catch
                      {
                          trans.Rollback();
                          throw;
                      }
                  }
              }
          }

          /// <summary>
          /// 执行一条计算查询结果语句，返回查询结果（object）。
          /// </summary>
          /// <param name="SQLString">计算查询结果语句</param>
          /// <returns>查询结果（object）</returns>
          public static object GetSingle(string SQLString, params SQLiteParameter[] cmdParms)
          {
              using (SQLiteConnection connection = new SQLiteConnection(connectionString))
              {
                  using (SQLiteCommand cmd = new SQLiteCommand())
                  {
                      try
                      {
                          PrepareCommand(cmd, connection, null, SQLString, cmdParms);
                          object obj = cmd.ExecuteScalar();
                          cmd.Parameters.Clear();
                          if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
                          {
                              return null;
                          }
                          else
                          {
                              return obj;
                          }
                      }
                      catch (System.Data.SQLite.SQLiteException e)
                      {
                          throw new Exception(e.Message);
                      }
                  }
              }
          }

          /// <summary>
          /// 执行查询语句，返回SQLiteDataReader (使用该方法切记要手工关闭SQLiteDataReader和连接)
          /// </summary>
          /// <param name="strSQL">查询语句</param>
          /// <returns>SQLiteDataReader</returns>
          public static SQLiteDataReader ExecuteReader(string SQLString, params SQLiteParameter[] cmdParms)
          {
              SQLiteConnection connection = new SQLiteConnection(connectionString);
              SQLiteCommand cmd = new SQLiteCommand();
              try
              {
                  PrepareCommand(cmd, connection, null, SQLString, cmdParms);
                  SQLiteDataReader myReader = cmd.ExecuteReader();
                  cmd.Parameters.Clear();
                  return myReader;
              }
              catch (System.Data.SQLite.SQLiteException e)
              {
                  throw new Exception(e.Message);
              }
              //finally //不能在此关闭，否则，返回的对象将无法使用
              //{
              //    cmd.Dispose();
              //    connection.Close();
              //}    

          }

          /// <summary>
          /// 执行查询语句，返回DataSet
          /// </summary>
          /// <param name="SQLString">查询语句</param>
          /// <returns>DataSet</returns>
          public static DataSet Query(string SQLString, params SQLiteParameter[] cmdParms)
          {
              using (SQLiteConnection connection = new SQLiteConnection(connectionString))
              {
                  SQLiteCommand cmd = new SQLiteCommand();
                  PrepareCommand(cmd, connection, null, SQLString, cmdParms);
                  using (SQLiteDataAdapter da = new SQLiteDataAdapter(cmd))
                  {
                      DataSet ds = new DataSet();
                      try
                      {
                          da.Fill(ds, "ds");
                          cmd.Parameters.Clear();
                      }
                      catch (System.Data.SQLite.SQLiteException ex)
                      {
                          throw new Exception(ex.Message);
                      }
                      return ds;
                  }
              }
          }

          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;//cmdType;
              if (cmdParms != null)
              {

                  foreach (SQLiteParameter parameter in cmdParms)
                  {
                      if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) &&
                          (parameter.Value == null))
                      {
                          parameter.Value = DBNull.Value;
                      }
                      cmd.Parameters.Add(parameter);
                  }
              }
          }

          #endregion

          #region 参数转换
          /// <summary>
          /// 放回一个SQLiteParameter
          /// </summary>
          /// <param name="name">参数名字</param>
          /// <param name="type">参数类型</param>
          /// <param name="size">参数大小</param>
          /// <param name="value">参数值</param>
          /// <returns>SQLiteParameter的值</returns>
          public static SQLiteParameter MakeSQLiteParameter(string name, DbType type, int size, object value)
          {
              SQLiteParameter parm = new SQLiteParameter(name, type, size);
              parm.Value = value;
              return parm;
          }

          public static SQLiteParameter MakeSQLiteParameter(string name, DbType type, object value)
          {
              SQLiteParameter parm = new SQLiteParameter(name, type);
              parm.Value = value;
              return parm;
          }

          #endregion
      }
  }

通过这个基本满足对sqlite的操作。