一、前言

这份指南旨在帮助你为主要考察 Entity Framework Core (EF Core) 的面试做好准备，内容涵盖基础、中级和高级三个不同经验级别。每个级别包括10个高频面试题，附有解题思路和详细的解答示例。

二、基础级别

重点在于 EF Core 的基本概念和使用，如 DbContext 的基本配置、简单的查询和插入操作、关系映射以及基本的迁移和模型验证。旨在评估对 EF Core 基本功能的理解，以及如何在简单的应用场景中使用这些功能。

1. 什么是 Entity Framework Core？

• 解题思路： 解释 EF Core 是什么，包括它的用途和基本功能。
• 解答示例：
  Entity Framework Core（简称 EF Core）是一个开源、轻量级、可扩展且跨平台的版本，它是 .NET 的流行对象关系映射（ORM）框架 Entity Framework 的现代化版本。EF Core 允许开发人员使用 .NET 对象与数据库进行交互，减少了编写大部分数据访问代码的需求。

2. EF Core 的主要特性有哪些？

• 解题思路： 列出并解释 EF Core 的主要特性。
• 解答示例：
  • 跨平台支持: 可在 Windows、Linux 和 macOS 上运行。
  • LINQ 查询: 支持使用 Language-Integrated Query (LINQ) 来检索和操作数据。
  • 更改跟踪: 自动跟踪对实体所做的更改。
  • 迁移: 帮助在模型更改时更新数据库架构。
  • 并发管理: 管理并发，防止多个用户访问数据时发生冲突。

3. 如何在 EF Core 中配置 DbContext？

• 解题思路： 解释 DbContext 的用途以及如何在 EF Core 中配置它。
• 解答示例：
  DbContext 是负责与数据库交互的主要类。可以在 OnConfiguring 方法中或通过依赖注入进行配置。以下是使用 SQL Server 数据库配置 DbContext 的示例：

  public class ApplicationDbContext : DbContext
  {
      protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
      {
          optionsBuilder.UseSqlServer("YourConnectionString");
      }
  }
  

4. DbContext 类中的 DbSet 属性的作用是什么？

• 解题思路： 讨论 DbSet<TEntity> 在管理实体中的角色。
• 解答示例：
  DbSet<TEntity> 代表可以从数据库查询和用于跟踪更改的实体集合。通常在 DbContext 类中定义为属性，用于表示数据库中的表。

  public class ApplicationDbContext : DbContext
  {
      public DbSet<Customer> Customers { get; set; }
      public DbSet<Order> Orders { get; set; }
  }
  

5. 如何使用 EF Core 执行 CRUD 操作？

• 解题思路： 提供如何执行创建、读取、更新和删除操作的示例。
• 解答示例：

  // 创建
  var customer = new Customer { Name = "John Doe" };
  context.Customers.Add(customer);
  context.SaveChanges();
  
  // 读取
  var customers = context.Customers.ToList();
  
  // 更新
  var customer = context.Customers.First();
  customer.Name = "Jane Doe";
  context.SaveChanges();
  
  // 删除
  var customer = context.Customers.First();
  context.Customers.Remove(customer);
  context.SaveChanges();
  

6. EF Core 中的被跟踪和未被跟踪的实体有什么区别？

• 解题思路： 解释跟踪的概念及其对 EF Core 操作的影响。
• 解答示例：
  在 EF Core 中，被跟踪的实体由 DbContext 监控其更改，这允许在调用 SaveChanges 时自动更新。未被跟踪的实体不受监控，尽管这可以提高性能，但需要手动处理更新。

7. 如何在 EF Core 中处理多对多关系？

• 解题思路： 讨论如何配置和使用多对多关系。
• 解答示例：
  从 EF Core 5.0 开始，支持无需连接实体的多对多关系。你可以使用导航属性来定义关系：

  public class Student
  {
      public int Id { get; set; }
      public string Name { get; set; }
      public ICollection<Course> Courses { get; set; }
  }
  
  public class Course
  {
      public int Id { get; set; }
      public string Title { get; set; }
      public ICollection<Student> Students { get; set; }
  }
  

8. 什么是数据注释（Data Annotations），它们在 EF Core 中如何使用？

• 解题思路： 描述数据注释的用途并给出示例。
• 解答示例：
  数据注释是可以应用于模型类的属性，用于配置数据库模式规则。例如：

  public class Customer
  {
      [Key]
      public int Id { get; set; }
  
      [Required]
      [MaxLength(100)]
      public string Name { get; set; }
  
      [EmailAddress]
      public string Email { get; set; }
  }
  

9. 如何在 EF Core 中使用 Fluent API？

• 解题思路： 解释如何使用 Fluent API 配置模型关系和属性。
• 解答示例：
  Fluent API 用于配置模型关系、属性和数据库模式行为。通常在 DbContext 中的 OnModelCreating 方法中完成。

  protected override void OnModelCreating(ModelBuilder modelBuilder)
  {
      modelBuilder.Entity<Customer>()
          .Property(c => c.Name)
          .IsRequired()
          .HasMaxLength(100);
  }
  

10. 什么是 EF Core 中的延迟加载（Lazy Loading），如何启用它？

• 解题思路： 定义延迟加载并描述如何在 EF Core 中实现它。
• 解答示例：
  延迟加载是一种特性，当通过导航属性访问相关数据时，它会自动从数据库加载数据。可以通过安装 Microsoft.EntityFrameworkCore.Proxies 包并配置 DbContext 来启用：

 protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
 {
      optionsBuilder.UseLazyLoadingProxies()
                    .UseSqlServer("YourConnectionString");
  }

---

三、中级级别

主要考察对更复杂的操作和高级特性的掌握，如复杂关系映射、事务管理、数据迁移的高级应用以及查询优化。如何在中等复杂度的场景中有效利用 EF Core 的功能，同时考量对性能优化和数据一致性的关注。

1. 如何在 EF Core 中实现和配置全局查询过滤器（Global Query Filters）？

• 解题思路： 解释全局查询过滤器的概念及其用途，并展示如何在 OnModelCreating 方法中进行配置。
• 解答示例：
  全局查询过滤器允许你为所有查询自动应用过滤条件，常用于实现软删除或多租户应用。可以在 DbContext 的 OnModelCreating 方法中配置：

  protected override void OnModelCreating(ModelBuilder modelBuilder)
  {
      modelBuilder.Entity<Order>().HasQueryFilter(o => !o.IsDeleted);
  }
  

  这样，所有对 Order 实体的查询都会自动包含 IsDeleted 为 false 的条件。

2. 什么是 EF Core 的延迟加载（Lazy Loading）和显式加载（Explicit Loading），它们有何区别？

• 解题思路： 定义延迟加载和显式加载，比较它们的优缺点，并提供实现示例。
• 解答示例：
  • 延迟加载（Lazy Loading）： 当访问导航属性时，相关数据才从数据库加载。需要启用代理或使用 ILazyLoader。

    var customer = context.Customers.First();
    var orders = customer.Orders; // 自动加载
    

  • 显式加载（Explicit Loading）： 需要明确调用方法来加载相关数据。

    var customer = context.Customers.First();
    context.Entry(customer).Collection(c => c.Orders).Load();
    

  • 区别： 延迟加载简化了代码，但可能导致意外的多次数据库查询；显式加载提供了更好的控制，但需要更多的代码。

3. 如何在 EF Core 中实现事务管理？

• 解题思路： 解释事务的概念，展示如何在 EF Core 中使用事务确保数据一致性。
• 解答示例：
  EF Core 提供了多种方式管理事务，包括隐式事务和显式事务。使用显式事务可以确保一组操作要么全部成功，要么全部失败。

  using var transaction = context.Database.BeginTransaction();
  try
  {
      context.Customers.Add(new Customer { Name = "Alice" });
      context.Orders.Add(new Order { Product = "Book", CustomerId = 1 });
      context.SaveChanges();
      
      transaction.Commit();
  }
  catch
  {
      transaction.Rollback();
      throw;
  }
  

4. 如何在 EF Core 中实现复杂类型（Owned Entities）？

• 解题思路： 解释复杂类型的概念及其用途，展示如何在模型中配置复杂类型。
• 解答示例：
  复杂类型（Owned Entities）用于表示不具有独立存在意义的实体，如地址信息。配置方式如下：

  public class Customer
  {
      public int Id { get; set; }
      public string Name { get; set; }
      public Address Address { get; set; }
  }
  
  [Owned]
  public class Address
  {
      public string Street { get; set; }
      public string City { get; set; }
  }
  
  protected override void OnModelCreating(ModelBuilder modelBuilder)
  {
      modelBuilder.Entity<Customer>().OwnsOne(c => c.Address);
  }
  

5. 如何在 EF Core 中使用投影（Projection）优化查询性能？

• 解题思路： 解释投影的概念及其在优化查询性能中的作用，提供使用示例。
• 解答示例：
  投影是指选择查询结果中的特定字段，而不是整个实体，减少数据传输量并提高性能。

  var customerNames = context.Customers
                              .Where(c => c.IsActive)
                              .Select(c => new { c.Name, c.Email })
                              .ToList();
  

  这样只会查询 Name 和 Email 字段，而不是整个 Customer 实体。

6. 如何在 EF Core 中处理并发冲突（Concurrency Conflicts）？

• 解题思路： 解释并发冲突的原因，展示如何使用乐观并发控制来处理冲突。
• 解答示例：
  并发冲突发生在多个用户同时修改同一数据时。EF Core 使用乐观并发控制，通过在模型中添加并发标记字段（如 RowVersion）来检测冲突。

  public class Customer
  {
      public int Id { get; set; }
      public string Name { get; set; }
      
      [Timestamp]
      public byte[] RowVersion { get; set; }
  }
  
  // 处理并发冲突
  try
  {
      context.SaveChanges();
  }
  catch (DbUpdateConcurrencyException ex)
  {
      foreach (var entry in ex.Entries)
      {
          if (entry.Entity is Customer)
          {
              var databaseValues = entry.GetDatabaseValues();
              entry.OriginalValues.SetValues(databaseValues);
          }
      }
      // 再次尝试保存
      context.SaveChanges();
  }
  

7. 如何在 EF Core 中使用原始 SQL 查询？

• 解题思路： 解释使用原始 SQL 查询的场景，展示如何在 EF Core 中执行和映射原始 SQL。
• 解答示例：
  当 LINQ 无法表达复杂查询时，可以使用原始 SQL 查询。

  var customers = context.Customers
                         .FromSqlRaw("SELECT * FROM Customers WHERE IsActive = 1")
                         .ToList();
  

  或者使用参数化查询以防止 SQL 注入：

  var name = "Alice";
  var customers = context.Customers
                         .FromSqlInterpolated($"SELECT * FROM Customers WHERE Name = {name}")
                         .ToList();
  

8. 如何在 EF Core 中实现分页（Paging）？

• 解题思路： 解释分页的需求和常见方法，展示如何使用 Skip 和 Take 实现分页。
• 解答示例：
  分页用于限制一次查询返回的数据量，常用于展示大量数据的场景。

  int pageNumber = 2;
  int pageSize = 10;
  var pagedCustomers = context.Customers
                               .OrderBy(c => c.Name)
                               .Skip((pageNumber - 1) * pageSize)
                               .Take(pageSize)
                               .ToList();
  

9. 如何在 EF Core 中使用延展方法（Extension Methods）来优化代码？

• 解题思路： 解释延展方法的作用及其在 EF Core 中的应用，提供示例代码。
• 解答示例：
  延展方法可以封装常用的查询逻辑，提高代码复用性和可读性。

  public static class CustomerExtensions
  {
      public static IQueryable<Customer> WhereIsActive(this IQueryable<Customer> query)
      {
          return query.Where(c => c.IsActive);
      }
  }
  
  // 使用延展方法
  var activeCustomers = context.Customers
                               .WhereIsActive()
                               .ToList();
  

10. 如何在 EF Core 中配置复合主键（Composite Keys）？

• 解题思路： 解释复合主键的概念及其配置方法，展示在模型中定义复合主键的示例。
• 解答示例：
  复合主键由多个列组成，需在 OnModelCreating 方法中使用 Fluent API 进行配置。

  public class OrderItem
  {
      public int OrderId { get; set; }
      public int ProductId { get; set; }
      public int Quantity { get; set; }
      
      public Order Order { get; set; }
      public Product Product { get; set; }
  }
  
  protected override void OnModelCreating(ModelBuilder modelBuilder)
  {
      modelBuilder.Entity<OrderItem>()
                  .HasKey(oi => new { oi.OrderId, oi.ProductId });
  
      modelBuilder.Entity<OrderItem>()
                  .HasOne(oi => oi.Order)
                  .WithMany(o => o.OrderItems)
                  .HasForeignKey(oi => oi.OrderId);
  
      modelBuilder.Entity<OrderItem>()
                  .HasOne(oi => oi.Product)
                  .WithMany(p => p.OrderItems)
                  .HasForeignKey(oi => oi.ProductId);
  }
  

---

四、高级级别

聚焦于复杂和实际应用场景中的 EF Core 使用，包括并发控制、复杂查询优化、多租户架构、跨数据库操作等。考察对 EF Core 深入细节的理解，还评估在高并发、高数据量、多租户等复杂应用场景中的实践经验。

1. EF Core 中的乐观并发控制（Optimistic Concurrency Control）与悲观并发控制（Pessimistic Concurrency Control）的区别是什么？如何实现它们？

• 解题思路： 详细解释两种并发控制方法的区别，并提供实现方法。讨论它们各自的使用场景和优缺点。
• 解答示例：
  • 乐观并发控制： 假设冲突极少发生，通过在实体中添加并发标记（如 RowVersion），在更新数据时检查数据是否被修改过。示例代码：

    public class Product
    {
        public int Id { get; set; }
        public string Name { get; set; }
    
        [Timestamp]
        public byte[] RowVersion { get; set; }
    }
    // 更新时捕捉冲突异常
    try
    {
        context.SaveChanges();
    }
    catch (DbUpdateConcurrencyException)
    {
        // 处理冲突
    }
    

  • 悲观并发控制： 假设冲突可能频繁发生，通过在查询或更新时锁定数据行防止并发修改。示例代码：

    var product = context.Products
                         .FromSqlRaw("SELECT * FROM Products WITH (UPDLOCK) WHERE Id = {0}", productId)
                         .FirstOrDefault();
    

2. 如何在 EF Core 中使用无跟踪查询（No-Tracking Query），以及它们在性能优化中的作用？

• 解题思路： 解释无跟踪查询的概念及其优缺点，说明使用场景并提供实际应用示例。
• 解答示例：
  无跟踪查询用于查询不需要进行更新的数据，它减少了上下文的内存开销和处理时间，适合只读操作。

  var customers = context.Customers
                         .AsNoTracking()
                         .ToList();
  

  无跟踪查询在大型数据集的读取操作中可以显著提高性能。

3. 如何在 EF Core 中自定义迁移（Migration）脚本？

• 解题思路： 讨论迁移的基本原理，并展示如何在迁移脚本中手动调整或添加自定义 SQL。
• 解答示例：
  自定义迁移脚本可以在自动生成的迁移代码中手动编辑，或者通过 HasAnnotation 等方法调整迁移行为。

  migrationBuilder.Sql("ALTER TABLE Products ADD COLUMN Description NVARCHAR(MAX);");
  

  可以在 Up 和 Down 方法中手动添加自定义 SQL 脚本以适应特定需求。

4. 如何在 EF Core 中处理数据种子（Data Seeding），以及如何避免在多环境部署中引发问题？

• 解题思路： 解释数据种子的概念，并讨论如何在模型配置中实现数据种子。说明如何在不同环境中处理数据种子冲突。
• 解答示例：
  EF Core 提供了一种在模型中定义数据种子的方式：

  modelBuilder.Entity<Product>().HasData(
      new Product { Id = 1, Name = "Sample Product", Price = 9.99m }
  );
  

  在多环境部署时，确保数据种子逻辑的幂等性（即重复运行不会产生副作用），或者使用环境变量来控制数据种子的应用。

5. 如何在 EF Core 中优化查询性能以减少 N+1 查询问题？

• 解题思路： 解释 N+1 查询问题的原因及其影响，并展示如何使用 Include、ThenInclude 等方法优化查询。
• 解答示例：
  N+1 查询问题通常发生在延迟加载的场景中，可以通过显式地使用 Include 来避免。

  var customers = context.Customers
                         .Include(c => c.Orders)
                         .ThenInclude(o => o.OrderItems)
                         .ToList();
  

  通过这种方式，将所有相关数据在一次查询中加载，避免每次迭代时都触发新的查询。

6. EF Core 中如何实现数据库连接池化（Connection Pooling），以及它在高并发场景中的作用？

• 解题思路： 讨论数据库连接池化的概念及其重要性，展示如何在 EF Core 中启用和配置连接池化。
• 解答示例：
  数据库连接池化能够重用数据库连接，减少连接建立的开销，从而提高应用的吞吐量。
  在配置数据库连接字符串时，可以通过设置 Max Pool Size 和 Min Pool Size 来控制连接池：

  var optionsBuilder = new DbContextOptionsBuilder<MyDbContext>();
  optionsBuilder.UseSqlServer("Server=myServer;Database=myDb;User Id=myUser;Password=myPass;Max Pool Size=100;Min Pool Size=5;");
  

7. 如何在 EF Core 中处理复杂类型的映射，如值对象（Value Objects）和嵌套对象（Nested Objects）？

• 解题思路： 解释值对象和嵌套对象的概念，并展示如何在 EF Core 中进行适当的映射。
• 解答示例：
  值对象是一种无身份的对象，通常用来封装多个字段。例如，Address 可以作为 Customer 的值对象：

  public class Address
  {
      public string Street { get; set; }
      public string City { get; set; }
      public string PostalCode { get; set; }
  }
  
  public class Customer
  {
      public int Id { get; set; }
      public string Name { get; set; }
      public Address Address { get; set; }
  }
  
  protected override void OnModelCreating(ModelBuilder modelBuilder)
  {
      modelBuilder.Entity<Customer>().OwnsOne(c => c.Address);
  }
  

8. 如何在 EF Core 中进行复杂查询的优化，如在大数据集上执行分组、联接和聚合操作？

• 解题思路： 讨论复杂查询操作在大数据集上的挑战，并展示如何利用 EF Core 提供的功能进行优化，如批量处理和索引使用。
• 解答示例：
  复杂查询如 GroupBy 和 Join 可能会影响性能，适当的索引和查询优化可以显著提高性能。

  var result = context.Orders
                      .Where(o => o.Status == "Completed")
                      .GroupBy(o => o.CustomerId)
                      .Select(g => new { CustomerId = g.Key, Total = g.Sum(o => o.Amount) })
                      .ToList();
  

  使用数据库索引来优化上述查询的性能。

9. 如何在 EF Core 中处理跨数据库操作（跨多个数据库执行查询或事务）？

• 解题思路： 解释跨数据库操作的挑战，并展示如何在 EF Core 中使用 DbContext 管理多个数据库连接。
• 解答示例：
  处理跨数据库操作通常涉及到多个 DbContext 实例，并且需要通过事务来保证数据一致性。

  using var context1 = new FirstDbContext();
  using var context2 = new SecondDbContext();
  
  using var transaction1 = context1.Database.BeginTransaction();
  using var transaction2 = context2.Database.BeginTransaction();
  
  try
  {
      context1.DoSomeOperation();
      context2.DoAnotherOperation();
  
      transaction1.Commit();
      transaction2.Commit();
  }
  catch
  {
      transaction1.Rollback();
      transaction2.Rollback();
  }
  

  在这种场景下，也可以考虑使用分布式事务处理机制（如 Microsoft 的 DTC）。

10. 如何在 EF Core 中有效地处理多租户架构（Multi-Tenant Architecture）？

• 解题思路： 解释多租户架构的基本概念，讨论其实现策略，并展示如何在 EF Core 中进行配置和管理。
• 解答示例：
  多租户架构通常有两种实现方式：单数据库多架构（Shared Schema）和多数据库（Per Tenant）。
  在单数据库多架构中，可以使用全局查询过滤器来隔离不同租户的数据：

  protected override void OnModelCreating(ModelBuilder modelBuilder)
  {
      modelBuilder.Entity<Order>()
                  .HasQueryFilter(o => o.TenantId == _currentTenantId);
  }
  

  也可以通过动态设置 DbContext 的连接字符串来支持多数据库方案：

  protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
  {
      optionsBuilder.UseSqlServer(GetConnectionStringForTenant(_currentTenantId));
  }
  
  

五、总结

通过这份 EF Core 面试指南，能够全面、系统地评估对 EF Core 的掌握程度，从基础知识到高级应用，涵盖了 EF Core 在实际开发中的核心技术点。无论是初学者还是经验丰富的开发者，这份指南都能帮助展现出自己的技术深度和解决问题的能力。