entity framework 6 自己编写的通用数据类

最新推荐文章于 2021-03-17 04:26:39 发布
最新推荐文章于 2021-03-17 04:26:39 发布
阅读量588 收藏
点赞数
分类专栏： EF 
//dal类：
 public class BaseDAL
    {
        string strConn = "";
        public BaseDAL(string connString)
        {
            strConn = connString;
        }

        #region 通用增删改查
        #region 非原始sql语句方式
        /// <summary>
        /// 新增
        /// </summary>
        /// <param name="entity">实体</param>
        /// <returns>返回受影响行数</returns>
        public bool Add<T>(T entity) where T : class
        {
            using (SysDb<T> db = new SysDb<T>(strConn))
            {
                db.Entry<T>(entity).State = EntityState.Added;
                return db.SaveChanges() > 0;
            }
        }

        /// <summary>
        /// 修改
        /// </summary>
        /// <param name="entity">实体</param>
        /// <returns>返回受影响行数</returns>
        public bool Update<T>(T entity) where T : class
        {
            using (SysDb<T> db = new SysDb<T>(strConn))
            {
                db.Set<T>().Attach(entity);
                db.Entry<T>(entity).State = EntityState.Modified;
                return db.SaveChanges() > 0;
            }
        }

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="entity">实体</param>
        /// <returns>返回受影响行数</returns>
        public bool Delete<T>(T entity) where T : class
        {
            using (SysDb<T> db = new SysDb<T>(strConn))
            {
                db.Set<T>().Attach(entity);
                db.Entry<T>(entity).State = EntityState.Deleted;
                return db.SaveChanges() > 0;
            }
        }

        /// <summary>
        /// 根据条件删除
        /// </summary>
        /// <param name="deleWhere">删除条件</param>
        /// <returns>返回受影响行数</returns>
        public bool DeleteByConditon<T>(Expression<Func<T, bool>> deleWhere) where T : class
        {
            using (SysDb<T> db = new SysDb<T>(strConn))
            {
                List<T> entitys = db.Set<T>().Where(deleWhere).ToList();
                entitys.ForEach(m => db.Entry<T>(m).State = EntityState.Deleted);
                return db.SaveChanges() > 0;
            }
        }

        /// <summary>
        /// 查找单个
        /// </summary>
        /// <param name="id">主键</param>
        /// <returns></returns>
        public T GetSingleById<T>(int id) where T : class
        {
            using (SysDb<T> db = new SysDb<T>(strConn))
            {
                return db.Set<T>().Find(id);
            }
        }

        /// <summary>
        /// 查找单个
        /// </summary>
        /// <param name="seleWhere">查询条件</param>
        /// <returns></returns>
        public T GetSingle<T>(Expression<Func<T, bool>> seleWhere) where T : class
        {
            using (SysDb<T> db = new SysDb<T>(strConn))
            {
                return db.Set<T>().AsExpandable().FirstOrDefault(seleWhere);
            }
        }

        /// <summary>
        /// 获取所有实体集合
        /// </summary>
        /// <returns></returns>
        public List<T> GetAll<T>() where T : class
        {
            using (SysDb<T> db = new SysDb<T>(strConn))
            {
                return db.Set<T>().AsExpandable().ToList<T>();
            }
        }

        /// <summary>
        /// 获取所有实体集合(单个排序)
        /// </summary>
        /// <returns></returns>
        public List<T> GetAll<T, Tkey>(Expression<Func<T, Tkey>> orderWhere, bool isDesc) where T : class
        {
            using (SysDb<T> db = new SysDb<T>(strConn))
            {
                return CommonSort(db.Set<T>().AsExpandable(), orderWhere, isDesc).ToList<T>();
            }
        }

        /// <summary>
        /// 获取所有实体集合(多个排序)
        /// </summary>
        /// <returns></returns>
        public List<T> GetAll<T>(params OrderModelField[] orderByExpression) where T : class
        {
            using (SysDb<T> db = new SysDb<T>(strConn))
            {
                return CommonSort(db.Set<T>().AsExpandable(), orderByExpression).ToList();
            }
        }

        /// <summary>
        /// 单个排序通用方法
        /// </summary>
        /// <typeparam name="Tkey">排序字段</typeparam>
        /// <param name="data">要排序的数据</param>
        /// <param name="orderWhere">排序条件</param>
        /// <param name="isDesc">是否倒序</param>
        /// <returns>排序后的集合</returns>
        public IQueryable<T> CommonSort<T, Tkey>(IQueryable<T> data, Expression<Func<T, Tkey>> orderWhere, bool isDesc) where T : class
        {
            if (isDesc)
            {
                return data.OrderByDescending(orderWhere);
            }
            else
            {
                return data.OrderBy(orderWhere);
            }
        }

        /// <summary>
        /// 多个排序通用方法
        /// </summary>
        /// <typeparam name="Tkey">排序字段</typeparam>
        /// <param name="data">要排序的数据</param>
        /// <param name="orderWhereAndIsDesc">字典集合(排序条件,是否倒序)</param>
        /// <returns>排序后的集合</returns>
        public IQueryable<T> CommonSort<T>(IQueryable<T> data, params OrderModelField[] orderByExpression) where T : class
        {
            //创建表达式变量参数
            var parameter = Expression.Parameter(typeof(T), "o");

            if (orderByExpression != null && orderByExpression.Length > 0)
            {
                for (int i = 0; i < orderByExpression.Length; i++)
                {
                    //根据属性名获取属性
                    var property = typeof(T).GetProperty(orderByExpression[i].PropertyName);
                    //创建一个访问属性的表达式
                    var propertyAccess = Expression.MakeMemberAccess(parameter, property);
                    var orderByExp = Expression.Lambda(propertyAccess, parameter);

                    string OrderName = "";
                    if (i > 0)
                    {
                        OrderName = orderByExpression[i].IsDESC ? "ThenByDescending" : "ThenBy";
                    }
                    else
                        OrderName = orderByExpression[i].IsDESC ? "OrderByDescending" : "OrderBy";

                    MethodCallExpression resultExp = Expression.Call(typeof(Queryable), OrderName, new Type[] { typeof(T), property.PropertyType },
                        data.Expression, Expression.Quote(orderByExp));

                    data = data.Provider.CreateQuery<T>(resultExp);
                }
            }
            return data;
        }

        /// <summary>
        /// 根据条件查询实体集合
        /// </summary>
        /// <param name="seleWhere">查询条件 lambel表达式</param>
        /// <returns></returns>
        public List<T> GetList<T>(Expression<Func<T, bool>> seleWhere) where T : class
        {
            using (SysDb<T> db = new SysDb<T>(strConn))
            {
                return db.Set<T>().AsExpandable().Where(seleWhere).ToList();
            }
        }

        /// <summary>
        /// 根据条件查询实体集合
        /// </summary>
        /// <param name="seleWhere">查询条件 lambel表达式</param>
        /// <returns></returns>
        public List<T> GetList<T, TValue>(Expression<Func<T, TValue>> seleWhere, IEnumerable<TValue> conditions) where T : class
        {
            using (SysDb<T> db = new SysDb<T>(strConn))
            {

                return db.Set<T>().AsExpandable().WhereIn<T, TValue>(seleWhere, conditions).ToList();
            }
        }

        /// <summary>
        /// 根据条件查询实体集合(单个字段排序)
        /// </summary>
        /// <param name="seleWhere">查询条件 lambel表达式</param>
        /// <returns></returns>
        public List<T> GetList<T, Tkey>(Expression<Func<T, bool>> seleWhere, Expression<Func<T, Tkey>> orderWhere, bool isDesc) where T : class
        {
            using (SysDb<T> db = new SysDb<T>(strConn))
            {
                return CommonSort(db.Set<T>().AsExpandable().Where(seleWhere), orderWhere, isDesc).ToList();
            }
        }

        /// <summary>
        /// 根据条件查询实体集合(多个字段排序)
        /// </summary>
        /// <param name="seleWhere">查询条件 lambel表达式</param>
        /// <returns></returns>
        public List<T> GetList<T>(Expression<Func<T, bool>> seleWhere, params OrderModelField[] orderByExpression) where T : class
        {
            using (SysDb<T> db = new SysDb<T>(strConn))
            {
                return CommonSort(db.Set<T>().AsExpandable().Where(seleWhere), orderByExpression).ToList();
            }
        }

        /// <summary>
        /// 获取分页集合(无条件无排序)
        /// </summary>
        /// <returns></returns>
        public List<T> GetListPaged<T, Tkey>(int pageIndex, int pageSize, out int totalcount) where T : class
        {
            using (SysDb<T> db = new SysDb<T>(strConn))
            {
                totalcount = db.Set<T>().AsExpandable().Count();//获取总数
                //需要增加AsExpandable(),否则查询的是所有数据到内存，然后再排序  AsExpandable是linqkit.dll中的方法
                return db.Set<T>().AsExpandable().Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
            }
        }

        /// <summary>
        /// 获取分页集合(无条件单个排序)
        /// </summary>
        /// <returns></returns>
        public List<T> GetListPaged<T, Tkey>(int pageIndex, int pageSize, Expression<Func<T, Tkey>> orderWhere, bool isDesc, out int totalcount) where T : class
        {
            using (SysDb<T> db = new SysDb<T>(strConn))
            {
                totalcount = db.Set<T>().AsExpandable().Count();//获取总数
                //需要增加AsExpandable(),否则查询的是所有数据到内存，然后再排序  AsExpandable是linqkit.dll中的方法
                return CommonSort(db.Set<T>().AsExpandable(), orderWhere, isDesc).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
            }
        }

        /// <summary>
        /// 获取分页集合(无条件多字段排序)
        /// </summary>
        /// <returns></returns>
        public List<T> GetListPaged<T>(int pageIndex, int pageSize, out int totalcount, params OrderModelField[] orderByExpression) where T : class
        {
            using (SysDb<T> db = new SysDb<T>(strConn))
            {
                totalcount = db.Set<T>().AsExpandable().Count();//获取总数
                //需要增加AsExpandable(),否则查询的是所有数据到内存，然后再排序  AsExpandable是linqkit.dll中的方法
                return CommonSort(db.Set<T>().AsExpandable(), orderByExpression).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
            }
        }

        /// <summary>
        /// 获取分页集合(有条件无排序)
        /// </summary>
        /// <returns></returns>
        public List<T> GetListPaged<T, Tkey>(int pageIndex, int pageSize, Expression<Func<T, bool>> seleWhere, out int totalcount) where T : class
        {
            using (SysDb<T> db = new SysDb<T>(strConn))
            {
                totalcount = db.Set<T>().AsExpandable().Where(seleWhere).Count();//获取总数
                //需要增加AsExpandable(),否则查询的是所有数据到内存，然后再排序  AsExpandable是linqkit.dll中的方法
                return db.Set<T>().AsExpandable().Where(seleWhere).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
            }
        }

        /// <summary>
        /// 获取分页集合(有条件单个排序)
        /// </summary>
        /// <returns></returns>
        public List<T> GetListPaged<T, Tkey>(int pageIndex, int pageSize, Expression<Func<T, bool>> seleWhere,
            Expression<Func<T, Tkey>> orderWhere, bool isDesc, out int totalcount) where T : class
        {
            using (SysDb<T> db = new SysDb<T>(strConn))
            {
                totalcount = db.Set<T>().AsExpandable().Where(seleWhere).Count();//获取总数
                //需要增加AsExpandable(),否则查询的是所有数据到内存，然后再排序  AsExpandable是linqkit.dll中的方法
                return CommonSort(db.Set<T>().AsExpandable().Where(seleWhere), orderWhere, isDesc).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
            }
        }

        /// <summary>
        /// 获取分页集合(有条件多字段排序)
        /// </summary>
        /// <returns></returns>
        public List<T> GetListPaged<T>(int pageIndex, int pageSize, Expression<Func<T, bool>> seleWhere,
            out int totalcount, params OrderModelField[] orderModelFiled) where T : class
        {
            using (SysDb<T> db = new SysDb<T>(strConn))
            {
                totalcount = db.Set<T>().AsExpandable().Where(seleWhere).Count();//获取总数
                //需要增加AsExpandable(),否则查询的是所有数据到内存，然后再排序  AsExpandable是linqkit.dll中的方法
                return CommonSort(db.Set<T>().AsExpandable().Where(seleWhere), orderModelFiled).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
            }
        }
        #endregion

        #region 原始sql操作
        /// <summary>
        /// 执行操作
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="paras"></param>
        public void ExecuteSql(string sql, params object[] paras)
        {
            using (SysDb db = new SysDb(strConn))
            {
                db.Database.ExecuteSqlCommand(sql, paras);
            }
        }

        /// <summary>
        /// 查询列表
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="sql"></param>
        /// <param name="paras"></param>
        /// <returns></returns>
        public List<T> QueryList<T>(string sql, params object[] paras) where T : class
        {
            using (SysDb db = new SysDb(strConn))
            {
                return db.Database.SqlQuery<T>(sql, paras).ToList();
            }
        }

        /// <summary>
        /// 查询单个
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="sql"></param>
        /// <param name="paras"></param>
        /// <returns></returns>
        public T QuerySingle<T>(string sql, params object[] paras) where T : class
        {
            using (SysDb<T> db = new SysDb<T>(strConn))
            {
                return db.Database.SqlQuery<T>(sql, paras).FirstOrDefault();
            }
        }

        /// <summary>
        /// 执行事务
        /// </summary>
        /// <param name="lsSql"></param>
        /// <param name="lsParas"></param>
        public void ExecuteTransaction(List<String> lsSql, List<Object[]> lsParas)
        {
            using (SysDb db = new SysDb(strConn))
            {
                using (var tran = db.Database.BeginTransaction())
                {
                    try
                    {
                        for (int i = 0; i < lsSql.Count; i++)
                        {
                            if (lsParas != null && lsParas.Count > 0)
                            {
                                db.Database.ExecuteSqlCommand(lsSql[i], lsParas[i]);
                            }
                        }
                        foreach (String item in lsSql)
                        {
                            db.Database.ExecuteSqlCommand(item);
                        }

                        tran.Commit();
                    }
                    catch (Exception ex)
                    {
                        tran.Rollback();
                        throw ex;
                    }
                }
            }
        }
        #endregion
        #endregion

        #region 通用属性
        /// <summary>
        /// 获取数据库服务器当前时间。
        /// </summary>
        public DateTime ServerTime
        {
            get
            {
                using (SysDb db = new SysDb(strConn))
                {
                    String sql = "SELECT GETDATE()";
                    Object objServerTime = db.Database.SqlQuery<Object>(sql);
                    return Convert.ToDateTime(objServerTime);
                }
            }
        }

        /// <summary>
        /// 获取数据库版本。
        /// </summary>
        public String DatabaseVersion
        {
            get
            {
                using (SysDb db = new SysDb(strConn))
                {
                    try
                    {
                        String sql = "SELECT Version FROM Sys_Version";
                        Object objServerTime = db.Database.SqlQuery<Object>(sql);
                        return Convert.ToString(objServerTime);
                    }
                    catch
                    {
                    }
                    return String.Empty;
                }
            }
        }
        #endregion

    }
    public static class QueryableExtension
    {
        /// <summary>
        /// 扩展方法  支持 in 操作
        /// </summary>
        /// <typeparam name="TEntity">需要扩展的对象类型</typeparam>
        /// <typeparam name="TValue">in 的值类型</typeparam>
        /// <param name="source">需要扩展的对象</param>
        /// <param name="valueSelector">值选择器 例如c=>c.UserId</param>
        /// <param name="values">值集合</param>
        /// <returns></returns>
        public static IQueryable<TEntity> WhereIn<TEntity, TValue>(this IQueryable<TEntity> source, Expression<Func<TEntity, TValue>> valueSelector,
                IEnumerable<TValue> values)
        {
            if (null == valueSelector) { throw new ArgumentNullException("valueSelector"); }
            if (null == values) { throw new ArgumentNullException("values"); }
            ParameterExpression p = valueSelector.Parameters.Single();

            if (!values.Any())
            {
                return source;
            }
            var equals = values.Select(value => (Expression)Expression.Equal(valueSelector.Body, Expression.Constant(value, typeof(TValue))));
            var body = equals.Aggregate<Expression>((accumulate, equal) => Expression.Or(accumulate, equal));
            return source.Where(Expression.Lambda<Func<TEntity, bool>>(body, p));
        }
    }
    public struct OrderModelField
    {

        public bool IsDESC { get; set; }
        public string PropertyName { get; set; }
    }

dbcontext类：

    public class SysDb : DbContext
    {
        bool isNew = true;//是否是新的sql执行
        string strMsg = "";//sql执行的相关信息
        string strConn = "";//数据库连接字符串
        string UserName = "";//日志用户名称
        string AdditionalInfo = "";//日志额外信息
        public SysDb(string connString) : // 数据库链接字符串
            base(connString)
        {
            strConn = connString;
            Database.SetInitializer<SysDb>(null);//设置为空，防止自动检查和生成
            base.Database.Log = (info) => Debug.WriteLine(info);
        }

        public SysDb(string connString, string logUserName, string logAdditionalInfo) : // 数据库链接字符串
            base(connString)
        {
            strConn = connString;
            Database.SetInitializer<SysDb>(null);//设置为空，防止自动检查和生成
            UserName = logUserName;
            AdditionalInfo = logAdditionalInfo;
            base.Database.Log = AddLogger;
        }

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            //去掉复数映射
            modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();
            base.OnModelCreating(modelBuilder);
        }

        /// <summary>
        /// 添加日志
        /// </summary>
        /// <param name="info"></param>
        public void AddLogger(string info)
        {
            if (info != "\r\n" && (!info.Contains("Sys_EventLog")))
            {
                string strTemp = info.ToUpper().Trim();
                if (isNew)
                {
                    //记录增删改
                    if (strTemp.StartsWith("INSERT") || strTemp.StartsWith("UPDATE") || strTemp.StartsWith("DELETE"))
                    {
                        strMsg = info;
                        isNew = false;
                    }
                }
                else
                {
                    if (strTemp.StartsWith("CLOSED CONNECTION"))
                    {
                        //增加新日志
                        using (SysDb db = new SysDb(strConn))
                        {
                            try
                            {
				//保存日志到数据库或其他地方

                            }
                            catch (Exception ex)
                            {
                                using (System.IO.StreamWriter sw = new System.IO.StreamWriter(AppDomain.CurrentDomain.BaseDirectory + "//logError.txt"))
                                {
                                    sw.Write(ex.Message);
                                    sw.Flush();
                                }
                            }
                        }
                        //清空
                        strMsg = "";
                        isNew = true;
                    }
                    else
                    {
                        strMsg += info;
                    }
                }

            }
        }

        
    }
    public class SysDb<T> : SysDb where T : class
    {
        public SysDb(string connString) : // 数据库链接字符串
            base(connString)
        {
            Database.SetInitializer<SysDb<T>>(null);//设置为空，防止自动检查和生成
        }

        public SysDb(string connString, string logUserName, string logAdditionalInfo) : // 数据库链接字符串
            base(connString,logUserName,logAdditionalInfo)
        {
            Database.SetInitializer<SysDb<T>>(null);//设置为空，防止自动检查和生成
        }

        public DbSet<T> Entities { get; set; }
    }

界面使用：（bll层忽略） 

 public class BusinessController : Controller
    {
        //
        // GET: /Jygl/Business/
        BaseBLL basebll = new BaseBLL(WebHelper.Conn);

        public ActionResult GetXMList(int page,int rows)
        {
            int count = 0;
            //查询条件
            //Expression<Func<JY_XM, bool>> searchPredicate = PredicateBuilder.True<JY_XM>();
            //searchPredicate = searchPredicate.And(c => c.UserName.Contains(""));
            Expression<Func<JY_XM, int>> keySelector = u => u.UID;
            string str = ExceptionHelper<JY_XM>.TryCatchPageQueryJson<int>(basebll.GetListPaged, page, rows, keySelector, false, out count);
            return Content(str); 
        }

        [HttpPost]
        public ActionResult XMEdit(JY_XM jyxm)
        {
            basebll.Add(jyxm);
            return View();
        }

        public ActionResult GetAllGCLB()
        {

            List<DICT_GCLB> lsGCLB = basebll.GetAll<DICT_GCLB>();
            DICT_GCLB dicNew=new DICT_GCLB();
            dicNew.GCLBText="-请选择-";
            dicNew.GCLBId=0;
            lsGCLB.Add(dicNew);

            return Content(WebHelper.Json(lsGCLB));
        }

        public ActionResult GetAllArea()
        {
            List<DICT_Area> lsArea = basebll.GetAll<DICT_Area>();
            DICT_Area dicNew=new DICT_Area();
            dicNew.AreaText="-请选择-";
            dicNew.AreaId=0;
            lsArea.Add(dicNew);
            return Content(WebHelper.Json(lsArea));
        }
    }

个人原创，欢迎转载，尊重劳动成果，引用注明来源。

http://blog.csdn.net/laokaizzz/article/details/25730813


白天吃黑片
关注
专栏目录
GameFramework框架详解之 Entity实体
TxNet
03-27 2113
GameFramework中Entity，一般用于游戏运行时动态加载的游戏对象，如角色，怪物，武器，技能，子弹，特效等。一般来说，我们想创建一个实体，最简单的方法当然是Resource.Load()+Instantiate()，然后放到合适的位置，播放合适的动画即可。但是GameFramework却给每个实体定义了一个Entity类，一个EntityLogic类，一个EntityData类，初次用起来会感觉很吃力，甚至有的人觉得完全没必要，甚至放弃了GameFramework。
基于Entity Framework5的通用数据访问层实现
06-16
基于Entity Framework5的通用数据访问层实现，全面数据访问接口，独立数据库，所有数据库都能直接使用
Entity Framework Demo(一) 简单搭建环境
weixin_30507269的博客
05-20 241
Entity Framwork(实体框架，简称EF)是ORM(Object Relational Mapping，对象映射关系)的一个解决方案。 EF允许项目将数据库的表映射为实体，并封装了操作方法，方便开发人员直接操作数据库。 EF有三种开发模式，分别是： Database First(数据库先行): 将已存在的数据库中的表映射为实体； Code First(代码先行):先编写代码，再通...
EntityFramework实现指定字段的通用赋值
https://github.com/conanl5566
10-14 288
1、背景 平常我们在建表的时候一般除了业务字段，还会加上如Create_Date 、Create_User 、Update_Date 、Update_User这样的通用字段 ； public Nullable<System.DateTime> Create_Date { get; set; } public string Create_User { get; set; } public Nullable<System.DateTime> Upd
Entity Framework orm教程
08-21
- 包括EntityFramework6和EntityFrameworkCore两个版本的API参考，以及DbSet类等高级功能。 文档中还提到了如何浏览EntityFramework6 API，并且按照命名空间进行排列，方便查找和使用。对于开发者来说，这些API是...
使用 LINQ To SQL 和Entity Framework实现灵活的数据访问
01-08
为了与 LINQ to SQL 或 Entity Framework 生成的实体保持一致，我们可以选择不使用这些自动生成的实体类，而是创建自己的 DTO 类，这些 DTO 类只包含必要的属性，比如 ID、名称等。 ##### 3. 跟踪实体状态 在使用 ...
EFCore.GenericRepository:该存储库包含Entity Framework Core的通用存储库实现
03-29
该库是EF Core ORM的通用存储库实现，它将消除开发人员为每个.NET Core和.NET项目编写存储库层的麻烦。 :star: 给一颗星 :star: 如果您发现此库有用，请不要忘了鼓励我给此存储库加星号，以使我做更多的事情。 ...
基于EF的通用访问类(C#)
weixin_30474613的博客
03-25 165
1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 using System.Text; 5 using System.Threading.Tasks; 6 using System.Data.Entity; 7 8 namespace DAL 9 { 10 ...
NET基础篇——Entity Framework 数据转换层通用类
weixin_30378311的博客
06-14 199
在实现基础的三层开发的时候，大家时常会在数据层对每个实体进行CRUD的操作，其中存在相当多的重复代码。为了减少重复代码的出现，通常都会定义一个共用类，实现相似的操作，下面为大家介绍一下Entity Framework时常用到的通用类。首先在数据库建立起几个关联表：Person、Company、Position，三个实体之间通过导航属性进行相互引用。 下面为大家分别...
AppBox升级进行时 - 如何向OrderBy传递字符串参数（Entity Framework）
weixin_34023863的博客
09-10 92
AppBox 是基于 FineUI 的通用权限管理框架，包括用户管理、职称管理、部门管理、角色管理、角色权限管理等模块。   Entity Framework提供的排序功能  再来回顾一下上篇文章，加载用户列表并进行排序数据库分页的代码： var q = DB.Users.Include(u =&gt; u.Dept); // 在用户名称中搜索 string sear...
EntityFreamWork 项目总结
weixin_30851867的博客
02-29 98
　　前段时间一直在忙着处理一个B2C的商城项目，未来得整理这次项目的心得，今天偶有空闲便写下这篇文章以记录整个项目的设计及自我总结。 这个项目是我综合传智播客教学基础将传统三层架构与EntityFramework进行整合，其中如有不对之处，还望各位高手指点。 　　 一、项目结构:经典三层+EF 　　首先，先说说整个项目的结构。该项目使用 Visual Studio2013+EF4...
MySQL linq 分页,EFCore+Mysql仓储层建设(分页、多字段排序、部分字段更新)
weixin_35706067的博客
03-17 371
前沿园子里已有挺多博文介绍了EFCore+Mysql/MSSql如何进行使用，但实际开发不会把EF层放在Web层混合起来，需要多个项目配合结构清晰的进行分层工作，本文根据个人实践经验总结将各个项目进行分层，仅供想自己搭建,包含数据仓储以及分页多字段排序。目录结构 1.实体层(EF)搭建 1.1添加Nuget包 1.2添加实体 1.3构造DbContext 1.4数据迁移生成数据库 2.仓储层搭建 ...
EF 通用数据层类
weixin_34319817的博客
03-09 325
EF 通用数据层父类方法小结 转载：http://www.cnblogs.com/yq-Hua/p/4165344.html MSSql 数据库 数据层 父类 增删改查：   using System; using System.Collections.Generic; using System.Data; using System.Data.Entity; using ...
EF 通用数据层 增删改查操作，泛型类II
Johnson在Csdn的小窝
06-15 8178
using System; using System.Collections.Generic; using System.Data.Entity.Infrastructure; using System.Linq; using System.Linq.Expressions; using System.Reflection; using System.Text;   namespa
entity framework mvc dal bll类 封装
laokaizzz的专栏
04-10 1834
参考： http://www.cnblogs.com/weilengdeyu/p/3588472.html http://blog.csdn.net/xjn030594/article/details/8946996 
.NET Core实战项目之CMS 第十二章 开发篇-Dapper封装CURD及仓储代码生成器实现
依乐祝的博客
12-19 1573
.NET Core实战项目之CMS 第十二章 开发篇-Dapper封装CURD及仓储代码生成器实现 本篇我将带着大家一起来对Dapper进行下封装并实现基本的增删改查、分页操作的同步异步方法的实现（已实现MSSQL，MySql，PgSQL）。同时我们再实现一下仓储层的代码生成器，这样的话，我们只需要结合业务来实现具体的业务部分的代码就可以了，可以大...
精通Entity Framework Core：现代数据访问与实战
6. **移动应用开发**：了解如何在Xamarin应用中使用Entity Framework Core，实现跨平台的数据访问。 7. **附录**：书中包含一个在线附录，专门介绍Entity Framework Core 2.1版本的更新和改进，帮助读者保持对最新...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值