C#操作SQLite数据库增、删、改、查 欢迎转载

C#操作SQLite数据库增、删、改、查 欢迎转载

转载记得留下链接地址哦！！！

最近项目上要使用SQLite数据库，不怕大伙笑话毕业四年多了，一直使用Oracle或者MySQL或者SQLServer，但是真的是没有用过SQLite数据库，据说非常轻量级，但是真没有用过，于是网上大概搜索下，例子比较多，但是么有一个完整的，即使有，也五花八门。。看的人头晕，可能对于他们大神来讲这都太简单了，算求了更新一篇，新来的小伙伴请看下文，大神你就直接飘过吧!

本例子运行效果

正式开始吧

1.SQLite的下载安装

自然官网下载对应版本即可，我这里下载的是  Precompiled Binaries for 32-bit Windows (.NET Framework 4.0)  不愿意下载的 可以直接使用我下载过的  点击这里下载

2.减压找出我们所需要的库文件   这里我们只需要俩个文件下图所示

3.下载一个数据库管理系统来创建数据库

我是用的是SQLiteStudio3.1.1版本  自己下载吧  下载地址：https://sqlitestudio.pl/index.rvt?act=download

4.创建数据库以及表

这里创建一个简单的表 UserInfo  完了代码中会有这个数据库 在Debug\bin目录下

SQLite数据库文件就一个后缀为.db的文件，就没了。。

通过SQLiteStudio打开该数据库

5.开始使用大伙所熟悉的VS了创建相关类

userinfo的Mode类

  /// <summary>
     /// UserInfo:实体类(属性说明自动提取数据库字段的描述信息)
     /// </summary>
     [Serializable]
     public partial class UserInfo
     {
         public UserInfo()
         { }
         #region Model
         private int _id;
         private string _username;
         private string _pwd;
         private int? _age;
         /// <summary>
         ///
         /// </summary>
         public int ID
         {
             set { _id = value; }
             get { return _id; }
         }
         /// <summary>
         ///
         /// </summary>
         public string UserName
         {
             set { _username = value; }
             get { return _username; }
         }
         /// <summary>
         ///
         /// </summary>
         public string Pwd
         {
             set { _pwd = value; }
             get { return _pwd; }
         }
         /// <summary>
         ///
         /// </summary>
         public int? Age
         {
             set { _age = value; }
             get { return _age; }
         }
         #endregion Model

     }

UserInfo 的Dal类

     /// <summary>
     /// 数据访问类:UserInfo
     /// </summary>
     public partial class UserInfo
     {
         public UserInfo()
         { }
         #region  BasicMethod

         /// <summary>
         /// 得到最大ID
         /// </summary>
         public int GetMaxId()
         {
             return DbHelperSQLite.GetMaxID("ID", "UserInfo");
         }

         /// <summary>
         /// 是否存在该记录
         /// </summary>
         public bool Exists(int ID)
         {
             StringBuilder strSql = new StringBuilder();
             strSql.Append("select count(1) from UserInfo");
             strSql.Append(" where ID=@ID ");
             SQLiteParameter[] parameters = {
                     new SQLiteParameter("@ID", DbType.Int32,)          };
             parameters[].Value = ID;

             return DbHelperSQLite.Exists(strSql.ToString(), parameters);
         }

         /// <summary>
         /// 增加一条数据
         /// </summary>
         public bool Add(Model.UserInfo model)
         {
             StringBuilder strSql = new StringBuilder();
             strSql.Append("insert into UserInfo(");
             strSql.Append("UserName,Pwd,Age)");
             strSql.Append(" values (");
             strSql.Append("@UserName,@Pwd,@Age)");
             SQLiteParameter[] parameters = {
                     new SQLiteParameter("@UserName", DbType.String,),
                     new SQLiteParameter("@Pwd", DbType.String,),
                     new SQLiteParameter("@Age", DbType.Int32,)};
             parameters[].Value = model.UserName;
             parameters[].Value = model.Pwd;
             parameters[].Value = model.Age;

             int rows = DbHelperSQLite.ExecuteSql(strSql.ToString(), parameters);
             if (rows > )
             {
                 return true;
             }
             else
             {
                 return false;
             }
         }
         /// <summary>
         /// 更新一条数据
         /// </summary>
         public bool Update(Model.UserInfo model)
         {
             StringBuilder strSql = new StringBuilder();
             strSql.Append("update UserInfo set ");
             strSql.Append("UserName=@UserName,");
             strSql.Append("Pwd=@Pwd,");
             strSql.Append("Age=@Age");
             strSql.Append(" where ID=@ID ");
             SQLiteParameter[] parameters = {
                     new SQLiteParameter("@UserName", DbType.String,),
                     new SQLiteParameter("@Pwd", DbType.String,),
                     new SQLiteParameter("@Age", DbType.Int32,),
                     new SQLiteParameter("@ID", DbType.Int32,)};
             parameters[].Value = model.UserName;
             parameters[].Value = model.Pwd;
             parameters[].Value = model.Age;
             parameters[].Value = model.ID;

             int rows = DbHelperSQLite.ExecuteSql(strSql.ToString(), parameters);
             if (rows > )
             {
                 return true;
             }
             else
             {
                 return false;
             }
         }

         /// <summary>
         /// 删除一条数据
         /// </summary>
         public bool Delete(int ID)
         {

             StringBuilder strSql = new StringBuilder();
             strSql.Append("delete from UserInfo ");
             strSql.Append(" where ID=@ID ");
             SQLiteParameter[] parameters = {
                     new SQLiteParameter("@ID", DbType.Int32,)          };
             parameters[].Value = ID;

             int rows = DbHelperSQLite.ExecuteSql(strSql.ToString(), parameters);
             if (rows > )
             {
                 return true;
             }
             else
             {
                 return false;
             }
         }
         /// <summary>
         /// 批量删除数据
         /// </summary>
         public bool DeleteList(string IDlist)
         {
             StringBuilder strSql = new StringBuilder();
             strSql.Append("delete from UserInfo ");
             strSql.Append(" where ID in (" + IDlist + ")  ");
             int rows = DbHelperSQLite.ExecuteSql(strSql.ToString());
             if (rows > )
             {
                 return true;
             }
             else
             {
                 return false;
             }
         }

         /// <summary>
         /// 得到一个对象实体
         /// </summary>
         public Model.UserInfo GetModel(int ID)
         {

             StringBuilder strSql = new StringBuilder();
             strSql.Append("select ID,UserName,Pwd,Age from UserInfo ");
             strSql.Append(" where ID=@ID ");
             SQLiteParameter[] parameters = {
                     new SQLiteParameter("@ID", DbType.Int32,)          };
             parameters[].Value = ID;

             Model.UserInfo model = new Model.UserInfo();
             DataSet ds = DbHelperSQLite.Query(strSql.ToString(), parameters);
             if (ds.Tables[].Rows.Count > )
             {
                 return DataRowToModel(ds.Tables[].Rows[]);
             }
             else
             {
                 return null;
             }
         }

         /// <summary>
         /// 得到一个对象实体
         /// </summary>
         public Model.UserInfo DataRowToModel(DataRow row)
         {
             Model.UserInfo model = new Model.UserInfo();
             if (row != null)
             {
                 if (row["ID"] != null && row["ID"].ToString() != "")
                 {
                     model.ID = int.Parse(row["ID"].ToString());
                 }
                 if (row["UserName"] != null)
                 {
                     model.UserName = row["UserName"].ToString();
                 }
                 if (row["Pwd"] != null)
                 {
                     model.Pwd = row["Pwd"].ToString();
                 }
                 if (row["Age"] != null && row["Age"].ToString() != "")
                 {
                     model.Age = int.Parse(row["Age"].ToString());
                 }
             }
             return model;
         }

         /// <summary>
         /// 获得数据列表
         /// </summary>
         public DataSet GetList(string strWhere)
         {
             StringBuilder strSql = new StringBuilder();
             strSql.Append("select ID,UserName,Pwd,Age ");
             strSql.Append(" FROM UserInfo ");
             if (strWhere.Trim() != "")
             {
                 strSql.Append(" where " + strWhere);
             }
             return DbHelperSQLite.Query(strSql.ToString());
         }

         /// <summary>
         /// 获取记录总数
         /// </summary>
         public int GetRecordCount(string strWhere)
         {
             StringBuilder strSql = new StringBuilder();
             strSql.Append("select count(1) FROM UserInfo ");
             if (strWhere.Trim() != "")
             {
                 strSql.Append(" where " + strWhere);
             }
             object obj = DbHelperSQLite.GetSingle(strSql.ToString());
             if (obj == null)
             {
                 return ;
             }
             else
             {
                 return Convert.ToInt32(obj);
             }
         }
         /// <summary>
         /// 分页获取数据列表
         /// </summary>
         public DataSet GetListByPage(string strWhere, string orderby, int startIndex, int endIndex)
         {
             StringBuilder strSql = new StringBuilder();
             strSql.Append("SELECT * FROM ( ");
             strSql.Append(" SELECT ROW_NUMBER() OVER (");
             if (!string.IsNullOrEmpty(orderby.Trim()))
             {
                 strSql.Append("order by T." + orderby);
             }
             else
             {
                 strSql.Append("order by T.ID desc");
             }
             strSql.Append(")AS Row, T.*  from UserInfo T ");
             if (!string.IsNullOrEmpty(strWhere.Trim()))
             {
                 strSql.Append(" WHERE " + strWhere);
             }
             strSql.Append(" ) TT");
             strSql.AppendFormat(" WHERE TT.Row between {0} and {1}", startIndex, endIndex);
             return DbHelperSQLite.Query(strSql.ToString());
         }

         #endregion  BasicMethod
     }

Userinfo的BLL类

     public partial class UserInfo
     {
         private readonly DAL.UserInfo dal = new DAL.UserInfo();
         public UserInfo()
         { }
         #region  BasicMethod

         /// <summary>
         /// 得到最大ID
         /// </summary>
         public int GetMaxId()
         {
             return dal.GetMaxId();
         }

         /// <summary>
         /// 是否存在该记录
         /// </summary>
         public bool Exists(int ID)
         {
             return dal.Exists(ID);
         }

         /// <summary>
         /// 增加一条数据
         /// </summary>
         public bool Add(Model.UserInfo model)
         {
             return dal.Add(model);
         }

         /// <summary>
         /// 更新一条数据
         /// </summary>
         public bool Update(Model.UserInfo model)
         {
             return dal.Update(model);
         }

         /// <summary>
         /// 删除一条数据
         /// </summary>
         public bool Delete(int ID)
         {

             return dal.Delete(ID);
         }
         /// <summary>
         /// 删除一条数据
         /// </summary>
         public bool DeleteList(string IDlist)
         {
             return dal.DeleteList(IDlist);
         }

         /// <summary>
         /// 得到一个对象实体
         /// </summary>
         public Model.UserInfo GetModel(int ID)
         {

             return dal.GetModel(ID);
         }

         ///// <summary>
         ///// 得到一个对象实体，从缓存中
         ///// </summary>
         //public Model.UserInfo GetModelByCache(int ID)
         //{

         //    string CacheKey = "UserInfoModel-" + ID;
         //    object objModel = Common.DataCache.GetCache(CacheKey);
         //    if (objModel == null)
         //    {
         //        try
         //        {
         //            objModel = dal.GetModel(ID);
         //            if (objModel != null)
         //            {
         //                int ModelCache = Maticsoft.Common.ConfigHelper.GetConfigInt("ModelCache");
         //                Maticsoft.Common.DataCache.SetCache(CacheKey, objModel, DateTime.Now.AddMinutes(ModelCache), TimeSpan.Zero);
         //            }
         //        }
         //        catch { }
         //    }
         //    return (Maticsoft.Model.UserInfo)objModel;
         //}

         /// <summary>
         /// 获得数据列表
         /// </summary>
         public DataSet GetList(string strWhere)
         {
             return dal.GetList(strWhere);
         }
         /// <summary>
         /// 获得数据列表
         /// </summary>
         public List<Model.UserInfo> GetModelList(string strWhere)
         {
             DataSet ds = dal.GetList(strWhere);
             return DataTableToList(ds.Tables[]);
         }
         /// <summary>
         /// 获得数据列表
         /// </summary>
         public List<Model.UserInfo> DataTableToList(DataTable dt)
         {
             List<Model.UserInfo> modelList = new List<Model.UserInfo>();
             int rowsCount = dt.Rows.Count;
             if (rowsCount > )
             {
                 Model.UserInfo model;
                 for (int n = ; n < rowsCount; n++)
                 {
                     model = dal.DataRowToModel(dt.Rows[n]);
                     if (model != null)
                     {
                         modelList.Add(model);
                     }
                 }
             }
             return modelList;
         }

         /// <summary>
         /// 获得数据列表
         /// </summary>
         public DataSet GetAllList()
         {
             return GetList("");
         }

         /// <summary>
         /// 分页获取数据列表
         /// </summary>
         public int GetRecordCount(string strWhere)
         {
             return dal.GetRecordCount(strWhere);
         }
         /// <summary>
         /// 分页获取数据列表
         /// </summary>
         public DataSet GetListByPage(string strWhere, string orderby, int startIndex, int endIndex)
         {
             return dal.GetListByPage(strWhere, orderby, startIndex, endIndex);
         }
         /// <summary>
         /// 分页获取数据列表
         /// </summary>
         //public DataSet GetList(int PageSize,int PageIndex,string strWhere)
         //{
         //return dal.GetList(PageSize,PageIndex,strWhere);
         //}

         #endregion  BasicMethod
         #region  ExtensionMethod

         #endregion  ExtensionMethod
     }

创建SQLite帮助类

     /// <summary>
     /// 数据访问基础类(基于SQLite)
     /// 可以用户可以修改满足自己项目的需要。
     /// </summary>
     public abstract class DbHelperSQLite
     {
         //数据库连接字符串(web.config来配置)，可以动态更改connectionString支持多数据库.
         public static string connectionString = CreateConnectionString();
         public DbHelperSQLite()
         {
         }
         private static string CreateConnectionString()
         {

             string dbName = ConfigurationManager.AppSettings["SQLiteDB"];
             string sqlLitePath = "data source=" + System.Environment.CurrentDirectory+"\\"+dbName + ";version=3;";
             return sqlLitePath;
         }

         #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="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>
         /// 向数据库里插入图像格式的字段(和上面情况类似的另一种实例)
         /// </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
         /// </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);
             }

         }
         /// <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;
             }
         }

         #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
         /// </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);
             }

         }

         /// <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;
                 }
             }
         }

         private 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 parm in cmdParms)
                     cmd.Parameters.Add(parm);
             }
         }

         #endregion

     }

6.创建一个WinForm窗体用于测试

大概是这样的，我用的是VS2017

数据库配置文件新增App.config文件  其余的没有用，是Mysql的连接字符串，可以不用管。。。

窗体代码大概是这样的比较简单，只是实现简单的操作，具体细节那就交个大家了。。。

    public partial class Form1 : Form
     {
         public Form1()
         {
             InitializeComponent();
         }

         BLL.UserInfo bll = new BLL.UserInfo();

         //数据库连接
         SQLiteConnection m_dbConnection;
         private void button1_Click(object sender, EventArgs e)
         {

             DataSet ds =  bll.GetAllList();

             this.dataGridView1.DataSource = ds.Tables[];

         }

         int count = ;
         private void button2_Click(object sender, EventArgs e)
         {
             count++;
             Model.UserInfo userInfo = new Model.UserInfo();
             userInfo.UserName = "Count" + count;
             userInfo.Pwd = "";
             userInfo.Age = count;

             bll.Add(userInfo);

             DataSet ds = bll.GetAllList();
             this.dataGridView1.DataSource = ds.Tables[];

         }

         private void button3_Click(object sender, EventArgs e)
         {

             Model.UserInfo userInfo = new Model.UserInfo();
             userInfo.ID = int.Parse(this.label1.Text);
             userInfo.UserName = this.textBox1.Text;
             userInfo.Pwd = this.textBox2.Text;
             userInfo.Age = int.Parse(this.textBox3.Text);
             bll.Update(userInfo);

             DataSet ds = bll.GetAllList();
             this.dataGridView1.DataSource = ds.Tables[];

         }

         private void dataGridView1_MouseClick(object sender, MouseEventArgs e)
         {
             DataGridViewRow row = this.dataGridView1.CurrentRow;
             this.label1.Text = row.Cells[].Value.ToString();
             this.textBox1.Text = row.Cells[].Value.ToString();
             this.textBox2.Text = row.Cells[].Value.ToString();
             this.textBox3.Text = row.Cells[].Value.ToString();

         }

         private void button4_Click(object sender, EventArgs e)
         {
             bll.Delete(int.Parse(this.label1.Text));

             DataSet ds = bll.GetAllList();
             this.dataGridView1.DataSource = ds.Tables[];
         }

         private void linkLabel1_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
         {

             Process.Start("IExplore", "https://www.cnblogs.com/JiYF/");
         }
     }

7.运行效果

8.项目结构文件

到这里就完了，新手自己去下载调试吧，。。。。。爱你们哟  么么哒！❥(^_-)

源代码工程下载地址

或者博客留言，给出邮箱，发你！！！

直接下载：https://files.cnblogs.com/files/JiYF/SQLiteDBTest.rar

温馨小提示：

SQLite版本问题，如果你使用的32位，记得项目编译采用X86   如果你是64位则采用X64  否则会提示错误信息，就酱紫。。。。。。。。。。