devbox
Li_阴宅
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

第五章，人脸识别与管理系统开发之登录窗体实现（密码登录）_wpf人脸识别登录

作者：Li_阴宅 | 2024-07-28 11:34:49

赞

踩

wpf人脸识别登录

摘要：通过人脸识别与管理系统界面的开发（WinForm界面增强，OpenCV-Python智能识别），我将以一个用户登录窗体的两种不同登录验证方式向各位同学介绍如何利用WinForm开发出漂亮的应用程序窗体，为我们后面的各个章节中的窗体开发打下基础。另外也会向各位同学介绍WinForrm窗体如何调用Python程序让OpenCV-Python程序嵌入到我们的登录窗体中，从而实现人脸识别的。博文提供了完整的Python代码和使用教程，适合新入门的朋友参考，完整代码资源文件请转至文末的下载链接。本博文目录如下：

本章节主要介绍的内容如下：

一，如何利用WinForm三层架构(表现层UI，业务逻辑层BLL，数据访问层DAL，实体类Model)实现用户登录。

目录

一，如何利用WinForm三层架构(表现层UI，业务逻辑层BLL，数据访问层DAL，实体类Model)实现用户登录。

1，创建数据库表

2，数据库维护工具 SQLiteStudio

3，实体类Model 创建

4，数据访问层DAL 创建

5，业务逻辑层BLL 创建

6，数据库操作帮助类

7，UI层调用

8，登录成功后进入主窗体

9，源码分享，教学ppt分享

10，写在最后

========================================================================
1，创建数据库表

        本系统使用的数据库为Sqlite3，创建表 sql如下：

  1. PRAGMA foreign_keys = off;
  2. BEGIN TRANSACTION;
  3.  
  4. -- Table: UserInfo
  5. CREATE TABLE UserInfo (ID VARCHAR (25) PRIMARY KEY, UserName VARCHAR (50), Pwd VARCHAR (25), Tel VARCHAR (25), Gender VARCHAR (25), Email VARCHAR (50), Idcard VARCHAR (50), Faceinfo VARCHAR (400));
  6.  
  7. INSERT INTO UserInfo (ID, UserName, Pwd, Tel, Gender, Email, Idcard, Faceinfo) VALUES ('1', 'chenjq', '111111', '13545250214', 'N', '554951056@qq.com', '420982198407189834', NULL);
  8.  
  9.  
  10. -- Index: sqlite_autoindex_UserInfo_1
  11. CREATE INDEX sqlite_autoindex_UserInfo_1 ON UserInfo (ID COLLATE BINARY);
  12.  
  13. COMMIT TRANSACTION;
  14. PRAGMA foreign_keys = on;

2，数据库维护工具 SQLiteStudio

3，实体类Model 创建

  1. /// <summary>
  2.     /// UserInfo:实体类(属性说明自动提取数据库字段的描述信息)
  3.     /// </summary>
  4.     [Serializable]
  5.     public partial class UserInfo
  6.     {
  7.         public UserInfo()
  8.         { }
  9.         #region Model
  10.         private string _id;
  11.         private string _username;
  12.         private string _pwd;
  13.         private string _tel;
  14.         private string _gender;
  15.         private string _email;
  16.         private string _idcard;
  17.         /// <summary>
  18.         ///
  19.         /// </summary>
  20.         public string ID
  21.         {
  22.             set { _id = value; }
  23.             get { return _id; }
  24.         }
  25.         /// <summary>
  26.         ///
  27.         /// </summary>
  28.         public string UserName
  29.         {
  30.             set { _username = value; }
  31.             get { return _username; }
  32.         }
  33.         /// <summary>
  34.         ///
  35.         /// </summary>
  36.         public string Pwd
  37.         {
  38.             set { _pwd = value; }
  39.             get { return _pwd; }
  40.         }
  41.         /// <summary>
  42.         ///
  43.         /// </summary>
  44.         public string Tel
  45.         {
  46.             set { _tel = value; }
  47.             get { return _tel; }
  48.         }
  49.         /// <summary>
  50.         ///
  51.         /// </summary>
  52.         public string Gender
  53.         {
  54.             set { _gender = value; }
  55.             get { return _gender; }
  56.         }
  57.         /// <summary>
  58.         ///
  59.         /// </summary>
  60.         public string Email
  61.         {
  62.             set { _email = value; }
  63.             get { return _email; }
  64.         }
  65.         /// <summary>
  66.         ///
  67.         /// </summary>
  68.         public string IdCard
  69.         {
  70.             set { _idcard = value; }
  71.             get { return _idcard; }
  72.         }
  73.         #endregion Model
  74.  
  75.     }

4，数据访问层DAL 创建

  1. /// <summary>
  2.     /// 数据访问类:UserInfo
  3.     /// </summary>
  4.     public partial class UserInfo
  5.     {
  6.         public UserInfo()
  7.         { }
  8.         #region  BasicMethod
  9.  
  10.         /// <summary>
  11.         /// 得到最大ID
  12.         /// </summary>
  13.         public int GetMaxId()
  14.         {
  15.             return DbHelperSQLite.GetMaxID("ID", "UserInfo");
  16.         }
  17.  
  18.         /// <summary>
  19.         /// 是否存在该记录
  20.         /// </summary>
  21.         public bool Exists(int ID)
  22.         {
  23.             StringBuilder strSql = new StringBuilder();
  24.             strSql.Append("select count(1) from UserInfo");
  25.             strSql.Append(" where ID=@ID ");
  26.             SQLiteParameter[] parameters = {
  27.                     new SQLiteParameter("@ID", DbType.String,25)          };
  28.             parameters[0].Value = ID;
  29.  
  30.             return DbHelperSQLite.Exists(strSql.ToString(), parameters);
  31.         }
  32.  
  33.  
  34.         /// <summary>
  35.         /// 增加一条数据
  36.         /// </summary>
  37.         public bool Add(Model.UserInfo model)
  38.         {
  39.             StringBuilder strSql = new StringBuilder();
  40.             strSql.Append("insert into UserInfo(");
  41.             strSql.Append("UserName,Pwd,Tel,Gender,Email,Idcard)");
  42.             strSql.Append(" values (");
  43.             strSql.Append("@UserName,@Pwd,@Tel,@Gender,@Email,@Idcard)");
  44.             SQLiteParameter[] parameters = {
  45.                     new SQLiteParameter("@Id", DbType.String,25),
  46.                     new SQLiteParameter("@UserName", DbType.String,50),
  47.                     new SQLiteParameter("@Pwd", DbType.String,25),
  48.                     new SQLiteParameter("@Tel", DbType.String,25),
  49.                     new SQLiteParameter("@Gender", DbType.String,25),
  50.                     new SQLiteParameter("@Email", DbType.String,50),
  51.                     new SQLiteParameter("@Idcard", DbType.String,50)};
  52.             parameters[0].Value = model.ID;
  53.             parameters[1].Value = model.UserName;
  54.             parameters[2].Value = model.Pwd;
  55.             parameters[3].Value = model.Tel;
  56.             parameters[4].Value = model.Gender;
  57.             parameters[5].Value = model.Email;
  58.             parameters[6].Value = model.IdCard;
  59.  
  60.             int rows = DbHelperSQLite.ExecuteSql(strSql.ToString(), parameters);
  61.             if (rows > 0)
  62.             {
  63.                 return true;
  64.             }
  65.             else
  66.             {
  67.                 return false;
  68.             }
  69.         }
  70.         /// <summary>
  71.         /// 更新一条数据
  72.         /// </summary>
  73.         public bool Update(Model.UserInfo model)
  74.         {
  75.             StringBuilder strSql = new StringBuilder();
  76.             strSql.Append("update UserInfo set ");
  77.             strSql.Append("UserName=@UserName,");
  78.             strSql.Append("Pwd=@Pwd,");
  79.             strSql.Append("Tel=@Tel");
  80.             strSql.Append("Gender=@Gender");
  81.             strSql.Append("Email=@Email");
  82.             strSql.Append("IdCard=@IdCard");
  83.             strSql.Append(" where ID=@ID ");
  84.             SQLiteParameter[] parameters = {
  85.                     new SQLiteParameter("@UserName", DbType.String,50),
  86.                     new SQLiteParameter("@Pwd", DbType.String,25),
  87.                     new SQLiteParameter("@Tel", DbType.String,25),
  88.                     new SQLiteParameter("@Gender", DbType.String,25),
  89.                     new SQLiteParameter("@Email", DbType.String,50),
  90.                     new SQLiteParameter("@IdCard", DbType.String,50),
  91.                     new SQLiteParameter("@ID", DbType.String,25)};
  92.             parameters[0].Value = model.UserName;
  93.             parameters[1].Value = model.Pwd;
  94.             parameters[2].Value = model.Tel;
  95.             parameters[3].Value = model.Gender;
  96.             parameters[4].Value = model.Email;
  97.             parameters[5].Value = model.IdCard;
  98.             parameters[6].Value = model.ID;
  99.  
  100.             int rows = DbHelperSQLite.ExecuteSql(strSql.ToString(), parameters);
  101.             if (rows > 0)
  102.             {
  103.                 return true;
  104.             }
  105.             else
  106.             {
  107.                 return false;
  108.             }
  109.         }
  110.  
  111.         /// <summary>
  112.         /// 删除一条数据
  113.         /// </summary>
  114.         public bool Delete(int ID)
  115.         {
  116.  
  117.             StringBuilder strSql = new StringBuilder();
  118.             strSql.Append("delete from UserInfo ");
  119.             strSql.Append(" where ID=@ID ");
  120.             SQLiteParameter[] parameters = {
  121.                     new SQLiteParameter("@ID", DbType.String,25)          };
  122.             parameters[0].Value = ID;
  123.  
  124.             int rows = DbHelperSQLite.ExecuteSql(strSql.ToString(), parameters);
  125.             if (rows > 0)
  126.             {
  127.                 return true;
  128.             }
  129.             else
  130.             {
  131.                 return false;
  132.             }
  133.         }
  134.         /// <summary>
  135.         /// 批量删除数据
  136.         /// </summary>
  137.         public bool DeleteList(string IDlist)
  138.         {
  139.             StringBuilder strSql = new StringBuilder();
  140.             strSql.Append("delete from UserInfo ");
  141.             strSql.Append(" where ID in (" + IDlist + ")  ");
  142.             int rows = DbHelperSQLite.ExecuteSql(strSql.ToString());
  143.             if (rows > 0)
  144.             {
  145.                 return true;
  146.             }
  147.             else
  148.             {
  149.                 return false;
  150.             }
  151.         }
  152.  
  153.  
  154.         /// <summary>
  155.         /// 得到一个对象实体
  156.         /// </summary>
  157.         public Model.UserInfo GetModel(int ID)
  158.         {
  159.  
  160.             StringBuilder strSql = new StringBuilder();
  161.             strSql.Append("select ID,UserName,Pwd,Tel,Gender,Email,Idcard from UserInfo ");
  162.             strSql.Append(" where ID=@ID ");
  163.             SQLiteParameter[] parameters = {
  164.                     new SQLiteParameter("@ID", DbType.String,25)          };
  165.             parameters[0].Value = ID;
  166.  
  167.             Model.UserInfo model = new Model.UserInfo();
  168.             DataSet ds = DbHelperSQLite.Query(strSql.ToString(), parameters);
  169.             if (ds.Tables[0].Rows.Count > 0)
  170.             {
  171.                 return DataRowToModel(ds.Tables[0].Rows[0]);
  172.             }
  173.             else
  174.             {
  175.                 return null;
  176.             }
  177.         }
  178.  
  179.  
  180.         /// <summary>
  181.         /// 得到一个对象实体
  182.         /// </summary>
  183.         public Model.UserInfo DataRowToModel(DataRow row)
  184.         {
  185.             Model.UserInfo model = new Model.UserInfo();
  186.             if (row != null)
  187.             {
  188.                 if (row["ID"] != null && row["ID"].ToString() != "")
  189.                 {
  190.                     model.ID = row["ID"].ToString();
  191.                 }
  192.                 if (row["UserName"] != null)
  193.                 {
  194.                     model.UserName = row["UserName"].ToString();
  195.                 }
  196.                 if (row["Pwd"] != null)
  197.                 {
  198.                     model.Pwd = row["Pwd"].ToString();
  199.                 }
  200.                 if (row["Tel"] != null && row["Tel"].ToString() != "")
  201.                 {
  202.                     model.Tel = row["Tel"].ToString();
  203.                 }
  204.                 if (row["Gender"] != null)
  205.                 {
  206.                     model.Gender = row["Gender"].ToString();
  207.                 }
  208.                 if (row["Email"] != null)
  209.                 {
  210.                     model.Email = row["Email"].ToString();
  211.                 }
  212.                 if (row["Idcard"] != null)
  213.                 {
  214.                     model.IdCard = row["Idcard"].ToString();
  215.                 }
  216.             }
  217.             return model;
  218.         }
  219.  
  220.         /// <summary>
  221.         /// 获得数据列表
  222.         /// </summary>
  223.         public DataSet GetList(string strWhere)
  224.         {
  225.             StringBuilder strSql = new StringBuilder();
  226.             strSql.Append("select ID,UserName,Pwd,Tel,Gender,Email,Idcard ");
  227.             strSql.Append(" FROM UserInfo ");
  228.             if (strWhere.Trim() != "")
  229.             {
  230.                 strSql.Append(" where " + strWhere);
  231.             }
  232.             return DbHelperSQLite.Query(strSql.ToString());
  233.         }
  234.  
  235.         /// <summary>
  236.         /// 获取记录总数
  237.         /// </summary>
  238.         public int GetRecordCount(string strWhere)
  239.         {
  240.             StringBuilder strSql = new StringBuilder();
  241.             strSql.Append("select count(1) FROM UserInfo ");
  242.             if (strWhere.Trim() != "")
  243.             {
  244.                 strSql.Append(" where " + strWhere);
  245.             }
  246.             object obj = DbHelperSQLite.GetSingle(strSql.ToString());
  247.             if (obj == null)
  248.             {
  249.                 return 0;
  250.             }
  251.             else
  252.             {
  253.                 return Convert.ToInt32(obj);
  254.             }
  255.         }
  256.         /// <summary>
  257.         /// 分页获取数据列表
  258.         /// </summary>
  259.         public DataSet GetListByPage(string strWhere, string orderby, int startIndex, int endIndex)
  260.         {
  261.             StringBuilder strSql = new StringBuilder();
  262.             strSql.Append("SELECT * FROM ( ");
  263.             strSql.Append(" SELECT ROW_NUMBER() OVER (");
  264.             if (!string.IsNullOrEmpty(orderby.Trim()))
  265.             {
  266.                 strSql.Append("order by T." + orderby);
  267.             }
  268.             else
  269.             {
  270.                 strSql.Append("order by T.ID desc");
  271.             }
  272.             strSql.Append(")AS Row, T.*  from UserInfo T ");
  273.             if (!string.IsNullOrEmpty(strWhere.Trim()))
  274.             {
  275.                 strSql.Append(" WHERE " + strWhere);
  276.             }
  277.             strSql.Append(" ) TT");
  278.             strSql.AppendFormat(" WHERE TT.Row between {0} and {1}", startIndex, endIndex);
  279.             return DbHelperSQLite.Query(strSql.ToString());
  280.         }
  281.  
  282.         #endregion  BasicMethod
  283.     }

5，业务逻辑层BLL 创建

  1. public partial class UserInfo
  2.     {
  3.         private readonly DAL.UserInfo dal = new DAL.UserInfo();
  4.         public UserInfo()
  5.         { }
  6.         #region  BasicMethod
  7.  
  8.         /// <summary>
  9.         /// 得到最大ID
  10.         /// </summary>
  11.         public int GetMaxId()
  12.         {
  13.             return dal.GetMaxId();
  14.         }
  15.  
  16.         /// <summary>
  17.         /// 是否存在该记录
  18.         /// </summary>
  19.         public bool Exists(int ID)
  20.         {
  21.             return dal.Exists(ID);
  22.         }
  23.  
  24.         /// <summary>
  25.         /// 增加一条数据
  26.         /// </summary>
  27.         public bool Add(Model.UserInfo model)
  28.         {
  29.             return dal.Add(model);
  30.         }
  31.  
  32.         /// <summary>
  33.         /// 更新一条数据
  34.         /// </summary>
  35.         public bool Update(Model.UserInfo model)
  36.         {
  37.             return dal.Update(model);
  38.         }
  39.  
  40.         /// <summary>
  41.         /// 删除一条数据
  42.         /// </summary>
  43.         public bool Delete(int ID)
  44.         {
  45.  
  46.             return dal.Delete(ID);
  47.         }
  48.         /// <summary>
  49.         /// 删除一条数据
  50.         /// </summary>
  51.         public bool DeleteList(string IDlist)
  52.         {
  53.             return dal.DeleteList(IDlist);
  54.         }
  55.  
  56.         /// <summary>
  57.         /// 得到一个对象实体
  58.         /// </summary>
  59.         public Model.UserInfo GetModel(int ID)
  60.         {
  61.  
  62.             return dal.GetModel(ID);
  63.         }
  64.  
  65.         / <summary>
  66.         / 得到一个对象实体，从缓存中
  67.         / </summary>
  68.         //public Model.UserInfo GetModelByCache(int ID)
  69.         //{
  70.  
  71.         //    string CacheKey = "UserInfoModel-" + ID;
  72.         //    object objModel = Common.DataCache.GetCache(CacheKey);
  73.         //    if (objModel == null)
  74.         //    {
  75.         //        try
  76.         //        {
  77.         //            objModel = dal.GetModel(ID);
  78.         //            if (objModel != null)
  79.         //            {
  80.         //                int ModelCache = Maticsoft.Common.ConfigHelper.GetConfigInt("ModelCache");
  81.         //                Maticsoft.Common.DataCache.SetCache(CacheKey, objModel, DateTime.Now.AddMinutes(ModelCache), TimeSpan.Zero);
  82.         //            }
  83.         //        }
  84.         //        catch { }
  85.         //    }
  86.         //    return (Maticsoft.Model.UserInfo)objModel;
  87.         //}
  88.  
  89.         /// <summary>
  90.         /// 获得数据列表
  91.         /// </summary>
  92.         public DataSet GetList(string strWhere)
  93.         {
  94.             return dal.GetList(strWhere);
  95.         }
  96.         /// <summary>
  97.         /// 获得数据列表
  98.         /// </summary>
  99.         public List<Model.UserInfo> GetModelList(string strWhere)
  100.         {
  101.             DataSet ds = dal.GetList(strWhere);
  102.             return DataTableToList(ds.Tables[0]);
  103.         }
  104.         /// <summary>
  105.         /// 获得数据列表
  106.         /// </summary>
  107.         public List<Model.UserInfo> DataTableToList(DataTable dt)
  108.         {
  109.             List<Model.UserInfo> modelList = new List<Model.UserInfo>();
  110.             int rowsCount = dt.Rows.Count;
  111.             if (rowsCount > 0)
  112.             {
  113.                 Model.UserInfo model;
  114.                 for (int n = 0; n < rowsCount; n++)
  115.                 {
  116.                     model = dal.DataRowToModel(dt.Rows[n]);
  117.                     if (model != null)
  118.                     {
  119.                         modelList.Add(model);
  120.                     }
  121.                 }
  122.             }
  123.             return modelList;
  124.         }
  125.  
  126.         /// <summary>
  127.         /// 获得数据列表
  128.         /// </summary>
  129.         public DataSet GetAllList()
  130.         {
  131.             return GetList("");
  132.         }
  133.  
  134.         /// <summary>
  135.         /// 分页获取数据列表
  136.         /// </summary>
  137.         public int GetRecordCount(string strWhere)
  138.         {
  139.             return dal.GetRecordCount(strWhere);
  140.         }
  141.         /// <summary>
  142.         /// 分页获取数据列表
  143.         /// </summary>
  144.         public DataSet GetListByPage(string strWhere, string orderby, int startIndex, int endIndex)
  145.         {
  146.             return dal.GetListByPage(strWhere, orderby, startIndex, endIndex);
  147.         }
  148.         /// <summary>
  149.         /// 分页获取数据列表
  150.         /// </summary>
  151.         //public DataSet GetList(int PageSize,int PageIndex,string strWhere)
  152.         //{
  153.         //return dal.GetList(PageSize,PageIndex,strWhere);
  154.         //}
  155.  
  156.         #endregion  BasicMethod
  157.         #region  ExtensionMethod
  158.  
  159.         #endregion  ExtensionMethod
  160.     }

6，数据库操作帮助类

  1. /// <summary>
  2.     /// 数据访问基础类(基于SQLite)
  3.     /// 可以用户可以修改满足自己项目的需要。
  4.     /// </summary>
  5.     public abstract class DbHelperSQLite
  6.     {
  7.         //数据库连接字符串(web.config来配置)，可以动态更改connectionString支持多数据库.
  8.         public static string connectionString = CreateConnectionString();
  9.         public DbHelperSQLite()
  10.         {
  11.         }
  12.         private static string CreateConnectionString()
  13.         {
  14.  
  15.             string dbName = ConfigurationManager.AppSettings["SQLiteDB"];
  16.             string sqlLitePath = "data source=" + System.Environment.CurrentDirectory + "\\" + dbName + ";version=3";
  17.             return sqlLitePath;
  18.         }
  19.  
  20.         #region 公用方法
  21.  
  22.         public static int GetMaxID(string FieldName, string TableName)
  23.         {
  24.             string strsql = "select max(" + FieldName + ")+1 from " + TableName;
  25.             object obj = GetSingle(strsql);
  26.             if (obj == null)
  27.             {
  28.                 return 1;
  29.             }
  30.             else
  31.             {
  32.                 return int.Parse(obj.ToString());
  33.             }
  34.         }
  35.         public static bool Exists(string strSql)
  36.         {
  37.             object obj = GetSingle(strSql);
  38.             int cmdresult;
  39.             if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
  40.             {
  41.                 cmdresult = 0;
  42.             }
  43.             else
  44.             {
  45.                 cmdresult = int.Parse(obj.ToString());
  46.             }
  47.             if (cmdresult == 0)
  48.             {
  49.                 return false;
  50.             }
  51.             else
  52.             {
  53.                 return true;
  54.             }
  55.         }
  56.         public static bool Exists(string strSql, params SQLiteParameter[] cmdParms)
  57.         {
  58.             object obj = GetSingle(strSql, cmdParms);
  59.             int cmdresult;
  60.             if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
  61.             {
  62.                 cmdresult = 0;
  63.             }
  64.             else
  65.             {
  66.                 cmdresult = int.Parse(obj.ToString());
  67.             }
  68.             if (cmdresult == 0)
  69.             {
  70.                 return false;
  71.             }
  72.             else
  73.             {
  74.                 return true;
  75.             }
  76.         }
  77.  
  78.         #endregion
  79.  
  80.         #region  执行简单SQL语句
  81.  
  82.         /// <summary>
  83.         /// 执行SQL语句，返回影响的记录数
  84.         /// </summary>
  85.         /// <param name="SQLString">SQL语句</param>
  86.         /// <returns>影响的记录数</returns>
  87.         public static int ExecuteSql(string SQLString)
  88.         {
  89.             using (SQLiteConnection connection = new SQLiteConnection(connectionString))
  90.             {
  91.                 using (SQLiteCommand cmd = new SQLiteCommand(SQLString, connection))
  92.                 {
  93.                     try
  94.                     {
  95.                         connection.Open();
  96.                         int rows = cmd.ExecuteNonQuery();
  97.                         return rows;
  98.                     }
  99.                     catch (System.Data.SQLite.SQLiteException E)
  100.                     {
  101.                         connection.Close();
  102.                         throw new Exception(E.Message);
  103.                     }
  104.                 }
  105.             }
  106.         }
  107.  
  108.         /// <summary>
  109.         /// 执行多条SQL语句，实现数据库事务。
  110.         /// </summary>
  111.         /// <param name="SQLStringList">多条SQL语句</param>
  112.         public static void ExecuteSqlTran(ArrayList SQLStringList)
  113.         {
  114.             using (SQLiteConnection conn = new SQLiteConnection(connectionString))
  115.             {
  116.                 conn.Open();
  117.                 SQLiteCommand cmd = new SQLiteCommand();
  118.                 cmd.Connection = conn;
  119.                 SQLiteTransaction tx = conn.BeginTransaction();
  120.                 cmd.Transaction = tx;
  121.                 try
  122.                 {
  123.                     for (int n = 0; n < SQLStringList.Count; n++)
  124.                     {
  125.                         string strsql = SQLStringList[n].ToString();
  126.                         if (strsql.Trim().Length > 1)
  127.                         {
  128.                             cmd.CommandText = strsql;
  129.                             cmd.ExecuteNonQuery();
  130.                         }
  131.                     }
  132.                     tx.Commit();
  133.                 }
  134.                 catch (System.Data.SQLite.SQLiteException E)
  135.                 {
  136.                     tx.Rollback();
  137.                     throw new Exception(E.Message);
  138.                 }
  139.             }
  140.         }
  141.         /// <summary>
  142.         /// 执行带一个存储过程参数的的SQL语句。
  143.         /// </summary>
  144.         /// <param name="SQLString">SQL语句</param>
  145.         /// <param name="content">参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加</param>
  146.         /// <returns>影响的记录数</returns>
  147.         public static int ExecuteSql(string SQLString, string content)
  148.         {
  149.             using (SQLiteConnection connection = new SQLiteConnection(connectionString))
  150.             {
  151.                 SQLiteCommand cmd = new SQLiteCommand(SQLString, connection);
  152.                 SQLiteParameter myParameter = new SQLiteParameter("@content", DbType.String);
  153.                 myParameter.Value = content;
  154.                 cmd.Parameters.Add(myParameter);
  155.                 try
  156.                 {
  157.                     connection.Open();
  158.                     int rows = cmd.ExecuteNonQuery();
  159.                     return rows;
  160.                 }
  161.                 catch (System.Data.SQLite.SQLiteException E)
  162.                 {
  163.                     throw new Exception(E.Message);
  164.                 }
  165.                 finally
  166.                 {
  167.                     cmd.Dispose();
  168.                     connection.Close();
  169.                 }
  170.             }
  171.         }
  172.         /// <summary>
  173.         /// 向数据库里插入图像格式的字段(和上面情况类似的另一种实例)
  174.         /// </summary>
  175.         /// <param name="strSQL">SQL语句</param>
  176.         /// <param name="fs">图像字节,数据库的字段类型为image的情况</param>
  177.         /// <returns>影响的记录数</returns>
  178.         public static int ExecuteSqlInsertImg(string strSQL, byte[] fs)
  179.         {
  180.             using (SQLiteConnection connection = new SQLiteConnection(connectionString))
  181.             {
  182.                 SQLiteCommand cmd = new SQLiteCommand(strSQL, connection);
  183.                 SQLiteParameter myParameter = new SQLiteParameter("@fs", DbType.Binary);
  184.                 myParameter.Value = fs;
  185.                 cmd.Parameters.Add(myParameter);
  186.                 try
  187.                 {
  188.                     connection.Open();
  189.                     int rows = cmd.ExecuteNonQuery();
  190.                     return rows;
  191.                 }
  192.                 catch (System.Data.SQLite.SQLiteException E)
  193.                 {
  194.                     throw new Exception(E.Message);
  195.                 }
  196.                 finally
  197.                 {
  198.                     cmd.Dispose();
  199.                     connection.Close();
  200.                 }
  201.             }
  202.         }
  203.  
  204.         /// <summary>
  205.         /// 执行一条计算查询结果语句，返回查询结果（object）。
  206.         /// </summary>
  207.         /// <param name="SQLString">计算查询结果语句</param>
  208.         /// <returns>查询结果（object）</returns>
  209.         public static object GetSingle(string SQLString)
  210.         {
  211.             using (SQLiteConnection connection = new SQLiteConnection(connectionString))
  212.             {
  213.                 using (SQLiteCommand cmd = new SQLiteCommand(SQLString, connection))
  214.                 {
  215.                     try
  216.                     {
  217.                         connection.Open();
  218.                         object obj = cmd.ExecuteScalar();
  219.                         if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
  220.                         {
  221.                             return null;
  222.                         }
  223.                         else
  224.                         {
  225.                             return obj;
  226.                         }
  227.                     }
  228.                     catch (System.Data.SQLite.SQLiteException e)
  229.                     {
  230.                         connection.Close();
  231.                         throw new Exception(e.Message);
  232.                     }
  233.                 }
  234.             }
  235.         }
  236.         /// <summary>
  237.         /// 执行查询语句，返回SQLiteDataReader
  238.         /// </summary>
  239.         /// <param name="strSQL">查询语句</param>
  240.         /// <returns>SQLiteDataReader</returns>
  241.         public static SQLiteDataReader ExecuteReader(string strSQL)
  242.         {
  243.             SQLiteConnection connection = new SQLiteConnection(connectionString);
  244.             SQLiteCommand cmd = new SQLiteCommand(strSQL, connection);
  245.             try
  246.             {
  247.                 connection.Open();
  248.                 SQLiteDataReader myReader = cmd.ExecuteReader();
  249.                 return myReader;
  250.             }
  251.             catch (System.Data.SQLite.SQLiteException e)
  252.             {
  253.                 throw new Exception(e.Message);
  254.             }
  255.  
  256.         }
  257.         /// <summary>
  258.         /// 执行查询语句，返回DataSet
  259.         /// </summary>
  260.         /// <param name="SQLString">查询语句</param>
  261.         /// <returns>DataSet</returns>
  262.         public static DataSet Query(string SQLString)
  263.         {
  264.             using (SQLiteConnection connection = new SQLiteConnection(connectionString))
  265.             {
  266.                 DataSet ds = new DataSet();
  267.                 try
  268.                 {
  269.                     connection.Open();
  270.                     SQLiteDataAdapter command = new SQLiteDataAdapter(SQLString, connection);
  271.                     command.Fill(ds, "ds");
  272.                 }
  273.                 catch (System.Data.SQLite.SQLiteException ex)
  274.                 {
  275.                     throw new Exception(ex.Message);
  276.                 }
  277.                 return ds;
  278.             }
  279.         }
  280.  
  281.  
  282.         #endregion
  283.  
  284.         #region 执行带参数的SQL语句
  285.  
  286.         /// <summary>
  287.         /// 执行SQL语句，返回影响的记录数
  288.         /// </summary>
  289.         /// <param name="SQLString">SQL语句</param>
  290.         /// <returns>影响的记录数</returns>
  291.         public static int ExecuteSql(string SQLString, params SQLiteParameter[] cmdParms)
  292.         {
  293.             using (SQLiteConnection connection = new SQLiteConnection(connectionString))
  294.             {
  295.                 using (SQLiteCommand cmd = new SQLiteCommand())
  296.                 {
  297.                     try
  298.                     {
  299.                         PrepareCommand(cmd, connection, null, SQLString, cmdParms);
  300.                         int rows = cmd.ExecuteNonQuery();
  301.                         cmd.Parameters.Clear();
  302.                         return rows;
  303.                     }
  304.                     catch (System.Data.SQLite.SQLiteException E)
  305.                     {
  306.                         throw new Exception(E.Message);
  307.                     }
  308.                 }
  309.             }
  310.         }
  311.  
  312.  
  313.         /// <summary>
  314.         /// 执行多条SQL语句，实现数据库事务。
  315.         /// </summary>
  316.         /// <param name="SQLStringList">SQL语句的哈希表（key为sql语句，value是该语句的SQLiteParameter[]）</param>
  317.         public static void ExecuteSqlTran(Hashtable SQLStringList)
  318.         {
  319.             using (SQLiteConnection conn = new SQLiteConnection(connectionString))
  320.             {
  321.                 conn.Open();
  322.                 using (SQLiteTransaction trans = conn.BeginTransaction())
  323.                 {
  324.                     SQLiteCommand cmd = new SQLiteCommand();
  325.                     try
  326.                     {
  327.                         //循环
  328.                         foreach (DictionaryEntry myDE in SQLStringList)
  329.                         {
  330.                             string cmdText = myDE.Key.ToString();
  331.                             SQLiteParameter[] cmdParms = (SQLiteParameter[])myDE.Value;
  332.                             PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
  333.                             int val = cmd.ExecuteNonQuery();
  334.                             cmd.Parameters.Clear();
  335.  
  336.                             trans.Commit();
  337.                         }
  338.                     }
  339.                     catch
  340.                     {
  341.                         trans.Rollback();
  342.                         throw;
  343.                     }
  344.                 }
  345.             }
  346.         }
  347.  
  348.  
  349.         /// <summary>
  350.         /// 执行一条计算查询结果语句，返回查询结果（object）。
  351.         /// </summary>
  352.         /// <param name="SQLString">计算查询结果语句</param>
  353.         /// <returns>查询结果（object）</returns>
  354.         public static object GetSingle(string SQLString, params SQLiteParameter[] cmdParms)
  355.         {
  356.             using (SQLiteConnection connection = new SQLiteConnection(connectionString))
  357.             {
  358.                 using (SQLiteCommand cmd = new SQLiteCommand())
  359.                 {
  360.                     try
  361.                     {
  362.                         PrepareCommand(cmd, connection, null, SQLString, cmdParms);
  363.                         object obj = cmd.ExecuteScalar();
  364.                         cmd.Parameters.Clear();
  365.                         if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
  366.                         {
  367.                             return null;
  368.                         }
  369.                         else
  370.                         {
  371.                             return obj;
  372.                         }
  373.                     }
  374.                     catch (System.Data.SQLite.SQLiteException e)
  375.                     {
  376.                         throw new Exception(e.Message);
  377.                     }
  378.                 }
  379.             }
  380.         }
  381.  
  382.         /// <summary>
  383.         /// 执行查询语句，返回SQLiteDataReader
  384.         /// </summary>
  385.         /// <param name="strSQL">查询语句</param>
  386.         /// <returns>SQLiteDataReader</returns>
  387.         public static SQLiteDataReader ExecuteReader(string SQLString, params SQLiteParameter[] cmdParms)
  388.         {
  389.             SQLiteConnection connection = new SQLiteConnection(connectionString);
  390.             SQLiteCommand cmd = new SQLiteCommand();
  391.             try
  392.             {
  393.                 PrepareCommand(cmd, connection, null, SQLString, cmdParms);
  394.                 SQLiteDataReader myReader = cmd.ExecuteReader();
  395.                 cmd.Parameters.Clear();
  396.                 return myReader;
  397.             }
  398.             catch (System.Data.SQLite.SQLiteException e)
  399.             {
  400.                 throw new Exception(e.Message);
  401.             }
  402.  
  403.         }
  404.  
  405.         /// <summary>
  406.         /// 执行查询语句，返回DataSet
  407.         /// </summary>
  408.         /// <param name="SQLString">查询语句</param>
  409.         /// <returns>DataSet</returns>
  410.         public static DataSet Query(string SQLString, params SQLiteParameter[] cmdParms)
  411.         {
  412.             using (SQLiteConnection connection = new SQLiteConnection(connectionString))
  413.             {
  414.                 SQLiteCommand cmd = new SQLiteCommand();
  415.                 PrepareCommand(cmd, connection, null, SQLString, cmdParms);
  416.                 using (SQLiteDataAdapter da = new SQLiteDataAdapter(cmd))
  417.                 {
  418.                     DataSet ds = new DataSet();
  419.                     try
  420.                     {
  421.                         da.Fill(ds, "ds");
  422.                         cmd.Parameters.Clear();
  423.                     }
  424.                     catch (System.Data.SQLite.SQLiteException ex)
  425.                     {
  426.                         throw new Exception(ex.Message);
  427.                     }
  428.                     return ds;
  429.                 }
  430.             }
  431.         }
  432.  
  433.  
  434.         private static void PrepareCommand(SQLiteCommand cmd, SQLiteConnection conn, SQLiteTransaction trans, string cmdText, SQLiteParameter[] cmdParms)
  435.         {
  436.             if (conn.State != ConnectionState.Open)
  437.                 conn.Open();
  438.             cmd.Connection = conn;
  439.             cmd.CommandText = cmdText;
  440.             if (trans != null)
  441.                 cmd.Transaction = trans;
  442.             cmd.CommandType = CommandType.Text;//cmdType;
  443.             if (cmdParms != null)
  444.             {
  445.                 foreach (SQLiteParameter parm in cmdParms)
  446.                     cmd.Parameters.Add(parm);
  447.             }
  448.         }
  449.  
  450.         #endregion

   7，UI层调用

  1. //连接sqlite进行身份认证登录
  2.             string strUserName = txtUserName.Text;
  3.             string strUserPwd = TxtUserPwd.Text;
  4.  
  5.             string strwhere = " UserName = '" + strUserName + "' and Pwd = '" + strUserPwd + "'";
  6.  
  7.             int count = bll.GetRecordCount(strwhere);
  8.  
  9.             if (count > 0)
  10.             {
  11.                 App.frmMain = new FrmMain();
  12.                 App.qx = 1; //标记一下用户
  13.                 this.Close(); //关闭登陆窗口
  14.             }
  15.             else
  16.             {
  17.                 MessageBoxEx.Show("用户不存在,请联系管理员！", "登录认证", MessageBoxButtons.OK, MessageBoxIcon.Information, MessageBoxDefaultButton.Button1);
  18.             }

8，登录成功后进入主窗体

  9，源码分享，教学ppt分享

人脸识别与管理系统开发之登录窗体实现-基于sqlite验证（第五章）-C#文档类资源-CSDN下载

10，写在最后

        时间对待所有人都是公平的，是努力让每段人生不同。努力，能成全更多小小的梦想，能让你遇见更多可能的自己，能让你在回首时说一句问心无愧。生活会回报真正努力的你。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Li_阴宅/article/detail/894006
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号