ORM之EF初识

之前有写过ef的codefirst，今天来更进一步认识EF！

一：EF的初步认识

ORM(Object Relational Mapping)：对象关系映射，其实就是一种对数据访问的封装。主要实现流程如下图：

EF：是一种通过映射操作实现数据交互的ORM框架技术

今天我们主要先初步认识一下EF6，EntityFramwork6能支持多数据库；支持函数，存储过程；并且跟VS集成的比较好；能够跟项目完美结合；能基本实现增删改查，里面有两个主要的组成部分：Context（映射数据库实例）和实体类（跟数据库的映射关系表）

Visual Studio可以使用四种方式来创建EF的项目，分别如下：

第一是：EntityFramework DBFirst，这个是数据库优先，传统的开发模式，有个很重的edmx

第二种是：EntityFramework codeFirst from db && codeFirst，这个代码先行，不关心数据库，从业务出发，然后能自动生成数据库。

二：ef中我们如果想要看到底层生成的sql语句，有两种方式：

1：使用sqlserver中的sqlprofiler 监测工具，这个每次执行都会得到相应的sql的

2：在项目中添加context.Database.Log += s => Console.WriteLine($"当前执行sql:{s}"); 这个会把每次操作数据库的日志全部打印出来的，有兴趣的可以自己试一下。

三：如果数据库的字段跟项目中实体的字段名字不匹配，可以通过下面三种方式来实现：

1：使用特性直接完成，比如在实体类头部或者字段头部增加对应的特性，如下面的【Table】和【Column】等特性：

 [Table("JD_Commodity_001")]
 public partial class JDCommodity001
 {
     public int Id { get; set; }

     public long? ProductId { get; set; }

     public int? CategoryId { get; set; }

     [StringLength(500)]
     [Column("Title")]
     public string Text { get; set; }
 }

2：在DbContext中的OnModelCreating中完成链式映射，具体代码如下：

 protected override void OnModelCreating(DbModelBuilder modelBuilder)
 {
     Database.SetInitializer(new CreateDatabaseIfNotExists<CodeFirstFromDBContext>());

     modelBuilder.Entity<JDCommodity002>()
         .ToTable("JD_Commodity_002")
         .Property(c => c.Text).HasColumnName("Title");
 }

3：DbContext中的OnModelCreating中增加配置文件，具体代码如下：

A：首先先创建JDCommodity003Mapping映射类然后继承于 EntityTypeConfiguration<JDCommodity003>，具体如下：

public class JDCommodity003Mapping : EntityTypeConfiguration<JDCommodity003>
{
    public JDCommodity003Mapping()
    {
        this.ToTable("JD_Commodity_003");
        this.Property(c => c.Text).HasColumnName("Title");
    }
}

B：然后在DbContext中的OnModelCreating增加配置文件：

 protected override void OnModelCreating(DbModelBuilder modelBuilder)
 {
     modelBuilder.Configurations.Add(new JDCommodity003Mapping());
 }

通过上面三种方式都能实现实体类与数据库表对应的映射。

四：EF中复杂的查询以及写sql语句进行查询

1：EF普通的查询，使用IQuerable和linq的方式查询，如下：

#region 其他查询
            using (JDDbContext dbContext = new JDDbContext())
            {
                {
                    var list = dbContext.Users.Where(u => new int[] { 1, 2, 3, 5, 8, 9, 10, 11, 12, 14, 17 }
                    .Contains(u.Id));//in查询
                    //这些都是延迟加载，只有用到list的话才会实际去查询数据库
                    foreach (var user in list) 
                    {
                        Console.WriteLine(user.Name ?? "Name为空");
                    }
                }
                {
                    //没有任何差别，只有写法上的熟悉
                    var list = from u in dbContext.Users
                               where new int[] { 1, 2, 3, 5, 7, 8, 9, 10, 11, 12, 14 }.Contains(u.Id)
                               where u.Id>14
                               select u;
                    //上面这个也是延迟加载，只有用到list的话才会实际去查询数据库
                    foreach (var user in list)
                    {
                        Console.WriteLine(user.Name??"name为空");
                    }
                }
                {
                    var list = dbContext.Users.Where(u => new int[] { 1, 2, 3, 5, 7, 8, 9, 10, 11, 12, 14, 18, 19, 20, 21, 22, 23 }.Contains(u.Id))
                                              .OrderBy(u => u.Id)
                                              .Select(u => new
                                              {
                                                  Account = u.Account,
                                                  Pwd = u.Password
                                              }).Skip(3).Take(5);
                    foreach (var user in list)
                    {
                        Console.WriteLine(user.Pwd);
                    }
                }
                {
                    var list = (from u in dbContext.Users
                                where new int[] { 1, 2, 3, 5, 7, 8, 9, 10, 11, 12, 14 }.Contains(u.Id)
                                orderby u.Id
                                select new
                                {
                                    Account = u.Account,
                                    Pwd = u.Password
                                }).Skip(3).Take(5);

                    foreach (var user in list)
                    {
                        Console.WriteLine(user.Account);
                    }
                }

                {
                    var list = dbContext.Users.Where(u => u.Name.StartsWith("小") && u.Name.EndsWith("新"))
                                               .Where(u => u.Name.EndsWith("新"))
                                               .Where(u => u.Name.Contains("小新"))
                                               .Where(u => u.Name.Length < 5)
                                               .OrderBy(u => u.Id);

                    foreach (var user in list)
                    {
                        Console.WriteLine(user.Name);
                    }
                }
                {
                    var list = from u in dbContext.Users
                               join c in dbContext.Companies on u.CompanyId equals c.Id
                               where new int[] { 1, 2, 3, 4, 6, 7, 10 }.Contains(u.Id)
                               select new
                               {
                                   Account = u.Account,
                                   Pwd = u.Password,
                                   CompanyName = c.Name
                               };
                    foreach (var user in list)
                    {
                        Console.WriteLine("{0} {1}", user.Account, user.Pwd);
                    }
                }
                {
                    var list = from u in dbContext.Users
                               join c in dbContext.Categories on u.CompanyId equals c.Id
                               into ucList
                               from uc in ucList.DefaultIfEmpty()
                               where new int[] { 1, 2, 3, 4, 6, 7, 10 }.Contains(u.Id)
                               select new
                               {
                                   Account = u.Account,
                                   Pwd = u.Password
                               };
                    foreach (var user in list)
                    {
                        Console.WriteLine("{0} {1}", user.Account, user.Pwd);
                    }
                }
            }
            #endregion

2：EF自定义sql语句，然后EF框架自己调用sql执行sql，可以使用ado.net自带的事务来操作。

#region 自定义sql，然后ef框架调用
            using (JDDbContext dbContext = new JDDbContext())
            {
                {
                    DbContextTransaction trans = null;
                    try
                    {
                        trans = dbContext.Database.BeginTransaction();
                        string sql = "Update [User] Set Name='小新' WHERE Id=@Id";
                        SqlParameter parameter = new SqlParameter("@Id", 1);
                        dbContext.Database.ExecuteSqlCommand(sql, parameter);
                        trans.Commit();
                    }
                    catch (Exception ex)
                    {
                        if (trans != null)
                            trans.Rollback();
                        throw ex;
                    }
                    finally
                    {
                        trans.Dispose();
                    }
                }
                {
                    DbContextTransaction trans = null;
                    try
                    {
                        trans = dbContext.Database.BeginTransaction();
                        string sql = "SELECT * FROM [User] WHERE Id=@Id";
                        SqlParameter parameter = new SqlParameter("@Id", 1);
                        List<User> userList = dbContext.Database.SqlQuery<User>(sql, parameter).ToList<User>();
                        trans.Commit();
                    }
                    catch (Exception ex)
                    {
                        if (trans != null)
                            trans.Rollback();
                        throw ex;
                    }
                    finally
                    {
                        trans.Dispose();
                    }
                }
            }
            #endregion

五：EF的IQuerable延迟和IEnumerable的延迟加载的比较跟区别，首先我们写了一个例子如下：

#region
            //userList是IQueryable类型，数据在数据库里面，
            //这个list里面有表达式目录树---返回值类型--IQueryProvider(查询的支持工具，sqlserver语句的生成)
            //其实userList只是一个包装对象，里面有表达式目录树，有结果类型，有解析工具，还有上下文，
            //真需要数据的时候才去解析sql，执行sql，拿到数据的---因为表达式目录树可以拼装；
            IQueryable<User> sources = null;
            using (JDDbContext dbContext = new JDDbContext())
            {
                sources = dbContext.Set<User>().Where(u => u.Id > 20);
                //延迟查询也要注意：a 迭代使用时，用完了关闭连接  b 脱离context作用域则会异常
                foreach (var user in sources)//sources必须在该dbContext的using范围内使用
                {
                    Console.WriteLine(user.Name);
                }
                Console.WriteLine("&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&");

                var userList = dbContext.Set<User>().Where(u => u.Id > 10);//1 这句话执行完，没有数据库查询
                foreach (var user in userList)//2 迭代遍历数据才去数据库查询--在真实需要使用数据时，才去数据库查询的
                {
                    Console.WriteLine(user.Name);
                }
                //IEnumerator
                //这就是延迟查询,可以叠加多次查询条件，一次提交给数据库；可以按需获取数据；
                userList = userList.Where(u => u.Id < 100);
                userList = userList.Where(u => u.State < 3);
                userList = userList.OrderBy(u => u.Name);

                var list = userList.ToList<User>();//ToList() ，Count()， FitstOrDefalut()都会自动去调用数据库
            }
            //这个时候查询，已经超出作用域。会异常，所以必须在using范围内使用
            //foreach (var user in sources)
            //{
            //    Console.WriteLine(user.Name);
            //}

            //intList实现了IEnumerable类型，这里是延迟的，其实数据已经在内存里，利用的是迭代器的方式，每次去迭代访问时，才去筛选一次，委托+迭代器
            {
                List<int> intList = new List<int>() { 123, 4354, 3, 23, 3, 4, 4, 34, 34, 3, 43, 43, 4, 34, 3 };
                var list = intList.Where(i =>
                 {
                     Thread.Sleep(i);
                     return i > 10;
                 });//没有过滤
                foreach (var i in list)//才去过滤
                {
                    Console.WriteLine(i);
                }
                Console.WriteLine("*********************");
            }
            #endregion

1：IEnumerable：利用的是迭代器的方式，每次去迭代访问时，才去筛选一次，委托+迭代器

2：IQueryable：只是一个包装对象，里面有表达式目录树，有结果类型，有解析工具，还有上下文，真需要数据的时候才去解析sql，执行sql，拿到数据的---因为表达式目录树可以拼装；

六：EF状态的跟踪变化

1：ef内置的监控

User userNew = new User()
{
    Account = "Admin",
    State = 0,
    CompanyId = 4,
    CompanyName = "万达集团",
    CreateTime = DateTime.Now,
    CreatorId = 1,
    Email = "loverwangshan@qq.com",
    LastLoginTime = null,
    LastModifierId = 0,
    LastModifyTime = DateTime.Now,
    Mobile = "18664876671",
    Name = "intitName",
    Password = "12356789",
    UserType = 1
};
using (JDDbContext context = new JDDbContext())
{
    Console.WriteLine(context.Entry<User>(userNew).State);//实体跟context没关系 Detached
    userNew.Name = "小鱼";
    context.SaveChanges();//如果状态为Detached的时候，SaveChanges什么也不会做的

    context.Users.Add(userNew);
    Console.WriteLine(context.Entry<User>(userNew).State);//Added

    context.SaveChanges();//插入数据(自增主键在插入成功后，会自动赋值过去)
    Console.WriteLine(context.Entry<User>(userNew).State);//Unchanged（跟踪，但是没变化）

    userNew.Name = "加菲猫";//一旦任何字段修改----内存clone 
    Console.WriteLine(context.Entry<User>(userNew).State);//Modified
    context.SaveChanges();//更新数据库，因为状态是Modified
    Console.WriteLine(context.Entry<User>(userNew).State);//Unchanged（跟踪，但是没变化）

    context.Users.Remove(userNew);
    Console.WriteLine(context.Entry<User>(userNew).State);//Deleted
    context.SaveChanges();//删除数据，因为状态是Deleted
    Console.WriteLine(context.Entry<User>(userNew).State);//Detached已经从内存移除了
}

通过执行上面的代码，我们能看到每一步的操作状态，其实EF本身是依赖监听变化，如果有任何字段发生改变（会拿当前字段的值跟内存进行比较因此晓得是否发生改变），则会把context.Entry<User>(user20).State修改为Modified的，然后SaveChanges是以context为标准的，如果监听到任何数据的变化，会一次性的保存到数据库去，而且会开启事务！

2：因为EF默认会对与context的对象有关系的一些实体进行监控，如果仅仅是做查询而不会做更新，则不需要监控，以提高效率，下面代码是取消监控：

 using (JDDbContext context = new JDDbContext())
 {
     //如果获取对象仅仅为了查询，而不会对其修改，则没有必要进行监听某个对象，
     //可以使用AsNoTracking取消监听，这样可以提高一些效率
     User user21 = context.Users.Where(u => u.Id == 21).AsNoTracking().FirstOrDefault();
     Console.WriteLine(context.Entry<User>(user21).State); //Detached
 }

3：EF追踪对象的三种方式如下：

User user = null;//声明一个新的对象
using (JDDbContext context = new JDDbContext())
{
    User user20 = context.Users.Find(20);
    Console.WriteLine(context.Entry<User>(user20).State);
    user = user20;
}

user.Name = "滑猪小板123456789";
using (JDDbContext context = new JDDbContext())
{
    Console.WriteLine(context.Entry<User>(user).State); //因为user是新的字段，跟context么有关系，所以是Detached

    //第一种：如果user是新的对象，与context没有关系，则先使用Attach建立关系，然后修改字段
    //context.Users.Attach(user);//使user跟context建立关系
    //Console.WriteLine(context.Entry<User>(user).State);//Unchanged
    //user.Name = "滑猪小板";//只能更新这个字段
    //Console.WriteLine(context.Entry<User>(user).State);//Modified

    //第二种：强制指定State的状态为：EntityState.Modified，这个是默认所有的字段都会追踪
    context.Entry<User>(user).State = EntityState.Modified;//全字段更新
    Console.WriteLine(context.Entry<User>(user).State);//Modified

    //第三种：使用context直接查询出来的字段，是默认监听的
    user = context.Users.Find(user.Id);//查出来自然是监听
    user.Name = "ddds";
    Console.WriteLine(context.Entry<User>(user).State);//Modified

    context.SaveChanges();
}

刚刚有个设置整个对象的字段更新，可以通过：context.Entry<User>(user5).Property("Name").IsModified = true来指定某字段被改过 ！

七：EF内置的一些缓存

 using (JDDbContext context = new JDDbContext())
 {
     var userList = context.Users.Where(u => u.Id > 10).ToList();
     //var userList = context.Users.Where(u => u.Id > 10).AsNoTracking().ToList();
     Console.WriteLine(context.Entry<User>(userList[3]).State);
     Console.WriteLine("*********************************************");
     var user5 = context.Users.Find(5);
     Console.WriteLine("*********************************************");
     var user1 = context.Users.Find(30);
     Console.WriteLine("*********************************************");
     var user2 = context.Users.FirstOrDefault(u => u.Id == 30);
     Console.WriteLine("*********************************************");
     var user3 = context.Users.Find(30);
     Console.WriteLine("*********************************************");
     var user4 = context.Users.FirstOrDefault(u => u.Id == 30);
 }

Find可以使用缓存，优先从内存查找(限于同一个context)，但是linq时不能用缓存，每次都是要查询的

 八：DbContext的一些声明周期以及用法

1：DbContext的SaveChanges是开启事务的，任何一个失败直接全部失败，如下：

#region 多个数据操作一次savechange，任何一个失败直接全部失败
using (JDDbContext dbContext = new JDDbContext())
{
    User userNew = new User()
    {
        Account = "Admin",
        State = 0,
        CompanyId = 4,
        CompanyName = "万达集团",
        CreateTime = DateTime.Now,
        CreatorId = 1,
        Email = "dddd@qq.com",
        LastLoginTime = null,
        LastModifierId = 0,
        LastModifyTime = DateTime.Now,
        Mobile = "2222",
        Name = "aaa",
        Password = "12356789",
        UserType = 1
    };
    dbContext.Users.Add(userNew);

    User user17 = dbContext.Users.FirstOrDefault(u => u.Id == 17);
    user17.Name += "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";

    User user18 = dbContext.Set<User>().Find(18);
    user18.Name += "bbb";

    //Company company2019 = dbContext.Set<Company>().Find(2019);
    //dbContext.Companies.Remove(company2019);

    dbContext.SaveChanges();
}
#endregion

2：多context实例 join 不行，因为上下文环境不一样；除非把数据都查到内存，再去linq，如下代码会报错：

using (JDDbContext dbContext1 = new JDDbContext())
using (JDDbContext dbContext2 = new JDDbContext())
{
    var list = from u in dbContext1.Users
               join c in dbContext2.Companies on u.CompanyId equals c.Id
               where new int[] { 1, 2, 3, 4, 6, 7, 10 }.Contains(u.Id)
               select new
               {
                   Account = u.Account,
                   Pwd = u.Password,
                   CompanyName = c.Name
               };
    foreach (var user in list)
    {
        Console.WriteLine("{0} {1}", user.Account, user.Pwd);
    }
}

3：context的一些使用建议：

• DbContext是个上下文环境，里面内置对象跟踪，会开启链接(就等于一个数据库链接)
• 一次请求，最好是一个context；
• 多个请求 /多线程最好是多个实例；
• 用完尽快释放；

 九：多个数据源的事务

在第八条我们晓得不同的DbContext是没办法jioin联合查询的，那现在如果有一个需求，如果我想操作不同的数据源，又想放在一个事务里面统一操作，这个需要怎么做呢，.net帮我们提供了一个TransactionScope，具体实现如下：

 using (JDDbContext dbContext1 = new JDDbContext())
 using (JDDbContext dbContext2 = new JDDbContext())
 {
     using (TransactionScope trans = new TransactionScope())
     {
         User userNew1 = new User()
         {
             Account = "Admin",
             State = 0,
             CompanyId = 2031,
             CompanyName = "wwww",
             CreateTime = DateTime.Now,
             CreatorId = 1,
             Email = "dddd@qq.com",
             LastLoginTime = null,
             LastModifierId = 0,
             LastModifyTime = DateTime.Now,
             Mobile = "adfadf",
             Name = "民工甲123333333",
             Password = "12356789",
             UserType = 1
         };
         dbContext1.Set<User>().Add(userNew1);
         dbContext1.SaveChanges();

         SysLog sysLog = new SysLog()
         {
             CreateTime = DateTime.Now,
             CreatorId = userNew1.Id,
             LastModifierId = 0,
             LastModifyTime = DateTime.Now,
             Detail = "12345678",
             Introduction = "sadsfghj",
             LogType = 1,
             UserName = "zhangsanan2zhangsanan2zhangsanan2zhangsanan2333333333"
         };
         dbContext2.Set<SysLog>().Add(sysLog);
         dbContext2.SaveChanges();

         trans.Complete();//能执行这个，就表示成功了；
     }
 }

这样就能实现不同的数据源使用同一个事务了。

十：EF的导航属性

如果EF中有表对应的关系，一对多一对一，则如果想要查询出来一个表的同时把另外一个表也对应的查询出来，则可以使用导航属性，比如我们一个用户表属于某个公司，再查询用户表的时候想要把公司的信息给带出来，则可以进行如下操作：

[Table("User")]
    public partial class User
    {
        public int Id { get; set; }

        public int CompanyId { get; set; }

        [StringLength(500)]
        public string CompanyName { get; set; }

        public int State { get; set; }

        public int UserType { get; set; }

        public DateTime? LastModifyTime { get; set; }

        [ForeignKey("CompanyId")]
        public virtual Company Company { get; set; }
    }

注意：一般导航属性，实体与主键对应最好使用ForeignKey来标识一下，不要使用.netFramwork对应的框架那种默认方式去做，比较不明确。

然后查询如下：

 using (JDDbContext dbContext = new JDDbContext())
 {
     var userList = dbContext.Set<User>().Where(c => c.Id < 20);
     foreach (var user in userList)//只差company
     {
         Console.WriteLine($"用户Id：{user.Id}");
         Console.WriteLine($"公司名字：{user.Company?.Name}"); //每次会重新去加载用户信息
     }
 }

导航加载是懒加载，就是只有用到才会去读取。比如每次使用到user.Company都会重新去查询数据。所以这样会增加了对数据库的频繁打开跟关闭。如果要禁止懒加载，可以通过下面的Include来强制加载：

如果想要禁止懒加载，即每次查询的时候，也不想去查询数据，可以通过下面的方式来配置：