掌握EF Core：全方位面试指南，助你从初级到高级轻松晋级

dotnet研习社

于 2024-08-31 19:02:02 发布

阅读量668

点赞数 23

分类专栏： C#开发基础文章标签：面试 c# EFCore EFCore面试指南

本文链接：https://blog.csdn.net/houbincarson/article/details/141755753

版权

C#开发基础专栏收录该内容

28 篇文章 0 订阅

订阅专栏

在这里插入图片描述

一、前言

这份指南旨在帮助你为主要考察 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 在实际开发中的核心技术点。无论是初学者还是经验丰富的开发者，这份指南都能帮助展现出自己的技术深度和解决问题的能力。

在这里插入图片描述

dotnet研习社

关注

23
点赞
踩
7

收藏

觉得还不错? 一键收藏
打赏
0
评论
掌握EF Core：全方位面试指南，助你从初级到高级轻松晋级

这份指南旨在帮助你为主要考察 Entity Framework Core (EF Core) 的面试做好准备，内容涵盖基础、中级和高级三个不同经验级别。每个级别包括10个高频面试题，附有解题思路和详细的解答示例。解释 EF Core 是什么，包括它的用途和基本功能。Entity Framework Core（简称 EF Core）是一个开源、轻量级、可扩展且跨平台的版本，它是 .NET 的流行对象关系映射（ORM）框架 Entity Framework 的现代化版本。
复制链接

扫一扫