（MVC）三层架构知识的学习总结

首先介绍一下MVC的意义，和各个层面之间的用途和功能。

1）实体层。主要用来声明在视图层和业务逻辑层之间传递数据的载体。通常代表来源与项目数据库中一个或者多个表组成的一条有意义的记录。

2)业务逻辑层。根据业务逻辑向视图层提供数据，这个项目中的类有权根据业务逻辑来决定是否调用数据库访问层的方法

3）数据库访问层。项业务逻辑层提供访问数据的方法。

4）视图层。主要是以网站开发为例。用于提供显示，添加，编辑和删除数据。

我在VS中创建的项目的结构图：

NetMVC就是所谓的视图层。Entity是实体层，用来声明开发过程中被要使用的所有变量。DAL是数据库访问层，主要完成所有操作对数据库的访问。BLL是业务逻辑层，处理视图层传来的业务逻辑，然后传递给数据库访问层进行处理。

本例主要演示的是登陆页面的实现，Entity层的代码如下：

[csharp] view plain copy
 
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Text;  
  4.   
  5. namespace Entity  
  6. {  
  7.     public class UserInfo  
  8.     {  
  9.         private int UserId;  
  10.   
  11.         /// <summary>  
  12.         /// 用户比编号  
  13.         /// </summary>  
  14.         public int UserId1  
  15.         {  
  16.             get { return UserId; }  
  17.             set { UserId = value; }  
  18.         }  
  19.         private string username;  
  20.   
  21.         /// <summary>  
  22.         /// 登录账户名称  
  23.         /// </summary>  
  24.         public string Username  
  25.         {  
  26.             get { return username; }  
  27.             set { username = value; }  
  28.         }  
  29.   
  30.         private string password;  
  31.   
  32.         /// <summary>  
  33.         /// 登录密码  
  34.         /// </summary>  
  35.         public string Password  
  36.         {  
  37.             get { return password; }  
  38.             set { password = value; }  
  39.         }  
  40.         private int loginCount;  
  41.   
  42.         /// <summary>  
  43.         /// 登陆次数  
  44.         /// </summary>  
  45.         public int LoginCount  
  46.         {  
  47.             get { return loginCount; }  
  48.             set { loginCount = value; }  
  49.         }  
  50.         private DateTime regDate;  
  51.   
  52.         /// <summary>  
  53.         /// 注册时间  
  54.         /// </summary>  
  55.         public DateTime RegDate  
  56.         {  
  57.             get { return regDate; }  
  58.             set { regDate = value; }  
  59.         }  
  60.         private DateTime lastLoginDate;  
  61.   
  62.         /// <summary>  
  63.         /// 最后登录时间  
  64.         /// </summary>  
  65.         public DateTime LastLoginDate  
  66.         {  
  67.             get { return lastLoginDate; }  
  68.             set { lastLoginDate = value; }  
  69.         }  
  70.         private bool isForbidden;  
  71.         private string passwordQuestion;  
  72.   
  73.         /// <summary>  
  74.         /// 找回密码提示问题  
  75.         /// </summary>  
  76.         public string PasswordQuestion  
  77.         {  
  78.             get { return passwordQuestion; }  
  79.             set { passwordQuestion = value; }  
  80.         }  
  81.         private string passwordAnswer;  
  82.   
  83.         /// <summary>  
  84.         /// 找回密码答案  
  85.         /// </summary>  
  86.         public string PasswordAnswer  
  87.         {  
  88.             get { return passwordAnswer; }  
  89.             set { passwordAnswer = value; }  
  90.         }  
  91.   
  92.   
  93.     }  
  94. }  


完成对实体类的创建，接着就要完成对数据库访问层的创建（其中需要用到上篇问章所写的SqlHelper数据库访问通用类http://blog.csdn.net/yisuowushinian/article/details/7999305），代码如下，

[csharp] view plain copy
 
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Text;  
  4. using System.Data;  
  5. using System.Data.SqlClient;  
  6. using System.Configuration;  
  7. using Entity;  
  8.   
  9. namespace DAL  
  10. {  
  11.     public class UserDal  
  12.     {  
  13.         private string connectionString = ConfigurationManager.ConnectionStrings["connectionString"].ConnectionString;  
  14.   
  15.         /// <summary>  
  16.         /// 添加用户  
  17.         /// </summary>  
  18.         /// <param name="info">用户的实体类</param>  
  19.         /// <returns></returns>  
  20.         public bool AddUser(UserInfo info)  
  21.         {  
  22.             string sql = "insert into Users(Username,password) values('@Username','@password')";  
  23.             SqlParameter[] parameters = new SqlParameter[4];  
  24.             parameters[0] = new SqlParameter("@Username", SqlDbType.NVarChar, 30);  
  25.             parameters[0].Value = info.Username;  
  26.   
  27.             parameters[1] = new SqlParameter("password", SqlDbType.VarChar, 50);  
  28.             parameters[1].Value = info.Password;  
  29.   
  30.   
  31.             return new SqlDbHelper(connectionString).ExecuteNonQuery(sql) > 0;  
  32.         }  
  33.   
  34.         /// <summary>  
  35.         /// 删除用户  
  36.         /// </summary>  
  37.         /// <param name="UserId">用户编号</param>  
  38.         /// <returns></returns>  
  39.         public bool DeleteUser(int UserId)  
  40.         {  
  41.             string sql = "delete from users where UserId=" + UserId;  
  42.             return new SqlDbHelper(connectionString).ExecuteNonQuery(sql) > 0;  
  43.         }  
  44.   
  45.         /// <summary>  
  46.         /// 更新用户  
  47.         /// </summary>  
  48.         /// <param name="info">用户的实体类</param>  
  49.         /// <returns></returns>  
  50.         public bool UpDateUser(UserInfo info)  
  51.         {  
  52.             string sql = "update users set password=@password,loginCount=@loginCount where userid=@userid";  
  53.             SqlParameter[] parameters = new SqlParameter[7];  
  54.             parameters[0] = new SqlParameter("@password", SqlDbType.VarChar, 30);  
  55.             parameters[0].Value = info.Password;  
  56.   
  57.             parameters[1] = new SqlParameter("@loginCount", SqlDbType.Int, 4);  
  58.             parameters[1].Value = info.LoginCount;  
  59.   
  60.             return new SqlDbHelper(connectionString).ExecuteNonQuery(sql) > 0;  
  61.         }  
  62.   
  63.         /// <summary>  
  64.         /// 根据用户名或者用户编号查询用户  
  65.         /// </summary>  
  66.         /// <param name="userId">用户编号</param>  
  67.         /// <returns></returns>  
  68.         public DataTable GetUser(int userId)  
  69.         {  
  70.             string sql = "select * from users where userId=@UserId";  
  71.             SqlParameter[] parameters = new SqlParameter[1];  
  72.             parameters[0] = new SqlParameter("@UserId", SqlDbType.Int, 4);  
  73.             parameters[0].Value = userId;  
  74.             return new SqlDbHelper(connectionString).ExecuteDataTable(sql, CommandType.Text, parameters);  
  75.         }  
  76.   
  77.         /// <summary>  
  78.         /// 根据用户名查询用户信息  
  79.         /// </summary>  
  80.         /// <param name="Username">用户名</param>  
  81.         /// <returns></returns>  
  82.         public DataTable GetUser(string Username)  
  83.         {  
  84.             string sql = "select * from users where username=@username";  
  85.             SqlParameter[] parameters = new SqlParameter[1];  
  86.             parameters[1] = new SqlParameter("@username", SqlDbType.NVarChar, 30);  
  87.             parameters[1].Value = Username;  
  88.   
  89.             return new SqlDbHelper(connectionString).ExecuteDataTable(sql, CommandType.Text, parameters);  
  90.         }  
  91.   
  92.         /// <summary>  
  93.         /// 按照用户编号升序查询从指定位置开始的指定条数记录  
  94.         /// </summary>  
  95.         /// <param name="startIndex">查询的起始位置</param>  
  96.         /// <param name="size">返回的最大记录条数</param>  
  97.         /// <returns></returns>  
  98.         public DataTable GetUserList(int startIndex, int size)  
  99.         {  
  100.             string sql = "select top " + size + " * from users where UserId not in (select top " + startIndex + " UserId from Users order by UserId asc)order by UserId asc";  
  101.             return new SqlDbHelper(connectionString).ExecuteDataTable(sql);  
  102.         }  
  103.   
  104.         /// <summary>  
  105.         /// 查询用户总数  
  106.         /// </summary>  
  107.         /// <returns></returns>  
  108.         public int GetUserCount()  
  109.         {  
  110.             string sql = "select count(1) from Users";  
  111.             return int.Parse(new SqlDbHelper(connectionString).ExecuteScalar(sql).ToString());  
  112.         }  
  113.     }  
  114. }  


然后创建业务逻辑层，代码如下：

[csharp] view plain copy
 
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Text;  
  4.   
  5. using DAL;  
  6. using Entity;  
  7. using System.Data;  
  8. using System.Data.SqlClient;  
  9. using System.Security.Cryptography;  
  10. using System.Security;  
  11.   
  12. namespace BLL  
  13. {  
  14.     public class UserBLL  
  15.     {  
  16.         private static string MD5Hash(string password)  
  17.         {  
  18.             MD5 md5 = MD5.Create();//创建Md5算法实例  
  19.             //将原始字符串转换成UTF-8编码的字节数组  
  20.             byte[] sourceBytes = System.Text.Encoding.UTF8.GetBytes(password);  
  21.             //计算字节数组的哈希值  
  22.             byte[] resultBytes = md5.ComputeHash(sourceBytes);  
  23.             StringBuilder buffer = new StringBuilder(resultBytes.Length);  
  24.             //将计算得到的哈希值的字节数组中的每一个字节转换成十六进制形式  
  25.             foreach (byte b in resultBytes)  
  26.             {  
  27.                 buffer.Append(b.ToString("X"));  
  28.   
  29.             }  
  30.             return buffer.ToString();  
  31.         }  
  32.   
  33.         /// <summary>  
  34.         /// 添加用户  
  35.         /// </summary>  
  36.         /// <param name="info">用户的实体类</param>  
  37.         /// <returns></returns>  
  38.         public static bool AddUser(UserInfo info)  
  39.         {  
  40.             UserDal dal = new UserDal();  
  41.             DataTable data = dal.GetUser(info.Username);  
  42.             if (data.Rows.Count > 0)  
  43.             {  
  44.                 return false;  
  45.             }  
  46.             else  
  47.             {  
  48.                 info.Password =MD5Hash (info.Password);  
  49.                 return new UserDal().AddUser(info);  
  50.             }  
  51.         }  
  52.   
  53.         /// <summary>  
  54.         /// 删除用户  
  55.         /// </summary>  
  56.         /// <param name="userId">用户编号</param>  
  57.         /// <returns></returns>  
  58.         public static bool DeleteUser(int userId)  
  59.         {  
  60.             return new UserDal().DeleteUser(userId);  
  61.         }  
  62.   
  63.         /// <summary>  
  64.         /// 更新用户  
  65.         /// </summary>  
  66.         /// <param name="info">用户的实体类</param>  
  67.         /// <param name="changePassword">是否需要对用户密码进行加密</param>  
  68.         /// <returns></returns>  
  69.         public static bool UpdateUser(UserInfo info, bool changePassword)  
  70.         {  
  71.             //如果更改密码就需要对新密码进行加密  
  72.             //如果没有更改密码则不能对密码重复加密，否则会对用户造成无法登陆  
  73.             if (changePassword)  
  74.             {  
  75.                 info.Password = MD5Hash(info.Password);  
  76.             }  
  77.             return new UserDal().UpDateUser(info);  
  78.         }  
  79.   
  80.         /// <summary>  
  81.         /// 根据用户编号查询用户  
  82.         /// </summary>  
  83.         /// <param name="UserId">用户的编号</param>  
  84.         /// <returns></returns>  
  85.         public static DataTable GetUser(int UserId)  
  86.         {  
  87.             return new UserDal().GetUser(UserId);  
  88.         }  
  89.   
  90.         /// <summary>  
  91.         /// 根据用户名查询用户信息  
  92.         /// </summary>  
  93.         /// <param name="userName">用户名</param>  
  94.         /// <returns></returns>  
  95.         public static DataTable GetUser(string userName)  
  96.         {  
  97.             return new UserDal().GetUser(userName);  
  98.         }  
  99.   
  100.         /// <summary>  
  101.         /// 按照用户编号升序查询从指定位置开始的指定条数的记录  
  102.         /// </summary>  
  103.         /// <param name="startIndex">查询的起始位置</param>  
  104.         /// <param name="size">返回的最大记录条数</param>  
  105.         /// <returns></returns>  
  106.         public static DataTable GetUserList(int startIndex, int size)  
  107.         {  
  108.             return new UserDal().GetUserList(startIndex, size);  
  109.         }  
  110.   
  111.         /// <summary>  
  112.         /// 查询用户总数  
  113.         /// </summary>  
  114.         /// <returns></returns>  
  115.         public static int GetUserCount()  
  116.         {  
  117.             return new UserDal().GetUserCount();  
  118.         }  
  119.   
  120.         /// <summary>  
  121.         /// 根据用户名或者用户编号从数据库查询对应记录的实体，如果不存在则返回null  
  122.         /// </summary>  
  123.         /// <param name="userId">用户编号</param>  
  124.         /// <returns></returns>  
  125.         public static UserInfo GetUserEntity(int userId)  
  126.         {  
  127.             return ChangeToEntity(new UserDal().GetUser(userId));  
  128.         }  
  129.   
  130.         /// <summary>  
  131.         /// 根据用户名或者用户编号从数据库查询对应记录的实体，如果不存在则返回null  
  132.         /// </summary>  
  133.         /// <param name="userName">用户名</param>  
  134.         /// <returns></returns>  
  135.         public static UserInfo GetUserEntity(string userName)  
  136.         {  
  137.             return ChangeToEntity(new UserDal().GetUser(userName));  
  138.         }  
  139.   
  140.         /// <summary>  
  141.         /// 将包含Users表记录的DataTables中的第一条记录转换成Userinfo实体  
  142.         /// </summary>  
  143.         /// <param name="data"></param>  
  144.         /// <returns></returns>  
  145.         private static UserInfo ChangeToEntity(DataTable data)  
  146.         {  
  147.             UserInfo info = null;  
  148.             //如果data不为空并且包含的记录条数大于0、  
  149.             if (data!=null&&data.Rows.Count > 0)  
  150.             {  
  151.                 DataRow row = data.Rows[0];  
  152.                 info = new UserInfo();  
  153.   
  154.             }  
  155.             return info;  
  156.         }  
  157.   
  158.         public static bool Login(string userName, string password)  
  159.         {  
  160.             bool exits = false;  
  161.             UserInfo info = GetUserEntity(userName);  
  162.   
  163.             if (info != null && MD5Hash(password) == info.Password)  
  164.             {  
  165.                 exits = true;  
  166.                 info.LoginCount = info.LoginCount + 1;//将用户登陆的次数加1  
  167.                 info.LastLoginDate = DateTime.Now;//将用户最后的登录时间设置为现在  
  168.                 UpdateUser(info, false);//更新用户的登陆次数和最后的登录时间  
  169.             }  
  170.             return exits;  
  171.         }  
  172.     }  
  173. }  


这个就完成了对数据库访问层，实体层，业务逻辑层的创建工作。因为在创建过程中被，有很多的重复的工作，我为了加快速度，就省略了一些的代码。

在登陆页面使用时，只需要引入业务逻辑层的方法，然后根据其中的方法，传入相应的参数，就可以完成所有的操作。

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/netalen/p/6106440.html