ORM框架学习之EF



首先推荐一篇很好的EF文章翻译,可以系统的学习一遍。
《Entity Framework 6 Recipes》中文翻译系列

EF使用体会

优点:

  • 可以省去Ado.net复杂的管道连接代码。
  • 通过简单的引用就能完成对数据库的连接和开发。
  • 可以省去一些SQL语句的编写,对一些底层可能需要适配多数据库提供了一些方便。

缺点:

  • 学习成本较高,如果不怎么懂SQL,索引的一些数据库知识,也写不太好相对优化的Linq查询,所有EF既要懂Sql又懂Linq是最好的。
  • 比较大,EF的dll默认是连接SqlServer若要连接其它数据库引用其它数据库的DLL加起来10几M,而像Dapper这样的轻量级框架才100多K。
  • 查询只支持数据结果对实体的转换,不支持DataTable。

资料汇总

EF连接

连接数据库的多种方法

EF配置

EF的霸气配置秒杀一切

EF进阶

1.学习LINQ To Sql

LINQ To Sql语法汇总

2.学习Expression

LINQ Expression高级篇

3.优化测试

EF查询百万级数据的性能测试

简单的类库

项目如图:

Data.Map中放相关的EntityTypeConfiguration
Data.Module中相关的实体

这里贴一下EFContext和EFDatabase的类

using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Data.Entity.ModelConfiguration;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace Data.EF
{
    //[DbConfigurationType(typeof(MySql.Data.Entity.MySqlEFConfiguration))]  Mysql数据库配置
    public class EFContext : DbContext, IDisposable
    {
        public EFContext(string dbName)
            : base(dbName)
        {
            Database.SetInitializer<EFContext>(null);
            this.Configuration.AutoDetectChangesEnabled = false;
            this.Configuration.ValidateOnSaveEnabled = false;
            this.Configuration.LazyLoadingEnabled = false;
            this.Configuration.ProxyCreationEnabled = false;
        }

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            string assembleFileName = Assembly.GetExecutingAssembly().CodeBase.Replace("Data.EF.DLL", "Data.Map.dll").Replace("file:///", "");
            Assembly asm = Assembly.LoadFile(assembleFileName);
            var typesToRegister = asm.GetTypes()
            .Where(type => !String.IsNullOrEmpty(type.Namespace))
            .Where(type => type.BaseType != null && type.BaseType.IsGenericType && type.BaseType.GetGenericTypeDefinition() == typeof(EntityTypeConfiguration<>));
            foreach (var type in typesToRegister)
            {
                dynamic configurationInstance = Activator.CreateInstance(type);
                modelBuilder.Configurations.Add(configurationInstance);
            }
            base.OnModelCreating(modelBuilder);
        }
    }

}
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.Data.Entity;
using System.Data.Entity.Core.Metadata.Edm;
using System.Data.Entity.Infrastructure;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Text;

namespace Data.EF
{
    public class EFDatabase
    {
        /// <summary>
        /// 返回字符集
        /// </summary>
        /// <typeparam name="Table"></typeparam>
        /// <returns></returns>
        public DbSet<Table> Set<Table>() where Table : class
        {
            return dbcontext.Set<Table>();
        }

        #region 属性
        /// <summary>
        /// 获取 当前使用的数据访问上下文对象
        /// </summary>
        public DbContext dbcontext { get; set; }
        /// <summary>
        /// 事务对象
        /// </summary>
        public DbTransaction dbTransaction { get; set; }

        #endregion

        #region 构造函数

        public EFDatabase(string dataBase)
        {
            dbcontext = new EFContext(dataBase);
        }

        #endregion

        #region 私有方法

        /// <summary>
        /// 获取实体类键值(缓存)
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entity"></param>
        /// <returns></returns>
        private static Hashtable GetPropertyInfo<T>(T entity)
        {
            Type type = entity.GetType();
            object CacheEntity = null;
            if (CacheEntity == null)
            {
                Hashtable ht = new Hashtable();
                PropertyInfo[] props = type.GetProperties();
                foreach (PropertyInfo prop in props)
                {
                    string name = prop.Name;
                    object value = prop.GetValue(entity, null);
                    ht[name] = value;
                }
                return ht;
            }
            else
            {
                return (Hashtable)CacheEntity;
            }
        }

        /// <summary>
        /// 存储过程语句
        /// </summary>
        /// <param name="procName">存储过程名称</param>
        /// <param name="dbParameter">执行命令所需的sql语句对应参数</param>
        /// <returns></returns>
        private static string BuilderProc(string procName, params DbParameter[] dbParameter)
        {
            StringBuilder strSql = new StringBuilder("exec " + procName);
            if (dbParameter != null)
            {
                foreach (var item in dbParameter)
                {
                    strSql.Append(" " + item + ",");
                }
                strSql = strSql.Remove(strSql.Length - 1, 1);
            }
            return strSql.ToString();
        }

        private int Delete<T>(T entity) where T : class
        {
            dbcontext.Set<T>().Attach(entity);
            dbcontext.Set<T>().Remove(entity);
            return dbTransaction == null ? dbcontext.SaveChanges() : 0;
        }

        private int Delete<T>(IEnumerable<T> entities) where T : class
        {
            foreach (var entity in entities)
            {
                dbcontext.Set<T>().Attach(entity);
                dbcontext.Set<T>().Remove(entity);
            }
            return dbTransaction == null ? dbcontext.SaveChanges() : 0;
        }

        #endregion

        public EFDatabase BeginTrans()
        {
            DbConnection dbConnection = ((IObjectContextAdapter)dbcontext).ObjectContext.Connection;
            if (dbConnection.State == ConnectionState.Closed)
            {
                dbConnection.Open();
            }
            dbTransaction = dbConnection.BeginTransaction();
            return this;
        }

        public int Commit()
        {
            try
            {
                int returnValue = dbcontext.SaveChanges();
                if (dbTransaction != null)
                {
                    dbTransaction.Commit();
                    this.Close();
                }
                return returnValue;
            }
            catch (Exception ex)
            {
                if (ex.InnerException != null )
                {
                    throw ex.InnerException;
                }
                throw;
            }
            finally
            {
                if (dbTransaction == null)
                {
                    this.Close();
                }
            }
        }

        public void Rollback()
        {
            this.dbTransaction.Rollback();
            this.dbTransaction.Dispose();
            this.Close();
        }

        public void Close()
        {
            dbcontext.Dispose();
        }

        public int ExecuteBySql(string strSql)
        {
            dbcontext.Database.CommandTimeout = 60;
            return dbcontext.Database.ExecuteSqlCommand(strSql);
        }

        public int ExecuteBySql(string strSql, params object[] dbParameter)
        {
            dbcontext.Database.CommandTimeout = 60;
            return dbcontext.Database.ExecuteSqlCommand(strSql, dbParameter);
        }

        public int ExecuteByProc(string procName)
        {
              return dbcontext.Database.ExecuteSqlCommand(BuilderProc(procName));
        }

        public int ExecuteByProc(string procName, System.Data.Common.DbParameter[] dbParameter)
        {
              return dbcontext.Database.ExecuteSqlCommand(BuilderProc(procName, dbParameter), dbParameter);
        }

        public T FindEntity<T>(object keyValue) where T : class
        {
            return dbcontext.Set<T>().Find(keyValue);
        }

        public T FindEntity<T>(Expression<Func<T, bool>> condition) where T : class, new()
        {
              return dbcontext.Set<T>().Where(condition).FirstOrDefault();
        }

        public IQueryable<T> FindList<T>(Expression<Func<T, bool>> condition) where T : class, new()
        {
            return dbcontext.Set<T>().Where(condition);
        }

        public IQueryable<T> FindList<T>(string strSql) where T : class
        {
            return dbcontext.Set<T>().SqlQuery(strSql).AsQueryable();
        }

        public IQueryable<T> FindList<T>(string strSql, DbParameter[] dbParameter) where T : class
        {
            return dbcontext.Set<T>().SqlQuery(strSql, dbParameter).AsQueryable();
        }

        public int Delete<T>(object propertyValue, string propertyName) where T : class
        {
              string TableName = typeof(T).Name;
              return this.ExecuteBySql("delete from " + TableName + " where " + propertyName + " = {0}", propertyValue);
        }

        public int Delete<T>(Expression<Func<T, bool>> condition) where T : class, new()
        {
            IEnumerable<T> entities = dbcontext.Set<T>().Where(condition).ToList();
            return entities.Count() > 0 ? Delete(entities) : 0;
        }

        public int Update<T>(T entity) where T : class
        {
            dbcontext.Set<T>().Attach(entity);
            Hashtable props = GetPropertyInfo<T>(entity);
            foreach (string item in props.Keys)
            {
                object value = dbcontext.Entry(entity).Property(item).CurrentValue;
                if (value != null)
                {
                    if (value.ToString() == "&nbsp;"||value.ToString().Trim()=="")
                        dbcontext.Entry(entity).Property(item).CurrentValue = null;
                    dbcontext.Entry(entity).Property(item).IsModified = true;
                }
            }
            return dbTransaction == null ? this.dbcontext.SaveChanges() : 0;
        }

        public int Update<T>(IEnumerable<T> entities) where T : class
        {
            foreach (var entity in entities)
            {
                this.Update(entity);
            }
            return dbTransaction == null ? this.dbcontext.SaveChanges() : 0;
        }

    }
}

原文地址:https://www.cnblogs.com/kaoleba/p/9739170.html

时间: 2024-10-10 04:25:20

ORM框架学习之EF的相关文章

ORM框架学习(二)

ORM框架--新增数据 今天的内容对照上一节内容,上一节内容是对数据的查询,本节主要是对数据的新增.程序入口代码如下 static void Main(string[] args) { SqlHelper help = new SqlHelper(); UserModel u1 = help.Query<UserModel>(1); Company com1 = help.Query<Company>(2); bool re1 = help.AddData(u1); bool re

Mego(2) - NET主流ORM框架分析

接上文我们测试了各个ORM框架的性能,大家可以很直观的看到各个ORM框架与原生的ADO.NET在境删改查的性能差异.这里和大家分享下我对ORM框架的理解及一些使用经验. ORM框架工作原理 典型ORM框架实现 EF功能最强的ORM EF与EFCore缺陷 ORM框架工作原理 所有的ORM框架的工作原理都离不开下面这张图,只是每个框架的实现程度不同但是最终的目的是相同的. 如果是一个ORM框架那么一定会有上图中蓝色部分的这几个元素,无论是增删改查对于ORM一定是以对象为起点,使用对象构造出LINQ

[ASP.NET MVC]: - EF框架学习手记

1.EF(Entity Framework)实体框架EF是ADO.NET中的一组支持开发面向数据的软件应用程序的技术,是微软的一个ORM框架. 2.什么是ORM?ORM指的是面向对象的对象模型和关系型数据库的数据结构之间的互相转换.(表实体跟表之间的相互转换)ORM框架有很多,EF框架是ORM框架的其中一种,是实现了ORM思想的框架. O=>表实体M=>映射关系R=>数据库.表 3.创建EF,添加-新建项-ADO.NET 实体数据模型<configuration>  <

ORM框架EF(一)

应用程序和数据库采用Tcp协议通讯 ORM框架有: NHibernate ,Dapper ,Mybatis 底层是 ADO.Net 好处: 1.面向对象 2.没有sql减少学习成本,快速开发 3.编译检测会更有用(写sql,字段改了,漏改sql就会异常) 3.有编译检测(改了数据库字段,必须修改,否则报错)? 4.支持延迟特性,缓存 缺陷: 1.sql是自动生成,比较僵化,不确定是否使用索引 2.需要很多反射,对时间和空间有损耗(类,属性,特性) 3.比较复杂的查询不合适,用SQL 或 存储过程

Android 数据库ORM框架GreenDao学习心得及使用总结&lt;一&gt;

Android 数据库ORM框架GreenDao学习心得及使用总结<一> 转: http://www.it165.net/pro/html/201401/9026.html 最近在对开发项目的性能进行优化.由于项目里涉及了大量的缓存处理和数据库运用,需要对数据库进行频繁的读写.查询等操作.因此首先想到了对整个项目的数据库框架进行优化. 原先使用android本身内置的sqllite,也就是用的最基本的SQLiteOpenHelper方法,这种方法对自己来说比较方便易懂.但是在使用过程中感觉很繁

【转载】Android开源:数据库ORM框架GreenDao学习心得及使用总结

转载链接:http://www.it165.net/pro/html/201401/9026.html 最近在对开发项目的性能进行优化.由于项目里涉及了大量的缓存处理和数据库运用,需要对数据库进行频繁的读写.查询等操作.因此首先想到了对整个项目的数据库框架进行优化. 原先使用android本身内置的sqllite,也就是用的最基本的SQLiteOpenHelper方法,这种方法对自己来说比较方便易懂.但是在使用过程中感觉很繁琐,从建表到对表的增删改查等操作,如果表对象的属性很多,就需要使用大量的

抛弃EF,20分构建一个属于自己的ORM框架

相信EF大家都不陌生了,因为数据库表跟程序实体是一一对应的原因,我们能够通过lambda这种函数式的编程方式进行操作数据库,感觉非常清晰明了.与我们直接写SQL相比,lambda是强类型,拥有更好的扩展性,伸缩性,而且编程更加的方便,快捷..下面我们就基于Expression和lambda来与大家构建一个属于自己的ORM框架. 思路的话很简单,就是将lambda转换成我们对应的数据库所需的查询条件,然后执行查询,再将结果以反射的方式封装成List<T>返回出去. Expression 大家使用

ORM框架之一EF理解性

1.ORM概念 对象关系映射(英语:Object Relational Mapping,简称ORM,或O/RM,或O/R mapping),是一种程序技术,用于实现面向对象编程语言里不同类型系统的数据之间的转换.从效果上说,它其实是创建了一个可在编程语言里使用的“虚拟对象数据库”. 1.2,概念理解 O(Object) 它是程序设计中的对象,具体说来,也就是在开发过程中,所建立的Model层,在Model层中,每一个类都描述了一个对象,O就当理解为model层 R(Relational ) 它是

第六章 Django框架学习——ORM详解

第六章 Django框架学习--ORM介绍与常用方法 一.ORM介绍 二.ORM中的常用字段和参数 三.ORM中的关系字段--一对一(OneToOneField) 四.ORM中的关系字段--多对多(ManyToManyField) 五.ORM中的元信息 一.ORM介绍(部分内容前面的章节已经介绍过,此处只做简单介绍) 什么是ORM(what): ORM是通过使用描述对象和数据库之间映射的元数据,将程序中的对象自动持久化到关系数据库中. Django中的ORM: Django配置数据库 1.在se