FluentAPI深入

1.  HasMaxLenght 设定字段得最大长度：

        static void Main(string[] args)
        {
            using (TestDbContext ctx = new TestDbContext())
            {

                Person p = new Person
                {
                    Name = "chenwwwwwwwwwwwwwwwwwwwwww",
                    Age=,
                    CreateDateTime=DateTime.Now
                };
                ctx.Persons.Add(p);
                try
                {
                    ctx.SaveChanges();
                }
                catch (DbEntityValidationException ex)
                {
                    foreach (var e in ex.EntityValidationErrors)
                    {
                        foreach (var error in e.ValidationErrors)
                        {
                            Console.WriteLine(error.ErrorMessage);
                        }
                    }  

                }

                Console.ReadKey();
            }
        }

依赖于数据库得“字段长度、是否为空”等约束是在数据提交到数据库服务器得时候才会检查‘EF得配置，则是由EF来检查得，如果检查出错根本不会被提交给服务器。

2.  （有用）字段是否为空：

        public PersonConfig()
        {
            this.ToTable("T_Persons");
            this.Property(p=>p.Name).HasMaxLength();
            this.Property(p => p.Name).IsRequired();//属性不能为空
            this.Property(p => p.Name).IsOptional();//属性可以为空
        }  

默认规则是“主键属性不允许为空，引用类型允许为空”

        public PersonConfig()
        {
            this.ToTable("T_Persons");
            this.HasKey(p => p.Id); //主键
            this.Property(p => p.Name).IsFixedLength(); //是否对应固定得长度
            this.Property(p => p.Name).IsUnicode(false);//对应得数据库类型是varchar类型，而不是nvarchar
            this.Property(p => p.Name).HasColumnName("Names"); //Name对应数据库中得字段名是Names
            this.Ignore(p => p.Name);//某个字段不参与映射数据库
        }   

3、一对多

和关系映射相关得方法：

（1） 基本套路  this.Has****(p=>p.A).With****()  当前这个表和A属性表的关系是Has定义，  With定义的是A对应的表和这个表的关系。

（2）  HasOptional()   有一个是可选的（可以为空的）；   HasRequlred() 有一个是必须的（不能为空的）；    HasMany() 有很多的；

（3）WithOptional() 可选的；     WithRequired() 必须的   ；  WithMany() 很多的；

实例一：

  public  class Student
    {
        public long Id { get; set; }
        public string Name { get; set; }
        public int Age { get; set; }
        public long ClassId { get; set; }
        public virtual  Class Class { get; set; }
    }
   public class Class
    {
        public long Id { get; set; }

        public string Name { get; set; }
        public int Count { get; set; }

    }

  public class ClassConfig:EntityTypeConfiguration<Class>
    {
        public ClassConfig()
        {
            ToTable("T_Classes");
        }
    }
   public  class StudentConfig:EntityTypeConfiguration<Student>
    {
        public StudentConfig()
        {
            ToTable("T_Students");
        }
    }

                Class c1 = new Class()
                {
                    Name = "三年一班",
                };

                Student s1 = new Student()
                {
                    Name = "chen",
                    Age = ,
                    Class = c1
                };

                ctx.Students.Add(s1);
                ctx.SaveChanges();

实例二：

                var  s = ctx.Classes.First();

                //双向设计，容易搞混
                /*
                foreach (var item in s.Students)
                {
                    Console.WriteLine(item.Name);
                }
                */
                //数据库化思维，推荐用这种用法
                foreach (var item in ctx.Students.Where(p => p.ClassId == s.Id))
                {
                    Console.WriteLine(item.Name);
                }

    public class Class
    {
        public long Id { get; set; }

        public string Name { get; set; }
        public int Count { get; set; }
        public virtual ICollection<Student> Students { get; set; } = new List<Student>(); //这里就可以获得所有指向了当前对象的Student集合，不推荐这种双向设计关系

    }

4、 多对多

   public  class Teacher
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public virtual ICollection<Student> Students { get; set; } = new List<Student>();

    }

  public  class Student
    {
        public long Id { get; set; }
        public string Name { get; set; }
        public int Age { get; set; }
        public long? Class_Id { get; set; }

        public virtual  Class Class { get; set; }
        public virtual ICollection<Teacher>  Teachers { get; set; } = new List<Teacher> ();

    }

   public  class StudentConfig:EntityTypeConfiguration<Student>
    {
        public StudentConfig()
        {
            ToTable("T_Students");
            this.HasRequired(s => s.Class).WithMany().HasForeignKey(e => e.Class_Id);
        }
    }

  public  class TeacherConfig:EntityTypeConfiguration<Teacher>
    {
        public TeacherConfig()
        {
            ToTable("T_Teachers");
            this.HasMany(e => e.Students).WithMany(e=>e.Teachers).Map(e => e.ToTable("T_TeacherStudentRelations").MapLeftKey("teacherId").MapRightKey("studentId"));
        }
    }

        static void Main(string[] args)
        {
            using (TestDbContext ctx = new TestDbContext())
            {

                Teacher t1 = new Teacher()
                {
                    Name = "语文老师"
                };
                Teacher t2 = new Teacher()
                {
                    Name = "数学老师"
                };

                Student s1 = new Student()
                {
                    Name = "小李",
                    Age =
                };
                Student s2 = new Student()
                {
                    Name = "小王",
                    Age =
                };
                Student s3 = new Student()
                {
                    Name = "小章",
                    Age =
                };
                t1.Students.Add(s1);
                t1.Students.Add(s2);
                t2.Students.Add(s2);
                t2.Students.Add(s3);

                ctx.Teachers.Add(t1);
                ctx.Teachers.Add(t2);

                ctx.SaveChanges();

                Console.ReadKey();

            }
        }

总结：  （1）一对多中不建议配置一端的集合属性，因此配置的时候不用给WithMany()参数，如果配置了集合属性，则必须给WithMany参数；多对多关系必须要给WithMany参数

（2） 多对多移除关系：

        static void Main(string[] args)
        {
            using (TestDbContext ctx = new TestDbContext())
            {
               var t=ctx.Teachers.Single(p=>p.Name=="数学老师");
               var s = ctx.Students.Single(p => p.Name == "小章");
                t.Students.Remove(s);

                ctx.SaveChanges();

                Console.ReadKey();

            }
        }

（3）如果数据库创建好了再修改模型或者配置，运行就会报错，那么就要手动删除数据库或者

 Database.SetInitializer(new DropCreateDatabaseIfModelChanges<TestDbContext>());

（4）做项目时建议初期先把主要的类使用EF自动生成表，然后干掉Migration表，然后

Database.SetInitializer<TestDbContext>(null);   //禁止DbMigration使用，手动修改实体类和数据库

5、延迟加载：

延迟加载（lazy load） ，只有用到关联的对象的数据，才会再去指向select查询，注意延迟加载只在关联对象属性上，普通属性没有这个东西；

注意启用延迟加载需要配置如下的两个属性（默认是true，因此不需要配置，只要别手动设置为false即可）

context.Configuration..ProxyCreationEnable=true;     context.Configuration..LazyLoadingEnable=true;

分析延迟加载的原理：打印一下拿到的对象的GetType()，再打印一下GetType().BaseType;我们发现拿到的对象其实是Student子类的对象（如果结果不一致，说明类不是Public，没有关联的virtua属性l）

延迟加载的优点： 用到的时候才加载，没用到的时候不加载，避免了一次性加载所有的数据，提高了加载速度。缺点： 如果不用延迟加载，就可以一次数据库查询所有数据（join实现），用了延迟加载就要多次的执行数据库操作，提高了数据库服务器的压力

因此：如果关联的属性几乎都要读到，那么就不要用延迟加载；如果关联的属性只有较小的概率则可以启动延迟记载；

6、不延迟加载，怎样一次加载？

又想方便（必须是virtual）又想效率高！用EF永远都要把导航属性设置为virtual。

使用Include()方法：

（1）var s= ctx.Students.Include("Class").First();   //Include("Class")的意思是直接加载student的Class属性的数据。注意只有关联的对象属性才可以用Include，普通字段不可以；

（2） C#6.0 语法糖，可以使用nameof语法解决这个问题：

ctx.Students.Include(nameof(Student.Class)).First();

（3）      //using System.Data.Entity;   推荐这种做法

ctx.Students.Include(e=>e.Class).First();

如果有多个属性需要一次性加载，也可以写多个Include：

（4）

            using (TestDbContext ctx = new TestDbContext())
            {
                foreach (var s in ctx.Students)
                {
                    Console.WriteLine(s.Name);
                    Console.WriteLine(s.Class.Name);
                }
            }   //报错，多个DataReader一起执行了

三种解决方法：

在字符串上加上：MultipleActiveResultSets=true; 但是不支持其他数据库

执行一下Tolist()  ，因为Tolist() 就遍历然后生成list：

            using (TestDbContext ctx = new TestDbContext())
            {
                foreach (var s in ctx.Students.ToList())
                {
                    Console.WriteLine(s.Name);
                    Console.WriteLine(s.Class.Name);
                }
            }

推荐做法：Include预先加载：

            using (TestDbContext ctx = new TestDbContext())
            {
                foreach (var s in ctx.Students.Include(e=>e.Class))
                {
                    Console.WriteLine(s.Name);
                    Console.WriteLine(s.Class.Name);
                }
            }