C# EntityFramwork(Model First)使用要点

本文介绍EntityFramework使用方法

1. Entity Framework的注意点

   由于安装和操作的细节讲起来很琐碎，这部分只罗列出难点，其他细节请自行查阅
   安装细节
       Pluralize or singularize generated object names（确定所生成对象名称的单复数形式）复选框
           此复选框的意思是，将数据库中的复数表名映射成单数形式的实体类，如果有一对多，多对多关系的表会将属性名以复数形式显示，增加程序可读性
       Include foreign key columns in the model （在模型中包含外键）复选框
           将数据库外键关系映射到实体模型中
       Import selected stored procedures and functions into entity model （将所选存储过程和函数导入到实体模型中） 
           将存储过程和函数导入到实体模型
   操作CRUD
       要先实例化上下文类
       using(var ctx = new SchoolDBEntities()) 
       {
           // 进行增删改查
       }
   

2. 支持的查询方法

   支持的查询数据的方式有
       LINQ to Entites
           linq方法
               var linq = ctx.Students.Where(s => s.StudentID > 2);
           linq查询语句
               var linq = from item in ctx.Students select item; 
       Entity SQL
           此法不建议使用
       Native SQL
           var tempResult = ctx.Students.SqlQuery("select * from Student");
           注意：sql语句返回的列不能改名，否则报错
           返回值类型的写法
               string result = db.Database.SqlQuery<string>("select studentname from Student where studentid = 1").FirstOrDefault<string>();
           执行非查询sql的写法
               int noOfRowUpdated = ctx.Database.ExecuteSqlCommand("Update student set studentname ='changed student by command' where studentid=1");
   

3. ef表示体包含的方法

   ctx.Students表实体中除了上面讲到的SqlQuery方法外还包括如下方法
       Add方法
           db.Students.Add(student); // 添加一条记录到实体框架中
       AsNoTracking方法
           如果查询的数据只是用来展示的，可以使用AsNoTracking方法将查询的数据和DbContext断开连接，提高查询效率
           var result = db.Students.Select(s => new
           {
               s.StandardId,
               s.StudentName
           }).AsNoTracking().ToList();
       Attach方法
           将一条Student数据附加到EF的跟踪图中就像数据是从数据库中读取的一样，其实数据库中并不存在
           var result = db.Students.Attach(st);
       Create方法
           创建一个空的Student实例，该实例没有附加到Students集合中
           var result = db.Students.Create();
       Find方法
           返回Students表中主键id是5的数据，与之关联的数据也会一起返回
           如果数据已经添加到上下文中，但是没有保存到数据库，使用Find同样有效
           var result = db.Students.Find(5);
       Include方法
           指定包含在结果集中的导航属性
               var result = db.Students.Include("StudentAddress").ToList<Student>();
               也可以传递lambda表达式
               var result = db.Students.Include(s => s.Standard).ToList<Student>();
       Remove方法
           将提供的Student实例标记为已删除，改实例必须存在于上下文中
           var result = db.Students.Remove(st);
       SqlQuery带参数的用法    
           var result = db.Students.SqlQuery("select * from student where studentid = @p", new SqlParameter("@p", SqlDbType.Int) { Value = 5} ).Select(s => s.StudentName).ToList();
   

4. DBEntityEntry对象

   ef实体框架中，可以通过数据实体获取数据实体相关的DBEntityEntry对象，从而得到数据实体的所有信息
   var student = db.Students.Find(1);
   student.StudentName = "yejiawei";
   var entry = db.Entry(student); // 获取数据实体的DBEntityEntry对象
   属性
       var result = entry.Entity.GetType().FullName; // 获取实体的名称
       var result = entry.State.ToString(); // 获取实体当前的状态
       IEnumerable<string> result = entry.CurrentValues.PropertyNames; // 获取实体的所有属性名
       var result = entry.OriginalValues["StudentName"]; // 获取实体属性修改之前的值
       var result = entry.CurrentValues["StudentName"]; // 获取实体属性修改之后的值
       可以手动设置实体的状态为 Added,Modified,Deleted
           entry.State = EntityState.Modified;
   方法
       Collection
           返回导航属性的集合，多对多关系
           var result = entry.Collection("Courses");
           可以继续使用 result.Load() 预载数据
           还可以继续使用 result.Query().Where(...) 进一步筛选数据
       ComplexProperty
           返回复杂属性的集合
       GetDatabaseValues
           返回跟踪的属性集合
           var result = entry.GetDatabaseValues();
       Property
           返回实体指定属性的所有信息组成的集合
           var result = entry.Property("StudentName");
       Reference
           返回导航属性的集合，一对多或者多对一关系
           var result = entry.Reference("StudentAddress");
           可以继续使用 result.Load() 预载数据
           还可以继续使用 result.Query().Where(...) 进一步筛选数据
       Reload方法
           entry.Reload();
           调用此方法，之前的所有更改都无效，全部和数据库同步，并且当前状态是Unchanged
   

5. 追踪变化

   在ef上下文的生命周期中，ef会自动追踪加载进来的实体，可以通过ChangeTracker来获取所有被上下文追踪的实体
   每一个实体都必须包含一个主键，如果没有主键ef是不会追踪的
   var student = db.Students.Find(1);
   属性
       var result = db.ChangeTracker.Entries(); // 获取所有被上下文追踪的实体
       var result = db.ChangeTracker.Entries().Count(); // 获取所有被上下文追踪的实体的个数
       var result = db.ChangeTracker.Entries(); // 获取当前上下文中的所有DBEntityEntry对象对象
   

6. 维持Entity Framework的实体场景

   连接场景
       数据检索和增删改都在一个上下文里面操作
       在连接场景中完成增删改查是非常容易的，因为上下文自动跟踪实体的状态，AutoDetectChangesEnabled默认是true
       添加操作
           定义一个引用类型比较类
               public class StudentComparer : IEqualityComparer<Student>
               {
                   public bool Equals(Student x, Student y)
                   {
                       if (x.StudentName.ToLower() == y.StudentName.ToLower())
                       {
                           return true;
                       }
                       return false;
                   }
                   public int GetHashCode(Student obj)
                   {
                       return obj.GetHashCode();
                   }
               }
           新增操作
               if(!db.Students.ToList().Contains(new Student() { StudentName = "yejiawei" }, new StudentComparer()))
               {
                   db.Students.Add(new Student() { StudentName = "yejiawei" });
                   db.SaveChanges();
                   return Ok("添加成功");
               }
               return Ok("已经存在了");
       修改操作
           Student StudetUpdate = db.Students.ToList().Where(s => s.StudentName == "yejiawei").FirstOrDefault();
           StudetUpdate.StudentName = "叶家伟";
           db.SaveChanges();
       删除操作
           db.Students.Remove(db.Students.ToList().ElementAt(0));
           db.SaveChanges();
   断开连接场景
       数据检索和增删改在不同的上下文里面操作
       在断开连接场景中，我们需要附加实体到新的上下文中，并且要指定状态
       Add方法，会自动的将实体块附加到新的上下文中并且自动的修改状态为Added，也就是说你调用Add方法，管他啥玩意儿都可以成功
       Attach方法，调用Attach方法会将实体块添加到上下文中，但是状态还是Unchanged，需要手动设置
           var test = db.Students.Attach(new Student() { StudentName = "yejiawei" });
           db.Entry(test).State = EntityState.Added;
           var result = db.Entry(test).State.ToString();
           db.SaveChanges();
       单个的实体
           单个的实体，直接更改状态，然后保存即可
           var test = new Student() { StudentName = "叶家伟" };
           db.Entry(test).State = EntityState.Added;
           var result = db.Entry(test).State.ToString();
           db.SaveChanges();
   

7. Entity Framework并发问题

   在ef中可以根据数据库timestamp类型的列来处理并发问题，timestamp数据会在插入和更新时自动更改并且是唯一的
   数据库中timestamp类型的值是自动添加的
   然后，需要在ef中将timestamp列属性中的Concurency Mode设置为Fixed
   此时，ef在执行更新操作会将timestamp列设置成where的字句，来判断操作的数据有没有并发操作，如果发生了并发操作，那么会抛出DbUpdateConcurrencyException错误
       Student test1 = null;
       using(var context1 = new SchoolDBEntities())
       {
           context1.Configuration.ProxyCreationEnabled = false; // 查询的时候是否包含导航属性
           test1 = context1.Students.Where(s => s.StudentID == 9).Single();
           test1.StudentName = "小王";
           try
           {
               context1.Entry(test1).State = EntityState.Modified;
               context1.SaveChanges();
           }
           catch (DbUpdateConcurrencyException ex)
           {
               var t = ex;
           }
       }
   

8. 执行存储过程

   如下的存储过程导入到ef中
       ALTER PROCEDURE [dbo].[GetCoursesByStudentId]
           -- Add the parameters for the stored procedure here
           @StudentId int = null
       AS
       BEGIN
           -- SET NOCOUNT ON added to prevent extra result sets from
           -- interfering with SELECT statements.
           SET NOCOUNT ON;
           -- Insert statements for procedure here
       select c.courseid, c.coursename,c.Location, c.TeacherId
       from student s left outer join studentcourse sc on sc.studentid = s.studentid left outer join course c on c.courseid = sc.courseid
       where s.studentid = @StudentId
       END
   然后直接当做函数执行就可以了
       var courses = db.GetCoursesByStudentId(1);
   可以将更新，删除，新增的存储过程映射到实体上面，从而重写ef默认的增删改的方法
       存储过程中，新增的时候执行SELECT SCOPE_IDENTITY() AS StudentId，可以返回新增数据的id
   

9. 在ef中使用枚举

   数据库中可以使用一些特殊的整数值，来表示数据的特殊含义，为了是代码的可读性更强，使用枚举来代替这些整数值
   首先，将实体中的一个属性列，Convert to Enum
   然后，在弹出的选择框中，输入枚举类型的名字，也就是你在写代码时要用到的枚举名称
   其次，在成员列表中，指定成员的名字，和成员对应的整数值
   现在，你可以使用你定义的枚举了
       var type = TeacherType.Guest;
   

10. 在ef中使用表值函数

    首先要在数据库中添加一个表值函数
        ALTER FUNCTION [dbo].[GetCourseListByStudentID] 
        (	
            -- Add the parameters for the function here
            @studentID int
        )
        RETURNS TABLE 
        AS
        RETURN 
        (
            -- Add the SELECT statement with parameter references here
            select c.courseid, c.coursename,c.Location, c.TeacherId
            from student s left outer join studentcourse sc on sc.studentid = s.studentid left outer join course c on c.courseid = sc.courseid
            where s.studentid = @studentID
        )
    然后将这个表值函数导入到ef中，可以在模型浏览器中修改函数，然后在ef中使用表值函数，如下
        var result = db.GetCoursesByStudentId(1).Select(s => s);
    

11. Local属性

    可以通过Local属性访问当前被追踪的实体，被标记为Deleted的实体不可以通过Local访问
    db.Students.Load(); // 预载，免去写ToList
    db.Students.Add(new Student() { StudentName = "New Student" });
    return Ok(db.Students.Local);
    

12. 预先加载

    使用Include，表示加载导航属性
        (from s in context.Students.Include("Standard")
        where s.StudentName == "Student1"
        select s).FirstOrDefault<Student>();
    

13. 懒加载

    当实体中包含包含复杂属性，只有当访问这个复杂属性的时候才会去查询
    如果要为整个上下文关闭懒加载，可以在上下文的类中设置
        public SchoolDBEntities(): base("name=SchoolDBEntities")
        {
            this.Configuration.LazyLoadingEnabled = false;
        }
    如果想只关闭某一个属性的懒加载，可以导实体的类中设置
        public virtual StudentAddress StudentAddress { get; set; }将这个virtual关键字去掉即可
    

14. 异步查询和保存

    异步查询
        使用async标记此方法是异步的
        public async Task<Student> GetStudents()
        {
            Student result = null;
            using (var context = new SchoolDBEntities())
            {
                context.Configuration.ProxyCreationEnabled = false;
                // 使用await，可以释放当前线程从而可以执行其他代码，避免阻塞程序
                result = await context.Students.Where(s => s.StudentID == 10).FirstOrDefaultAsync<Student>();
            }
            return result;
        }
    异步保存
        public async Task<int> Get()
        {
            using (var context = new SchoolDBEntities())
            {
                var test = context.Courses.Attach(new Course() { CourseName = "数学" });
                context.Entry(test).State = EntityState.Added;
                return await context.SaveChangesAsync();
            }
        }
    

15. 日志的记录

    第一种方式，使用默认配置
        在web.config配置文件中的entityFramework节点下添加
        <interceptors>
            <interceptor type="System.Data.Entity.Infrastructure.Interception.DatabaseLogger, EntityFramework">
                <parameters>
                <parameter value="F:学习实验区EntityFrameworkLog.txt"/>
                <parameter value="true" type="System.Boolean"/>
                </parameters>
            </interceptor>
        </interceptors>
        即可自动的记录ef做的所有操作
    第二种方式，自定义日志记录
        using (var context = new SchoolDBEntities())
        {
            // 使用Log方法即可自动实现记录日志，然后追加到日志文件中
            context.Database.Log = (string message) =>
            {
                byte[] bts = Encoding.UTF8.GetBytes(message);
                using (FileStream fwrite = File.OpenWrite(@"F:学习实验区EntityFrameworkLog1.txt"))
                {
                    //fwrite.Write(bts, 0, bts.Length);
                    fwrite.Position = fwrite.Length;
                    fwrite.Write(bts, 0, bts.Length);
                }
            };
            var test = context.Courses.Attach(new Course() { CourseName = "数学" });
            context.Entry(test).State = EntityState.Added;
            return await context.SaveChangesAsync();
        }
    

16. 事务提交和回滚

    ef默认的操作都是事务处理的，但是我们可以将ef多个操作再用一个事务封装起来，方便回滚
        using(DbContextTransaction dbTran = context.Database.BeginTransaction())
        {
            try
            {
                var test = context.Courses.Attach(new Course() { CourseName = "333" });
                context.Entry(test).State = EntityState.Added;
                await context.SaveChangesAsync();
                dbTran.Commit();
                return 1;
            }catch(Exception ex)
            {
                dbTran.Rollback();
                return 0;
            }
        }
    

17. AddRange和RemoveRange

    AddRange批量增加
        List<Course> list = new List<Course>()
        {
            new Course() { CourseName = "yuwen" },
            new Course() { CourseName = "shuxue" },
            new Course() { CourseName = "yinyu" }
        };
        using (var context = new SchoolDBEntities())
        {
            context.Courses.AddRange(list);
            return await context.SaveChangesAsync();
        }
    RemoveRange批量删除
        using (var context = new SchoolDBEntities())
        {
            var items = context.Courses.Where(
                s => s.CourseName == "yuwen" || s.CourseName == "shuxue" || s.CourseName == "yinyu"
            ).AsEnumerable<Course>();
            context.Courses.RemoveRange(items);;
            return await context.SaveChangesAsync();
        }