• MVC ---- EF三层代码


    1、DAL层

    using Night.Models;
    using System;
    using System.Collections.Generic;
    using System.Data.Entity.Infrastructure;
    using System.Linq;
    using System.Linq.Expressions;
    using System.Reflection;
    
    namespace NightCat.DAL
    {
        public class SysLogService
        {
    
            //public SysLogService()
            //{
            //    //删除使用
            //    DelByCondition(p => p.F_Id == "00003");
    
            //    //修改使用
            //    Sys_Log sl = new Sys_Log()
            //    {
            //        F_Id = "00003",
            //        F_Account = "adf",
            //        F_CreatorTime = DateTime.Now
            //    };
            //    this.Modify(sl, "F_Account", "F_CreatorTime");////    this.Modify(sl, new string[] { "F_Account", "F_CreatorTime" });
    
            //    //排序  
            //    List<Sys_Log> ssl = this.GetListByCondition(p => p.F_Id == "00003" && p.F_Account == "1000");
            //    List<Sys_Log> ssl2 = this.GetListByCondition(p => p.F_Id == "00003" && p.F_Account == "1000", p2 => p2.F_Id);
    
            //}
    
    
            /// <summary>
            /// EF数据上下文
            /// </summary>
            NightCatEntities nc = new NightCatEntities();
    
            #region 新增实体
            /// <summary>
            /// 新增实体
            /// </summary>
            /// <param name="log"></param>
            /// <returns></returns>
            public int Add(Sys_Log log)
            {
                try
                {
                    nc.Sys_Log.Add(log);
                    //保存成功之后,会将自增的ID和新增的行数设置给log
                    return nc.SaveChanges();
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
            #endregion
             
            #region 根据ID删除一条数据
            /// <summary>
            /// 根据ID删除一条数据
            /// </summary>
            /// <param name="Id"></param>
            /// <returns></returns>
            public int DelById(string Id)
            {
                try
                {
                    //创建对象
                    Sys_Log sl = new Sys_Log()
                    {
                        F_Id = Id
                    };
                    //把要删除的对象添加到集合中
                    nc.Sys_Log.Attach(sl);
                    nc.Sys_Log.Remove(sl);
                    return nc.SaveChanges();
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
            #endregion
    
            #region 根据条件删除数据
            /// <summary>
            /// 根据条件删除数据
            /// </summary>
            /// <param name="delWhere">返回值为bool类型的委托对象(方法)</param>
            /// <returns></returns>
            public int DelByCondition(Expression<Func<Sys_Log, bool>> delWhere)
            {
                try
                {
                    //查询
                    List<Sys_Log> pDels = nc.Sys_Log.Where(delWhere).ToList();
                    pDels.ForEach(p => nc.Sys_Log.Remove(p));
                    return nc.SaveChanges();
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
            #endregion
    
            #region 修改+Modify(Sys_Log p, params string[] proNames)
            /// <summary>
            /// 修改数据
            /// </summary>
            /// <param name="p">要修改的对象</param>
            /// <param name="proName">要修改的属性名称集合</param>
            /// params 可变参数
            /// <returns></returns>
            public int Modify(Sys_Log p, params string[] proNames)
            {
                try
                {
                    DbEntityEntry entry = nc.Entry<Sys_Log>(p);
                    entry.State = System.Data.Entity.EntityState.Unchanged;
    
                    foreach (string proName in proNames)
                    {
                        entry.Property(proName).IsModified = true;
                    }
                    return nc.SaveChanges();
                }
                catch (Exception)
                {
    
                    throw;
                }
            }
            #endregion
    
            #region 根据条件检索集合中的数据 List<Sys_Log> GetListByCondition(Expression<Func<Sys_Log, bool>> whereLambda)
            /// <summary>
            /// 根据条件检索集合中的数据
            /// </summary>
            /// <param name="whereLambda"></param>
            /// <returns></returns>
            public List<Sys_Log> GetListByCondition(Expression<Func<Sys_Log, bool>> whereLambda)
            {
                try
                {
                    return nc.Sys_Log.Where(whereLambda).ToList();
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
            #endregion
    
            #region + 根据条件检索集合中的数据并进行排序+GetListByCondition<Tkey>(Expression<Func<Sys_Log, bool>> whereLambda,Expression<Func<Sys_Log,Tkey>> orderLamba)
            /// <summary>
            /// 根据条件检索集合中的数据并进行排序+GetListByCondition<Tkey>(Expression<Func<Sys_Log, bool>> whereLambda,Expression<Func<Sys_Log,Tkey>> orderLamba)
            /// </summary>
            /// <param name="whereLambda"></param>
            /// <returns></returns>
            /// 这么的Tkey不是必要的使用的时候可以不写
            public List<Sys_Log> GetListByCondition<Tkey>(Expression<Func<Sys_Log, bool>> whereLambda,Expression<Func<Sys_Log,Tkey>> orderLamba)
            {
                try
                {
                    return nc.Sys_Log.Where(whereLambda).OrderBy(orderLamba).ToList();
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
            #endregion
    
            #region 根据条件和排序查询一分页的形式展示
            /// <summary>
            /// 根据条件和排序查询一分页的形式展示
            /// </summary>
            /// <typeparam name="Tkey">排序字段类型</typeparam>
            /// <param name="pageIndex">查询的页面</param>
            /// <param name="pageSize">每页显示的条数</param>
            /// <param name="orderLambda">排序的字段</param>
            /// <param name="whereLambda">查询的条件</param>
            /// <returns></returns>
            public List<Sys_Log> GetPageList<Tkey>(int pageIndex, int pageSize, Expression<Func<Sys_Log, Tkey>> orderLambda, Expression<Func<Sys_Log, bool>> whereLambda)
            {
                try
                {
                    return nc.Sys_Log.Where(whereLambda).OrderBy(orderLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
            #endregion
    
    
            #region 批量修改+Modify(Sys_Log p, params string[] proNames)
            /// <summary>
            /// 批量修改数据
            /// </summary>
            /// <param name="model">要修改的列及修改后列的值的集合</param>
            /// params 可变参数
            /// <returns></returns>
            public int Modifys(Sys_Log model,Expression<Func<Sys_Log,bool>> whereLambda,params string[] ModifyProNames)
            {
                try
                {
                    //1、查询出要修改的数据
                    List<Sys_Log> listModif = nc.Sys_Log.Where(whereLambda).ToList();
    
                    //2、获取实体类对象
                    Type t = typeof(Sys_Log);
                    //3、获取实体类所有的共有属性
                    List<Sys_Log> proInfos = t.GetProperties(BindingFlags.Instance | BindingFlags.Public).ToList();
                    //4、创建一个实体属性字典集合
                    Dictionary<string, PropertyInfo> dictPros = new Dictionary<string, PropertyInfo>();
                    //5、将实体属性中要修改的属性,添加到字典集合中,键:属性名,值:属性对象
                    proInfos.ForEach(p =>
                    {
                        if (ModifyProNames.Contains(p.F_NickName))
                        {
                            dictPros.Add(p.F_NickName, p);
                        }
                    });
                    //循环要修改的属性名
                    foreach (string proName in ModifyProNames)
                    {
                        //判断要修改的属性名是否在实体类的属性集合中
                        if (dictPros.ContainsKey(proName))
                        {
                            //如何存在,则取出要修改的属性对象
                            PropertyInfo proInfo = dictPros[proName];
                            //取出要修改的值
                            object newValue = proInfo.GetValue(model, null);
                            //批量设置要修改的对象的属性
                            foreach (Sys_Log item in listModif)
                            {
                                //为要修改的对象的要修改的属性,设置新的值
                                proInfo.SetValue(item, newValue,null);
                            }
    
                        }
                    }
    
                 }
                catch (Exception)
                {
    
                    throw;
                }
            }
            #endregion
        }
    }
    View Code

    2、BLL层

    using Night.Models;
    using NightCat.DAL;
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Linq.Expressions;
    using NightCat.DAL;
    
    namespace NightCat.BLL
    {
        public class SysLogManager
        {
            SysLogService ss = new SysLogService(); 
    
            #region 新增实体
            /// <summary>
            /// 新增实体
            /// </summary>
            /// <param name="log"></param>
            /// <returns></returns>
            public int Add(Sys_Log log)
            {
                try
                {
                  return  ss.Add(log);
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
            #endregion
    
            #region 根据ID删除一条数据
            /// <summary>
            /// 根据ID删除一条数据
            /// </summary>
            /// <param name="Id"></param>
            /// <returns></returns>
            public int DelById(string Id)
            {
                try
                {
                    return ss.DelById(Id);
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
            #endregion
    
            #region 根据条件删除数据
            /// <summary>
            /// 根据条件删除数据
            /// </summary>
            /// <param name="delWhere">返回值为bool类型的委托对象(方法)</param>
            /// <returns></returns>
            public int DelByCondition(Expression<Func<Sys_Log, bool>> delWhere)
            {
                try
                {
                    //查询
                    return ss.DelByCondition(delWhere);
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
            #endregion
    
            #region 修改+Modify(Sys_Log p, params string[] proNames)
            /// <summary>
            /// 修改数据
            /// </summary>
            /// <param name="p">要修改的对象</param>
            /// <param name="proName">要修改的属性名称集合</param>
            /// params 可变参数
            /// <returns></returns>
            public int Modify(Sys_Log p, params string[] proNames)
            {
                try
                {
                    return ss.Modify(p, proNames);
                }
                catch (Exception)
                {
    
                    throw;
                }
            }
            #endregion
    
            #region 根据条件检索集合中的数据 List<Sys_Log> GetListByCondition(Expression<Func<Sys_Log, bool>> whereLambda)
            /// <summary>
            /// 根据条件检索集合中的数据
            /// </summary>
            /// <param name="whereLambda"></param>
            /// <returns></returns>
            public List<Sys_Log> GetListByCondition(Expression<Func<Sys_Log, bool>> whereLambda)
            {
                try
                {
                    return ss.GetListByCondition(whereLambda);
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
            #endregion
    
            #region + 根据条件检索集合中的数据并进行排序+GetListByCondition<Tkey>(Expression<Func<Sys_Log, bool>> whereLambda,Expression<Func<Sys_Log,Tkey>> orderLamba)
            /// <summary>
            /// 根据条件检索集合中的数据并进行排序+GetListByCondition<Tkey>(Expression<Func<Sys_Log, bool>> whereLambda,Expression<Func<Sys_Log,Tkey>> orderLamba)
            /// </summary>
            /// <param name="whereLambda"></param>
            /// <returns></returns>
            /// 这么的Tkey不是必要的使用的时候可以不写
            public List<Sys_Log> GetListByCondition<Tkey>(Expression<Func<Sys_Log, bool>> whereLambda, Expression<Func<Sys_Log, Tkey>> orderLamba)
            {
                try
                {
                    return ss.GetListByCondition<Tkey>(whereLambda,orderLamba);
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
            #endregion
    
            #region 根据条件和排序查询一分页的形式展示
            /// <summary>
            /// 根据条件和排序查询一分页的形式展示
            /// </summary>
            /// <typeparam name="Tkey">排序字段类型</typeparam>
            /// <param name="pageIndex">查询的页面</param>
            /// <param name="pageSize">每页显示的条数</param>
            /// <param name="orderLambda">排序的字段</param>
            /// <param name="whereLambda">查询的条件</param>
            /// <returns></returns>
            public List<Sys_Log> GetPageList<Tkey>(int pageIndex, int pageSize, Expression<Func<Sys_Log, Tkey>> orderLambda, Expression<Func<Sys_Log, bool>> whereLambda)
            {
                try
                {
                    return ss.GetPageList(pageIndex, pageSize, orderLambda, whereLambda);
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
            #endregion
        }
    }
    View Code

    3、UI层

    <%@ Page Language="C#" AutoEventWireup="true" CodeBehind="WebForm1.aspx.cs" Inherits="NightCatWeb.WebForm1" %>
    
    <!DOCTYPE html>
    
    <html xmlns="http://www.w3.org/1999/xhtml">
    <head runat="server">
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
        <title></title>
    </head>
    <body>
        <form id="form1" runat="server">
        <div>
            <asp:GridView ID="gvParas" runat="server">
    
            </asp:GridView>
        </div>
        </form>
    </body>
    </html>
    ---------------------------------------------------------------------
    using Night.Models;
    using NightCat.BLL;
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Web;
    using System.Web.UI;
    using System.Web.UI.WebControls;
    
    namespace NightCatWeb
    {
        public partial class WebForm1 : System.Web.UI.Page
        {
            protected void Page_Load(object sender, EventArgs e)
            {
                if (!this.IsPostBack)
                {
                    SysLogManager sm = new SysLogManager();
                    List<Sys_Log> sl = sm.GetPageList(1, 5, p => p.F_Id, p => p.F_IPAddress != "").ToList();
                    this.gvParas.DataSource = sl;
                    this.gvParas.DataBind();
                }
            }
        }
    }
    View Code
  • 相关阅读:
    遗传学详解及Matlab算法实现
    (转)非常好的理解遗传算法的例子
    Halcon学习笔记之支持向量机(二)
    Hough 变换
    主元分析PCA理论分析及应用
    Retinex图像增强算法
    Halcon学习笔记之支持向量机(一)
    阿里云OSS安装使用问题
    JS中双击和单击事件冲突解决
    JavaScript正则表达式应用---replace()
  • 原文地址:https://www.cnblogs.com/youmingkuang/p/6307112.html
Copyright © 2020-2023  润新知