Entity Framework Core
文章目录
- Entity Framework Core
- EF历史—Need
- EF Core
- 使用依赖注入
- Model
- Convention(约定)，Annotation(注释)和Fluent API
- Convention
- 使用约定的Table per Hierarchy(TPH)
- Annotation
- Fluent API
- 配置自包含类型(Self-Contained Type Configuration)
- Scaffolding a Model from the Database——Need
- 字段映射(Mapping to Fields)
- 阴影属性（shadow Property）
- 从属实体(owned entity)
- 表拆分(Table Splitting)——EF Core2.0
- 使用Fluent API的Table per Hierarchy
- Context
- Convention(约定)，Annotation(注释)
- Fluent API
- 依赖注入
- 添加日志
- Context pooling（上下文池）——EF Core 2.0
- 事务
- 隐式事务
- 显式事务
- 冲突处理
- 保留最后一个
- 保留第一个
- 数据库创建与删除
- 创建
- 删除
- 查询
- 基本查询
- 原始Sql查询
- 编译查询——需要重复执行的查询
- EF.Functions
- 显式加载
- 立即加载
- 全局查询过滤器
- 客户端和服务端评估
- 保存
- 保存
- 对象追踪
- 更新对象
- 更新未跟踪的对象
- 批处理
- 迁移-Need
- 创建Migrations（迁移）
- 以编程方式应用迁移
- Deleting Records
- Logging
Entity Framework Core
EF历史—Need
EF Core
创建WroxBooks——Books表
CREATE TABLE [dbo].[Books]
(
[BookId] INT IDENTITY(1, 1) NOT NULL,
[Title] NVARCHAR(50) NOT NULL,
[Publisher] NVARCHAR(25) NULL,
CONSTRAINT [PK_Books] PRIMARY KEY CLUSTERED ([BookId] ASC)
)
使用依赖注入
BooksContext
public class BooksContext : DbContext
{
public BooksContext(DbContextOptions<BooksContext> options) : base(options) { }
}
BooksService
public class BooksService
{
private BooksContext _booksContext;
public BooksService(BooksContext context) => _booksContext = context;
}
主调程序
class Program
{
static async Task Main()
{
var p = new Program();
p.InitializeServices();
p.ConfigureLogging();
var service = p.Container.GetService<BooksService>();
}
/// Model
Convention(约定)，Annotation(注释)和Fluent API
EF Core使用三个概念来定义模型：Convention，Annotation和Fluent API。
- Convention——会自动对数据库进行操作。例如，使用Id后缀命名int类型或Guid类型的属性会将属性映射到主键。
- Annotation——可以使用注释覆盖约定。
- Fluent API——可以使用Fluent API代替注释，比注释强大。通过代码完成配置。使用Fluent API，方法的返回值可用于调用下一个方法。
Convention
Book
public class Book
{
public int BookId { get; set; }
public string Title { get; set; }
public List<Chapter> Chapters { get; } = new List<Chapter>();
/// Chapter
public class Chapter
{
public int ChapterId { get; set; }
public int Number { get; set; }
public string Title { get; set; }
/// Page
public class Page
{
public int PageId { get; set; }
public string Content { get; set; }
/// User
public class User
{
public int UserId { get; set; }
public string Name { get; set; }
public List<Book> AuthoredBooks { get; set; }
}
使用约定的Table per Hierarchy(TPH)
EF Core支持Table per Hierarchy(TPH)关系类型。 通过此关系，可以使用形成层次结构的多个模型类映射到单个表。 可以使用约定和使用fluent API指定此关系。
运行应用程序以创建数据库时，只创建了一个表-Payments。 此表定义了一个Discriminator列，它将表中的记录映射到相应的模型类型。
SELECT [p].[PaymentId], [p].[Amount], [p].[Discriminator],
[p].[Name],
[p].[CreditcardNumber]
FROM [Payments] AS [p]
WHERE [p].[Discriminator] = N'CreditcardPayment'
当然，在这种情况下，也可以调用上下文属性CreditcardPayments，从而产生相同的查询。
Annotation
Book
/// Chapter
[Table("Chapters", Schema = "myAnnotation")]
public class Chapter
{
public int ChapterId { get; set; }
public int Number { get; set; }
[MaxLength(120)]
public string Title { get; set; }
/// Page
[Table("Pages", Schema = "myAnnotation")]
public class Page
{
public int PageId { get; set; }
public string Content { get; set; }
/// User
/// Fluent API
指定关系的最有效方法是使用Fluent API。
- 一对一：HasOne和WithOne
- 一对多：HasOne和WithMany
- 多对一：HasMany and WithOne
Fluent API的优点:
- 可以在不添加任何属性的情况下保持实体类型简单，
- 相对于属性而言Fluent API提供了更多的选项
配置自包含类型(Self-Contained Type Configuration)
DbContext.OnModelCreating方法过长可以使用类型配置类。需要接口IEntityTypeConfiguration，并使用Configure方法。
BookConfiguration
public class BookConfiguration : IEntityTypeConfiguration<Book>
{
public void Configure(EntityTypeBuilder<Book> builder)
{
//主键
builder.ToTable("Books").HasKey(b => b.BookId);
//自增
builder.Property(b => b.BookId).ValueGeneratedOnAdd();
builder.Property(b => b.Title).HasMaxLength(50);
//关系
builder.HasMany(b => b.Chapters).WithOne(c => c.Book);
builder.HasMany(b => b.Pages).WithOne(p => p.Book);
#region 多个User类型的写法
builder.HasOne(b => b.Author).WithMany(u => u.AuthoredBooks);
builder.HasOne(b => b.Editor).WithMany(u => u.EditedBooks);
#endregion
}
}
public class BooksContext : DbContext
{
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
modelBuilder.ApplyConfiguration(new BookConfiguration());
}
}
Scaffolding a Model from the Database——Need
添加依赖
Microsoft.EntityFrameworkCore
Microsoft.EntityFrameworkCore.SqlServer
Microsoft.EntityFrameworkCore.Design
Microsoft.EntityFrameworkCore.Tools.Dotnet
dotnet ef dbcontext scaffold
数据库连接串
provider(例如：Microsoft.EntityFrameworkCore.SqlServer)
> dotnet ef dbcontext scaffold "server=(localdb)\MSSQLLocalDb;database=MenuCards;trusted_connection=true" "Microsoft.EntityFrameworkCore.SqlServer"
运行此命令后，可以看到DbContext派生类以及生成的模型类型。 默认情况下，模型的配置使用fluent API完成。 但是，您可以将其更改为使用提供–data-annotations选项的数据注释。 还可以影响生成的上下文类名称以及输出目录。
字段映射(Mapping to Fields)
EF Core不仅可以将表中的列映射到属性，还允许映射到私有字段。 这使得可以创建只读属性并使用在类外无法访问的私有字段。
Page
public class Page
{
private Page() { }
public Page(string remark)
{
_remark = remark;
}
/// PageConfiguration
internal class PageColumnNames
{
public const string PageId = nameof(PageId);
}
public class PageConfiguration : IEntityTypeConfiguration<Page>
{
public void Configure(EntityTypeBuilder<Page> builder)
{
builder.ToTable("Pages");
// _pageId没有相应的属性,使用Property的重载方法，会将数据库中的PageId映射到字段_pageId
builder.Property<int>(PageId).HasField("_pageId").IsRequired();
builder.HasKey(PageId);
builder.Property<int>(PageId).ValueGeneratedOnAdd();
// 使用HasField方法将Remark属性映射到相应字段。
builder.Property(b => b.Remark).HasField("_remark").IsRequired(false).HasMaxLength(100);
builder.HasOne(p=>p.Book).WithMany(b => b.Pages);
}
}
数据库
阴影属性（shadow Property）
将数据库列映射到Model中根本没有的字段。可以在上下文使用实体检索不能在Model中使用的阴影属性。
用途
- 频繁操作
- 状态值
**PageConfiguration **
internal class PageColumnNames
{
public const string LastUpdated = nameof(LastUpdated);
public const string IsDeleted = nameof(IsDeleted);
public const string PageId = nameof(PageId);
}
public class PageConfiguration : IEntityTypeConfiguration<Page>
{
public void Configure(EntityTypeBuilder<Page> builder)
{
builder.ToTable("Pages");
// 阴影属性
// LastUpdated：实体最后更新的时间。
// IsDeleted：逻辑删除还是物理删除。逻辑删除可以撤消以恢复实体并提供历史信息。
builder.Property<bool>(IsDeleted);
builder.Property<DateTime>(LastUpdated);
}
}
SaveChanges
/// 从属实体(owned entity)
包含从属实体(owned entity)的实体类可以将表拆分为多个实体类型。从属实体(owned entity)不需要主键;
包含从属实体的实体类能映射到
- 一个表：使用表拆分特性
- 多个表：它们共享相同的主键。
Page
public class Page
{
private Page() { }
public Page(string remark)
{
_remark = remark;
}
/// PageConfiguration
internal class PageColumnNames
{
public const string LastUpdated = nameof(LastUpdated);
public const string IsDeleted = nameof(IsDeleted);
public const string PageId = nameof(PageId);
}
public class PageConfiguration : IEntityTypeConfiguration<Page>
{
public void Configure(EntityTypeBuilder<Page> builder)
{
builder.ToTable("Pages");
builder.OwnsOne(p => p.TitleFont).OwnsOne<FontColor>(t => t.FontColor, tbuilder =>
{
tbuilder.Property(p => p.FontColorName).HasColumnName("TitleFontColorName");
});
builder.OwnsOne(p => p.TextFont).ToTable("TextFont").OwnsOne(a => a.FontColor);
}
}
测试代码（阴影属性和从属实体）
/// 顺序执行测试代码
创建的两个表：Pages和TextFont
表拆分(Table Splitting)——EF Core2.0
表拆分可以将单个数据库表拆分为多个实体类型。同一个表的每个类都需要一个一对一的关系并定义自己的主键。 但是，因为它们共享同一个表，所以也共享相同的主键。
User
public class User
{
public int UserId { get; set; }
public string Name { get; set; }
public List<Book> AuthoredBooks { get; set; }
public List<Book> EditedBooks { get; set; }
/// Address
public class Address
{
public int AddressId { get; set; }
public string AddressDetail { get; set; }
public int UserId { get; set; }
public User User { get; set; }
}
AddressConfiguration
public class AddressConfiguration : IEntityTypeConfiguration<Address>
{
public void Configure(EntityTypeBuilder<Address> builder)
{
#region 一个数据库表分为两个实体User和Address
builder.ToTable("Users");
#endregion
}
}
**UserConfiguration **
public class UserConfiguration : IEntityTypeConfiguration<User>
{
public void Configure(EntityTypeBuilder<User> builder)
{
builder.ToTable("Users").HasKey(u => u.UserId);
builder.Property(u => u.UserId).ValueGeneratedOnAdd();
builder.Property(u=>u.Name).IsRequired();
#region 多个List的写法
builder.HasMany(u => u.AuthoredBooks).WithOne(b => b.Author);
builder.HasMany(u => u.EditedBooks).WithOne(b => b.Editor);
#endregion
#region 表拆分，一个数据库表分为两个实体User和Address
// 在上下文中，User和Address是两个DbSet属性。
// 在OnModelCreating方法中，User类与Address使用HasOne和WithOne配置为一对一关系。
// User和Address传递给ToTable方法的参数指定了相同的表名。
// User和Address都映射到同一个表Users。
//builder.ToTable("Users").HasKey(u => u.UserId); //需要本段代码，可与不设置主键，因为第一行有，所以不重复
builder.HasOne(u => u.Address).WithOne(a => a.User).HasForeignKey<Address>(a => a.AddressId);
#endregion
}
}
实体拆分与表拆分相反，其中实体被拆分为多个表。 EF Core 2.0尚未提供此功能，但计划使用更高版本的EF Core。
使用Fluent API的Table per Hierarchy
使用Fluent API，可以更好地控制层次结构。
The database created looks similar like before, just instead of the
Discriminator column the table Payments now defines the Type column
—as specified with the creation of the model. The new query asking for
credit card numbers filters the Type column:
SELECT [p].[PaymentId], [p].[Amount], [p].[Name], [p].[Type],
[p].[CreditcardNumber]
FROM [Payments] AS [p]
WHERE [p].[Type] = N'Creditcard'
Context
Convention(约定)，Annotation(注释)
public class BooksContext :DbContext
{
private const string ConnectionString = @"server=(localdb)\MSSQLLocalDb;database=EFCoreDemo;trusted_connection=true";
/// 还可以使用依赖注入定义数据库连接串
Fluent API
public class BooksContext : DbContext
{
/// 依赖注入
主程
public ServiceProvider Container { get; private set; }
/// 添加日志
主程
/// Context pooling（上下文池）——EF Core 2.0
EF Core 2.0中，使用上下文池(context pooling)可以提高性能。数据库连接应在需要时打开，使用后关闭。此行为已在在EF Core中实现。正在关闭连接时(On closing)，数据库连接并未真正关闭。实际上，连接回到池中，等待重用。
DB context应该在需要之前创建，并在使用后立即关闭（销毁）。这种开销并不像您预期的那么重要。每次重新调用 context 时，都不会重新初始化模型；相反，模型被重用。使用Entity Framework和XML文件映射，创建context 的开销比使用EF Core时要大得多。但是，当有大的 context 时，创建context的开销可能仍然很大。在这里，您可以使用Context pooling来提高性能。
要使用上下文池，必须使用依赖注入。要激活Context pooling，您需要做的就是将EF Core注册从AddDbContext更改为AddDbContextPool。这样，从Context pooling中检索注入的Context
var services = new ServiceCollection();
services.AddTransient<BooksController>();
services.AddTransient<BooksService>();
services.AddEntityFrameworkSqlServer();
services.AddDbContextPool<BooksContext>(options =>
options.UseSqlServer(ConnectionString));
services.AddLogging();
Container = services.BuildServiceProvider();
事务
每次使用实体框架访问数据库时，都会涉及一个事务。 您可以隐式使用事务，也可以根据需要使用配置显式创建事务。
隐式事务
SaveChanges方法的调用会自动解析为一个事务。 如果更改的一部分失败——例如，由于数据库约束——所有已完成的更改都将回滚。
/// 异常的详细信息
An error occurred while updating the entries. See the inner exception for details.
The INSERT statement conflicted with the FOREIGN KEY constraint "FK_Chapters_Books_BookId". The conflict occurred in database "EFCoreDemoFluentAPI", table "fluent.Books", column 'BookId'.
The statement has been terminated.
多次调用SaveChanges，实现第一条插入成功，第二天插入失败。
/// 第一条插入成功，第二天插入失败
添加了1条
An error occurred while updating the entries. See the inner exception for details.
failThe INSERT statement conflicted with the FOREIGN KEY constraint "FK_Chapters_Books_BookId". The conflict occurred in database "EFCoreDemoFluentAPI", table "fluent.Books", column 'BookId'.
The statement has been terminated.
显式事务
使用显示事务，可以选择在某些业务逻辑失败时回滚，并且可以在一个事务中绑定多次调用SaveChanges。
要启动DbContext派生类的事务，需要调用DbContext.Database.BeginTransaction()，该方法返回IDbContextTransaction。
/// 第一次SaveChanges方法显示了一条添加记录，但此记录将稍后基于Rollback删除。 根据隔离级别（isolation level）的设置，更新的记录只能在事务中完成回滚之前查看，但不能在事务之外查看。
添加了1条
An error occurred while updating the entries. See the inner exception for details.
The INSERT statement conflicted with the FOREIGN KEY constraint "FK_Chapters_Books_BookId". The conflict occurred in database "EFCoreDemoFluentAPI", table "fluent.Books", column 'BookId'.
The statement has been terminated.
rolling back…
使用BeginTransaction方法，您设置隔离级别（isolation level）用来指定数据库中所需的隔离要求和锁定。
冲突处理
如果多个用户在同一记录上工作，则需要考虑解决冲突。有很多不同的方法来处理这个问题。 最简单的是最后一个获胜。 最后保存数据的用户会覆盖先前执行更改的用户的更改。
EF Core还提供了让第一个成功的方法。 使用此选项，在保存记录时，如果最初读取的数据仍在数据库中，则需要进行验证。 如果是这种情况，保存数据可以继续，因为读取和写入之间没有发生变化。 但是，如果数据发生变化，则需要进行冲突解决。 让我们进入这些不同的选择。
保留最后一个
默认最后保存最后一条更改。
private const string BookTitle = "sample book";
private const string ConnectionString = @"server=(localdb)\MSSQLLocalDb;database=EFCoreDemoFluentAPI;trusted_connection=true";
/// 第一次更新和第二次更新都执行更新成功，第二次更新只会覆盖第一次更新中的数据，
用户1: 1 record updated from 用户1
用户2: 1 record updated from 用户2
this is the updated state: 用户2更新了这条
保留第一个
Book
public class Book
{
//...
#region 解决冲突_保留第一个更改
public byte[] TimeStamp { get; set; }
#endregion
}
BookConfiguration
public void Configure(EntityTypeBuilder<Book> builder)
{
//...
#region 解决冲突_保留第一个更改,和保存最后一个更改会有冲突
builder.Property(p => p.TimeStamp).HasColumnType("timestamp")
.ValueGeneratedOnAddOrUpdate().IsConcurrencyToken();
#endregion
}
String扩展方法
public static class ByteArrayExtension
{
public static string StringOutput(this byte[] data)
{
var sb = new StringBuilder();
foreach (byte b in data)
{
sb.Append($"{b}.");
}
return sb.ToString();
}
}
示例方法
private const string BookTitle = "sample book";
private const string ConnectionString = @"server=(localdb)\MSSQLLocalDb;database=EFCoreDemoFluentAPI;trusted_connection=true";
public void ConflictHandingFirst()
{
var options = new DbContextOptionsBuilder<BooksContext>();
options.EnableSensitiveDataLogging();
options.UseSqlServer(ConnectionString);
// 准备初始数据
void PrepareBook()
{
using (var context = new BooksContext(options.Options))
{
context.Books.Add(new Book() { Title = BookTitle });
context.SaveChanges();
}
}
PrepareBook();
(BooksContext context, Book book) PrepareUpdateFirst()
{
var pOptions = new DbContextOptionsBuilder<BooksContext>();
pOptions.EnableSensitiveDataLogging();
pOptions.UseSqlServer(ConnectionString);
var context = new BooksContext(pOptions.Options);
Book book = context.Books.Where(b => b.Title == BookTitle).FirstOrDefault();
return (context, book);
}
// user 1
var tuple1 = PrepareUpdateFirst();
tuple1.book.Title = "用户1更新了这条";
// user 2
var tuple2 = PrepareUpdateFirst();
tuple2.book.Title = "用户2更新了这条";
UpdateFirst(tuple1.context, tuple1.book, "用户1");
UpdateFirst(tuple2.context, tuple2.book, "用户2");
tuple1.context.Dispose();
tuple2.context.Dispose();
CheckUpdateFirst(tuple1.book.BookId);
}
private void UpdateFirst(BooksContext context, Book book,string user) {
try
{
Console.WriteLine($"{user}: 更新中: id {book.BookId}, timestamp {book.TimeStamp.StringOutput()}");
ShowChangesFirst(book.BookId, context.Entry(book));
int records = context.SaveChanges();
Console.WriteLine($"{user}: 已更新 {book.TimeStamp.StringOutput()}");
Console.WriteLine($"{user}: 已更新 {records} 条 updated while updating {book.Title}");
}
catch (DbUpdateConcurrencyException ex)
{
Console.WriteLine($"{user}: 使用{book.Title}更新失败");
Console.WriteLine($"{user}: error: {ex.Message}");
foreach (var entry in ex.Entries)
{
if (entry.Entity is Book b)
{
Console.WriteLine($"{b.Title} {b.TimeStamp.StringOutput()}");
ShowChangesFirst(book.BookId, context.Entry(book));
}
}
}
}
private void ShowChangesFirst(int id, EntityEntry entity) {
//多次调用
void ShowChange(PropertyEntry propertyEntry) =>
Console.WriteLine($"id:{id},CurrentValue：{propertyEntry.CurrentValue}," +
$"original: {propertyEntry.OriginalValue}, modified: {propertyEntry.IsModified}");
ShowChange(entity.Property("Title"));
}
private static void CheckUpdateFirst(int id)
{
var options = new DbContextOptionsBuilder<BooksContext>();
options.EnableSensitiveDataLogging();
options.UseSqlServer(ConnectionString);
using (var context = new BooksContext(options.Options))
{
Book book = context.Books.Find(id);
Console.WriteLine($"已更新状态: {book.Title}");
}
结果
用户1: 更新中: id 10, timestamp 0.0.0.0.0.0.23.119.
id:10,CurrentValue：用户1更新了这条,original: sample book, modified: True
用户1: 已更新 0.0.0.0.0.0.23.120.
用户1: 已更新 1 条 updated while updating 用户1更新了这条
用户2: 更新中: id 10, timestamp 0.0.0.0.0.0.23.119.
id:10,CurrentValue：用户2更新了这条,original: sample book, modified: True
用户2: 使用用户2更新了这条更新失败
用户2: error: Database operation expected to affect 1 row(s) but actually affected 0 row(s). Data may have been modified or deleted since entities were loaded. See http://go.microsoft.com/fwlink/?LinkId=527962 for information on understanding and handling optimistic concurrency exceptions.
用户2更新了这条 0.0.0.0.0.0.23.119.
id:10,CurrentValue：用户2更新了这条,original: sample book, modified: True
已更新状态: 用户1更新了这条
数据库创建与删除
创建
public async Task CreateDatabaseAsync()
{
bool isCreated = await _booksContext.Database.EnsureCreatedAsync();
string res = isCreated ? "创建完毕" : "已创建";
Console.WriteLine($"数据库创建：{res}");
}
删除
public async Task DeleteDatabaseAsync()
{
bool isDeleted = await _booksContext.Database.EnsureDeletedAsync();
string res = isDeleted ? "删除完毕" : "无此数据库";
Console.WriteLine($"数据库删除：{res}");
}
查询
在调试期间打开IntelliTrace事件窗口时，您可以看到发送到数据库的SQL语句（这需要Visual Studio Enterprise版本）：
基本查询
/// Where方法可以简单过滤语句。 还可以在Where使用Contains方法。 因为Where使用得失延迟加载，所以没有异步方法。
foreach会触发查询的执行并阻塞线程，直到检索到结果。 而使用Task.ToListAsync可以立即执行。
List<Book> books = await context.Books.Where(b => b.Title.Contains(title)).ToListAsync();
原始Sql查询
private async Task RawSqlQuery(string title)
{
IList<Book> books = await _booksContext.Books.FromSql(
$"SELECT * FROM fluent.Books WHERE Title = {title}")
.ToListAsync();
foreach (var b in books)
{
Console.WriteLine(b.ToString());
}
}
编译查询——需要重复执行的查询
对于需要重复执行的查询，可以使用EF.CompileQuery创建编译查询进行。
/// 可以为创建编译查询作为一个成员字段（create a compiled query to a member field ），以便在以后需要时使用它，并且通过传递不同下上文进行查询。
EF.Functions
EF Core允许provider 实现的自定义扩展方法。 为此，EF类定义了可以使用extension method扩展的DbFunction类型的Functions属性。
/// 运行应用程序时，包含EF.Functions.Like的方法将转换为带有LIKE的SQL子句WHERE：
SELECT [b].[BookId], [b].[AuthorUserId], [b].[EditorUserId], [b].[Title], [b].[Type], [b].[AgeLimit]
FROM [fluent].[Books] AS [b]
WHERE [b].[Type] IN (N'MinorBook', N'AdultBook', N'Book') AND [b].[Title] LIKE @__likeExpression_1
显式加载
查询对象并显示相关属性——使用显示加载
/// 实现Load方法的NavigationEntry类还实现了一个IsLoaded属性，可以在其中检查是否已加载关系。 在调用Load方法之前，您不需要检查加载的关系; 如果在调用Load方法时已经加载了关系，则对数据库的查询不会再次发生。
// 使用查询书籍运行应用程序时，将在SQL Server上执行以下SELECT语句。 此查询仅访问Books表：
SELECT TOP(1) [b].[BookId], [b].[AuthorUserId], [b].[EditorUserId], [b].[Title], [b].[Type], [b].[AgeLimit]
FROM [fluent].[Books] AS [b]
WHERE [b].[Type] IN (N'MinorBook', N'AdultBook', N'Book') AND (([b].[Title] LIKE @__startsWithTitle_0 + N'%' AND (LEFT([b].[Title], LEN(@__startsWithTitle_0)) = @__startsWithTitle_0)) OR (@__startsWithTitle_0 = N''))
// 使用以下Load方法检索书籍的page，SELECT语句根据书籍ID检索章节：
SELECT [p].[PageId], [p].[BookId], [p].[Content], [p].[IsDeleted], [p].[LastUpdated], [p].[Remark], [p].[PageId], [p].[TitleFont_FontName], [p].[PageId], [p].[TitleFontColorName], [e.TextFont].[PageId], [e.TextFont].[FontName], [e.TextFont].[PageId], [e.TextFont].[FontColor_FontColorName]
FROM [fluent].[Pages] AS [p]
LEFT JOIN [fluent].[TextFont] AS [e.TextFont] ON [p].[PageId] = [e.TextFont].[PageId]
WHERE ([p].[IsDeleted] = 0) AND ([p].[BookId] = @__get_Item_0)
// 第三个查询，从Users表中检索用户信息：
SELECT [e].[UserId], [e].[Name]
FROM [fluent].[Users] AS [e]
WHERE [e].[UserId] = @__get_Item_0
立即加载
通过调用Include方法来实现立即加载。
/// 使用Include，只执行一个SQL语句来访问Books表并加入Pages和Users表：
如果需要包含多级关系，则可以在Include方法的结果上使用ThenInclude方法。
全局查询过滤器
Page的IsDeleted列使用了阴影状态。 当IsDeleted为true时，不需要为每个查询定义where。代替的是可以在创建Model时定义全局查询过滤器
builder.HasQueryFilter(p => !EF.Property<bool>(p, IsDeleted));
通过定义此查询过滤器。检查IsDeleted的Where语句将会添加到每个使用这个上下文的查询。
全局查询过滤器也具有多租户技术要求的实际用途（Global query filters are also of practical use with multi-tenancy requirements. ）。 可以为特定的tenant-id为上下文筛选所有查询。 您只需要在构造上下文时传递tenant-id。
不使用依赖注入，可以将tenant-id传递给构造函数。
使用依赖项注入，您只需指定一个使用构造函数注入的服务，其中可以在查询过滤器中检索tenant-id。multi-tenancy technology（多租户技术或称多重租赁技术），是一种软件架构技术，它是在探讨与实现如何于多用户的环境下共用相同的系统或程序组件，并且仍可确保各用户间数据的隔离性。
可以忽略全局查询过滤器。 例如，要获取所有已删除的实体，可以将方法IgnoreQueryFilters应用于LINQ表达式。
客户端和服务端评估
查询并非所有的部分都可以转换为Sql语句并在服务器上运行。某些部分需要在客户端上运行。EF Core允许透明的客户端和服务器评估。例如，能在服务器上完全评估查询的一个提供者。使用不解析所有查询的另一个提供程序，程序仍然运行，但是现在在客户机上评估了一些部分。
举例： Book与Author相关。一本书可以由多位作者撰写，一位作者可以写多本书。执行以下代码。
var books = context.Books
.Where(b => b.Title.StartsWith("Pro"))
.OrderBy(b => b.Title)
.Select(b => new
{
b.Title,
Authors = b.BookAuthors
});
所有的代码都能使用EF Core 2.0转换为SQL语句。评估只在服务器上运行。
SELECT [b.BookAuthors].[BookId], [b.BookAuthors].[AuthorId]
FROM [BookAuthors] AS [b.BookAuthors]
INNER JOIN (
SELECT [b0].[BookId], [b0].[Title]
FROM [Books] AS [b0]
WHERE [b0].[Title] LIKE N'Pro' + N'%' AND (LEFT([b0].[Title], LEN(N'Pro')) = N'Pro')) AS [t] ON [b.BookAuthors].[BookId] = [t].[BookId]
ORDER BY [t].[Title], [t].[BookId]
如果Select语句修改为返回包含作者的逗号分隔字符串，则结果会不同。
将字符串分配给Authors属性。使用BookAuthors，只选择作者的FirstName和LastName属性，string.Join将列表连接到单个字符串
var books = context.Books
.Where(b => b.Title.StartsWith("Pro"))
.OrderBy(b => b.Title)
.Select(b => new
{
b.Title,
Authors = string.Join(", ", b.BookAuthors.Select(a => $"{a.Author.FirstName} {a.Author.LastName}").ToArray())
});
EF Core 2.0无法将此查询转换为SQL语句。来自EF Core的记录信息显示此警告：
warn: Microsoft.EntityFrameworkCore.Query[200500]
The LINQ expression 'join Author a.Author in value(
Microsoft.EntityFrameworkCore.Query.Internal.EntityQueryable`1[
BooksSample.Author]) on Property([a], "AuthorId")
equals
Property([a.Author], "AuthorId")'
could not be translated and will be evaluated locally.
现在执行了三个查询。这些查询的结果将在客户端上加入。该应用程序仍然有效，但查询效率不高。在SQL Server中执行三个语句而不是一个语句，在分析查询时，您可以看到在客户端上进行评估之前从服务器检索所有作者。这可能会导致向客户端的大量传输：
SELECT [b].[Title], [b].[BookId]
FROM [Books] AS [b]
WHERE [b].[Title] LIKE N'Pro' + N'%' AND (LEFT([b].[Title], LEN(N'Pro')) = N'Pro')
ORDER BY [b].[Title]
SELECT [b0].[BookId], [b0].[AuthorId]
FROM [BookAuthors] AS [b0]
WHERE @_outer_BookId = [b0].[BookId]
SELECT [a.Author].[AuthorId], [a.Author].[FirstName],[a.Author].[LastName]
FROM [Authors] AS [a.Author]
自动进行客户端和服务器评估是切实可行的。与EF Core 1.0不同，EF Core 2.0的SQL Server提供程序可以在服务器上进行更多评估，未来版本甚至可以在服务器上支持更多评估。使用其他提供商可能会有不同的结果效率不一样，但至少程序是有效的。
要避免在服务器上进行评估，可以将上下文配置为仅在服务器上进行评估时抛出异常。您可以在配置上下文时通过在optionsBuilder上调用ConfigureWarnings方法来执行此操作：
optionsBuilder.UseSqlServer(ConnectionString)
.ConfigureWarnings(warnings =>
warnings.Throw(RelationalEventId.QueryClientEvaluationWarning));
客户端和服务器评估是使您的程序跨不同提供程序工作的一个很好的功能。但是，这可能会导致性能下降。要定义查询以获得最佳性能，可以通过配置抛出异常，轻松找出客户端何时进行评估。然后，可以相应地更改查询。
保存
保存
/// type: Book,state: Added, Id:-2147482647,Title:SaveBook1
type: User,state: Added, EFCoreModelUsingFluentAPI.Models.User
type: Address,state: Added, EFCoreModelUsingFluentAPI.Models.Address
type: Page,state: Added, PageId:-2147482647,ContentContent1_1
type: Page,state: Added, PageId:-2147482646,ContentContent1_2
type: TextFont,state: Added, EFCoreModelUsingFluentAPI.Models.TextFont
type: TextFont,state: Added, EFCoreModelUsingFluentAPI.Models.TextFont
type: FontColor,state: Added, EFCoreModelUsingFluentAPI.Models.FontColor
type: FontColor,state: Added, EFCoreModelUsingFluentAPI.Models.FontColor
type: TextFont,state: Added, EFCoreModelUsingFluentAPI.Models.TextFont
type: TextFont,state: Added, EFCoreModelUsingFluentAPI.Models.TextFont
type: FontColor,state: Added, EFCoreModelUsingFluentAPI.Models.FontColor
type: FontColor,state: Added, EFCoreModelUsingFluentAPI.Models.FontColor
对象追踪
上文了解到上下文是如何添加对象的。但是，还需要知道上下文是如何修改对象的。为了了解修改，检索的每个对象都需要在上下文中显示其状态。 为了在action中能看到，让我们创建两个返回同一对象的不同查询。
public void ObjectTracking()
{
var b1 = (from b in _booksContext.Books
where b.Title.StartsWith("Save")
select b).FirstOrDefault();
var b2 = (from b in _booksContext.Books
where b.Title.Contains("(")
select b).FirstOrDefault();
if (object.ReferenceEquals(b1, b2))
{
Console.WriteLine("相同对象");
}
else {
Console.WriteLine("不同对象");
}
ShowState();
}
//第一个查询
SELECT TOP(1) [b].[BookId], [b].[AuthorUserId], [b].[EditorUserId], [b].[Title], [b].[Type], [b].[AgeLimit]
FROM [fluent].[Books] AS [b]
WHERE [b].[Type] IN (N'MinorBook', N'AdultBook', N'Book') AND ([b].[Title] LIKE N'Save' + N'%' AND (LEFT([b].[Title], LEN(N'Save')) = N'Save'))
//第二个查询
SELECT TOP(1) [b].[BookId], [b].[AuthorUserId], [b].[EditorUserId], [b].[Title], [b].[Type], [b].[AgeLimit]
FROM [fluent].[Books] AS [b]
WHERE [b].[Type] IN (N'MinorBook', N'AdultBook', N'Book') AND (CHARINDEX(N'(', [b].[Title]) > 0)
相同对象
type: Book,state: Unchanged, Id:1,Title:SaveBook1(Tracker)
type: User,state: Unchanged, EFCoreModelUsingFluentAPI.Models.User
type: Address,state: Unchanged, EFCoreModelUsingFluentAPI.Models.Address
type: Page,state: Unchanged, PageId:1,ContentContent1_1
type: Page,state: Unchanged, PageId:2,ContentContent1_2
type: TextFont,state: Unchanged, EFCoreModelUsingFluentAPI.Models.TextFont
type: TextFont,state: Unchanged, EFCoreModelUsingFluentAPI.Models.TextFont
type: FontColor,state: Unchanged, EFCoreModelUsingFluentAPI.Models.FontColor
type: FontColor,state: Unchanged, EFCoreModelUsingFluentAPI.Models.FontColor
type: TextFont,state: Unchanged, EFCoreModelUsingFluentAPI.Models.TextFont
type: TextFont,state: Unchanged, EFCoreModelUsingFluentAPI.Models.TextFont
type: FontColor,state: Unchanged, EFCoreModelUsingFluentAPI.Models.FontColor
type: FontColor,state: Unchanged, EFCoreModelUsingFluentAPI.Models.FontColor
// 想不跟踪从数据库运行查询的对象，可以使用DbSet调用AsNoTracking方法
var b1 = (from b in _booksContext.Books.AsNoTracking()
where b.Title.StartsWith("Save")
select b).FirstOrDefault();
// 您还可以配置ChangeTracker的默认跟踪行为
_booksContext.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;
// 全局配置,还可以使用SQL Server配置跟踪行为
options.UseSqlServer(ConnectionString).UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking)
//配置完毕，对数据库进行两次查询，实现两个对象，并且状态信息为空。
当context仅用于读取记录但不进行更改时，使用NoTracking配置非常有用。 这减少了context 的开销，因为不保留状态信息。
更新对象
示例更新对象，并跟踪状态。
public void UpdateRecords()
{
Book book = _booksContext.Books.Skip(1).FirstOrDefault();
ShowState();
book.Title += "UpdateRecords";
ShowState();
int records = _booksContext.SaveChanges();
Console.WriteLine($"{records} updated");
ShowState();
}
type: Book,state: Unchanged, Id:2,Title:Book
type: Book,state: Modified, Id:2,Title:BookUpdateRecords
1 updated
type: Book,state: Unchanged, Id:2,Title:BookUpdateRecords
从更改跟踪器（change tracker）访问实体时，默认情况下会自动检测更改。ChangeTracker.AutoDetectChangesEnabled 可以开关。 调用DetectChanges可以手动检查是否已完成更改。调用SaveChangesAsync，状态将更改回Unchanged。可以通过调用AcceptAllChanges方法手动执行此操作。
更新未跟踪的对象
DB context通常具有短暂的生命周期。将EF Core与ASP.NET Core MVC一起使用，通过HTTP请求创建context来检索对象(with one HTTP request one object context is created to retrieve objects)。此对象没有和context关联。要在数据库更新它，此对象需要和DB context关联，并且状态会更改以便创建INSERT，UPDATE或DELETE语句。
/// entity = _booksContext.Books.Attach(b);
// entity.State = EntityState.Modified;
// 使用Update可以自动完成以上注释的语句
_booksContext.Books.Update(b);
ShowState();
_booksContext.SaveChanges();
}
type: AdultBook,state: Modified, Id:3,Title:AdultBookUpdateRecordsChangeUntracked
批处理
停用批处理：MaxBatchSize设置为1
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
base.OnConfiguring(optionsBuilder);
optionsBuilder.UseSqlServer(ConnectionString,
options => options.MaxBatchSize(1));
}
批处理示例：
/// 迁移-Need
EF Core 迁移并无多大帮助：在使用EF Core的许多场景中，数据库已经存在。对数据库的更新与应用程序无关，应用程序在数据库更改完成后更新。
EF Core 迁移会有帮助：如果使用应用程序创建数据库。在更改Model时，数据库会自动更新。客户各自拥有数据库，使用新版本应用程序更新老版本应用程序的数据库是一个挑战。EF Core迁移可以解决此问题：通过迁移，您可以轻松地从版本x升级到版本y。从数据库中读取当前版本的数据库，MIGRATIONS具有升级到最新版本的每个步骤所需的信息。 您还可以升级或降级到特定版本。
您有不同的选项来升级数据库。 可以使用升级命令（upgrade commands）直接从应用程序进行迁移。 您还可以使用dotnet命令从命令行更新数据库。 另一种选择是创建一个SQL服务器脚本，数据库管理员可以使用该脚本来更新数据库。
The sample application to show migrations exists from a .NET Standard library and a .NET Core Web application. Typically, data access code is implemented within a library, and there are some additional command-line options needed to deal with this, that’s why migrations are demonstrated in such a scenario.
创建Migrations（迁移）
更改当前目录为Model和Context的目录。如图，目录应为MigrationLib的目录。
// 1. 更换工作目录
cd C:\Users\Stone\Source\Repos\Professional_CSharp_Demo\EFCoreMigrations\MigrationsLib
// 2. 创建InitMenus
// --startup-project : 如果应用和Context不是一个项目，则需要提供应用项目
// --context:如果项目包含多个数据库上下文，则需要提供数据库上下文类的名称
dotnet ef migrations add InitMenus --startup-project ../EFCoreMigrations
执行完以上命令会自动生成文件：
MigrationsLib/Migration/MenusContextModelSnapshot.cs
根据模型创建完整的数据库模式
MigrationsLib/Migration/_InitialMenus.cs
每次迁移，都会创建从基类Migration派生测migration类。基类定义了Up和Down方法，这些方法控制migration的版本（应用当前迁移版本或回退）。
删除InitMenus
dotnet ef migrations remove --startup-project ../EFCoreMigrations
更新Menu的字段，增加Image属性
public class Menu
{
public int MenuId { get; set; }
public string Text { get; set; }
public decimal Price { get; set; }
public string Allergens { get; set; }
public string Image { get; set; }
public int MenuCardId { get; set; }
public MenuCard MenuCard { get; set; }
public override string ToString() => Text;
}
Migrations更新语句
dotnet ef migrations add Image --startup-project ..\MigrationsConsoleApp
会创建新的文件MigrationsLib/Migration/_Image.cs
With every change you’re doing, you can create another migration. The new migration defines only the changes needed to get from the previous version to the new version. In case a customer’s database needs to be updated from any earlier
version, the necessary migrations are invoked when migrating the database.
通过您正在进行的每项更改，您都可以创建另一个迁移。 新迁移仅定义从先前版本到新版本所需的更改。 如果客户的数据库需要从任何更早的版本更新
版本，迁移数据库时调用必要的迁移。
开发时，可以删除旧的迁移，重新开始迁移。
以编程方式应用迁移
Deleting Records
诸如EF Core之类的对象关系映射工具不是对所有场景都有好用。 使用示例代码无法有效地删除所有对象。 可以使用一个SQL语句删除所有记录，而不是每个记录一个一个删除。
Logging
要查看发送到数据库的SQL语句，可以使用SQL Server打开探查器，在Visual Studio中打开Intellitrace事件，这需要Visual Studio的企业版，或者只启用日志记录。通过日志记录，您可以在任意位置编写跟踪信息。
EF Core内部使用依赖注入容器（使用Microsoft.Extensions.DependencyInjection），该容器具有注册的ILoggerFactory接口。可以访问此界面并注册自己的Logging provider。