学习EntityFramework，实现分层架构

ORM：对象关系映射，为了解决面向对象与关系数据库存在的互补匹配的现象的技术.

O:表示内存中的对象

R:表示关系型数据库

M:表示映射逻辑关系

ORM的优劣势

优势

1.缩短编码时间，减少对Model的编码

2.支持多种数据库，提高程序扩展性

3.动态数据映射，数据表结构发生改变时，减少相关代码修改

劣势

1.性能，处理大量数据会消耗大量内存，严重影响性能

EF体系结构

主要包括EDM MetaData(核心)、Entity Client、Object Services、ADO .NET Provider

EDM:实体数据模型，它能将关系数据库模型映射为实体数据模型

CSDL:概念模型，对应实体类

SSDL:负责与数据库管理系统中的数据表做实体对应，表、列、关系等数据库存在的概念

MSL:负责将上层的概念层结构与下层的存储体结构中的成员相结合。

Entity Client:类似ADO.NET中的数据库操作类，主要用于操作EDM.

Object Service:EF提供的一系列操作业务对象的API,这些API需要依赖于Entity Client实现对数据库的访问

ADO.NET Provider:EF架构中，负责对具体数据库访问的只有Data Provider，Microsoft默认实现了对SQL server的ADO.NET Provider。

创建EF

添加实体数据模型（ADO.NET实体数据模型），选择相对于的数据表（分别为数据库优先，代码优先(推荐)，模型优先）

认识EDMX文件

SSDL(存储层)、CSDL(概念层)、C-S mapping(对应层)

实体文件

导航属性并且使用virtual修饰，表示可以"懒加载"，表示对象和对象之间的关系

​​public class Sys_Attendance:Base
    {
        public int Sys_PersonId { get; set; }
        /// <summary>
        /// 打卡情况
        /// </summary>
        public string State { get; set; }
        public virtual Sys_Person Sys_Person { get; set; }  //virtual懒加载  导航属性
    }

数据上下文

维护受业务影响的对象列表，负责管理对象的增、删、改、查操作，以及相应的事务及并发问题。

​​​​ public class OADbConText:DbContext
    {
        public OADbConText() : base("AoXiang")   //链接字符串
        {
            Configuration.ProxyCreationEnabled = false;//可以进行EF循环引用
        }
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);
            modelBuilder.Configurations.AddFromAssembly(Assembly.GetExecutingAssembly()); //导入当前文件夹中全部的对表的配置
            modelBuilder.Conventions.Remove<OneToManyCascadeDeleteConvention>(); //取消级联
            modelBuilder.Conventions.Remove<ManyToManyCascadeDeleteConvention>();
        }
}

导航属性

表示实体和另一个实体之间的关系

延迟加载

又称为"懒加载"，只有每次调用子实体的时候，才去查询数据库，主表在加载的时候，不去查询外键所在的从表

实现延迟加载需要满足二个条件

1.类是public且不能为Sealed

2.导航属性需要标记virtual

关闭延迟加载:db.Configuration.LazyLoadingEnabled=false     关闭延迟加载后，查询主表数据时候，主表中的从表实体为null

贪婪加载

又名立即加载和预加载

查询主表的时候通过Include()方法一次性将数据查询出来，在调用从表数据的时候，从换成中读取，无须查询数据库

使用Code First(代码优先)

      POCO：Plain old C# Object 表示 一堆普通的类和属性.

步骤

1.引用:EntityForamework  方式一:通过NuGet   方式二:通过Install-package EntityForamework(默认下载最新稳定版)

2.创建DbContext上下文（实现增删改查）

//先创建POCO 一堆干净的普通类，没有约束特性​​
public class Grade:Base
    {
        public int GradeId { get; set; }
        public string GradeName{ get; set; }
        //public virtual Sys_Person Sys_Person { get; set; }  //virtual懒加载  导航属性
    }
 
 
 
 
 
​​​​ public class OADbConText:DbContext
    {
        public OADbConText() : base("AoXiang")   //链接字符串
        {
            Configuration.ProxyCreationEnabled = false;//可以进行EF循环引用
        }
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);
            modelBuilder.Configurations.AddFromAssembly(Assembly.GetExecutingAssembly()); //导入当前文件夹中全部的对表的配置
            modelBuilder.Conventions.Remove<OneToManyCascadeDeleteConvention>(); //取消级联
            modelBuilder.Conventions.Remove<ManyToManyCascadeDeleteConvention>();
        }
        public virtual DbSet<Grade> Grade { get; set; }  //virtual懒加载
}
 
 
 static void Main(string[] args)
        {
            using (OADbConText entities = new OADbConText())
            {
                //实现添加
                Grade GradeInfo = new Grade()
                {
                    GradeName = "s8"
                };
                entities.Grade.Add(GradeInfo);
                if (entities.SaveChanges() > 0)
                    Console.WriteLine("数据添加成功！");
            }
            //删除操作
            using (OADbConText entitys = new OADbConText())
            {    //实现思路先通过Id获取对象，然后进行删除
                Grade GradeInfo = entitys.Grade.FirstOrDefault(s => s.GradeId == 7);
                if (GradeInfo != null)
                    entitys.Grade.Remove(GradeInfo);
                //SaveChanges获取受影响行数
                if (entitys.SaveChanges() > 0)
                    Console.WriteLine("删除成功！");
            }
            //实现修改
            using (OADbConText entitys = new OADbConText())
            {
                Grade GradeInfo = entitys.Grade.FirstOrDefault(s => s.GradeId == 8);
                if (GradeInfo != null)
                    GradeInfo.GradeName = "s10";
                if (entitys.SaveChanges() > 0)
                    Console.WriteLine("修改成功！");
            }
            //实现查询(查询单个使用FirstOrDefault)
            using (OADbConText entity = new OADbConText())
            {
                //实现查询
                IQueryable<Grade> GradeInfo = entity.Grade.Where(s => s.GradeName == "s8");
                foreach (var item in GradeInfo)
                {
                    Console.WriteLine(item.GradeId);
                }
            }
            
}

Code First映射规则

1.表中列和类中字段名称一样

2.主键名称为Id，数据类型为Int或者GUID类型会把设置为标识列

3.字符串映射到数据库时数据类型为nvarchar(Max)，并且允许为空

4.bool类型映射为bit类型，不允许为空

5.外键约定

会找到类名Id或者字段Id设置为外键，但是需要注意如果没有找到，EF会自己生成一个外键

一对多：在多方设置外键和导航属性

修改映射规则

数据注解(耦合度太高，不适合大项目开发)

Fluent API(推荐)  链式操作

每次当数据表结构发生改变的时候，会出现一系列问题二种解决方式 

EF的Database.Setlnitializer参数(了解即可，不推荐使用)             使用方式:在数据上下文 构造函数中使用

数据库不存在时重新创建数据库

Database.Selnitializer<DbContest名称>(new CreateDatabaselfNotExists<DbContest名称>())

每次启动时创建数据库

Database.Selnitializer<DbContest名称>(new DropCreateDatabaseAlways<DbContest名称>())

模型更改时重新创建数据库

Database.Setlnitializer<DbContest名称>(new Create DatabaselfModelchanges<DbContest名称>())

从不创建数据库

Database.Setlnitializer<DbContest名称>(null)

第二种,数据迁移(注意EF的版本，推荐使用)            使用方式:在程序包管理台控制器使用，只要要修改默认项目，直接输入代码就行

启动:Enable-Migrations

创建:Add-Migration 名称

执行:Update-Database [参数]  可升级，可回滚，填写参数即可

删除:remove-migration   最近的一个迁移

生成迁移脚本:Script-migration  可以生成中间 D F之间版本

优化EF

using Stu.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Linq.Expressions;
using System.Data.Entity;
 
namespace Stu.DAL
{
    public class BaseService<T> where T:Base,new()
    {
        private MyDbConText db = new MyDbConText();
        public int Add(T t)   //添加
        {
            db.Set<T>().Add(t);
            return db.SaveChanges();
        }
        public async Task<int> AddAsync(T t)   //异步添加
        {
            db.Set<T>().Add(t);
            return await db.SaveChangesAsync();
        }
        public int Delete(int Id)  //删除
        {
            var Item = new T() { Id = Id };
            db.Entry(Item).State = System.Data.Entity.EntityState.Deleted;
            return db.SaveChanges();
        }
        public async Task<int> DeleteAsync(int Id)  //异步删除
        {
            var Item = new T() { Id = Id };
            db.Entry(Item).State = System.Data.Entity.EntityState.Deleted;
            return await db.SaveChangesAsync();
        }
        public int Edit(T t)   //修改
        {
            db.Entry(t).State = System.Data.Entity.EntityState.Modified;
            return db.SaveChanges();
        }
        public async Task<int> EditAsync(T t)  //异步修改
        {
            db.Entry(t).State = System.Data.Entity.EntityState.Modified;
            return await db.SaveChangesAsync();
        }
        public IQueryable<T> GetList()   //返回全部数据
        {
            return db.Set<T>();
        }
        public T GetAllById(int Id)   //通过Id返回单个对象
        {
            return GetList().FirstOrDefault(e => e.Id==Id);
        }
        public async Task<T> GetAllByIdAsync(int Id)    //异步
        {
            return await GetList().FirstOrDefaultAsync(e => e.Id == Id);
        }
        public int Edit(T obj, params string[] updateFields)   //修改部分列
        {
            db.Set<T>().Attach(obj);
            foreach (var attr in typeof(T).GetProperties())
            {
                if (updateFields.Contains(attr.Name))
                {
                    db.Entry(obj).Property(attr.Name).IsModified = true;  // 设置属性被修改
                }
            }
            return db.SaveChanges();
        }
        public IQueryable<T> GetList(Expression<Func<T,bool>> Where)  //返回全部带条件
        {
            return db.Set<T>().Where(Where);
        }
        public IQueryable<T> OrderBy<K>(Expression<Func<T,bool>> where,int PageIndex,int PageSize,out int Count,Expression<Func<T,K>> Orders,bool IsOrder)    //实现分页
        {
            var Item = db.Set<T>().Where(a=>1==1);
            Item = where != null ? Item.Where(where):Item;
            Count = Item.Count();
            return (IsOrder ? Item.OrderBy(Orders) : Item.OrderByDescending(Orders)).Skip(PageSize * (PageIndex - 1)).Take(PageSize);
        }
    }
}