掌握Entity Framework Core：SoftUni完整课程教程

本文还有配套的精品资源，点击获取

简介：本课程资源专注于.NET框架中的Entity Framework Core ORM工具，使开发人员能够用C#操作数据库，减少SQL代码编写。涵盖了从基础概念到高级主题的各个方面，包括实体配置、数据库迁移、查询优化和代码优先开发等。同时，也介绍了T-SQL以帮助开发者更好地理解和调试数据库操作。通过实战练习和教程文档，学员将深入理解EF Core，并能有效地应用于实际项目。

1. Entity Framework Core概述

Entity Framework Core（EF Core）是流行的.NET对象关系映射（ORM）框架的跨平台版本。它为开发者提供了一种便捷的方式来操作数据库，无需编写大量SQL语句。EF Core支持多种数据库提供者，并允许开发者在不同的数据库系统之间轻松切换。

1.1 ORM框架的优势

使用Entity Framework Core可以极大地提高开发效率，因为它抽象了底层数据库细节，开发者只需关注于业务逻辑层面。EF Core还提供了强大的查询功能，通过LINQ（语言集成查询）可以编写类型安全的查询语句。

1.2 EF Core的架构

Entity Framework Core的核心架构基于几个关键组件： DbContext 、 DbSet 、 Entity 和 Entity Configuration 。 DbContext 是与数据库交互的中心，它负责追踪实体的状态和管理数据的持久化。 DbSet 代表了特定实体集合的数据库视图。实体类映射到数据库表，并使用属性装饰器来配置映射细节。 Entity Configuration 则允许开发者通过代码或Fluent API来配置实体和关系映射。

通过这个架构，EF Core可以轻松实现数据的CRUD操作，并能有效地处理复杂的数据关系和查询需求。EF Core还支持数据库迁移，这是一个强大的版本控制机制，用于跟踪和应用模型到数据库的更改。

2. 实体（Entities）的概念与应用

2.1 实体的定义与组成

2.1.1 实体类的作用与要求

在 Entity Framework Core 中，实体类是用于表示数据模型的普通类。每个实体类对应数据库中的一个表，实体的属性映射为表的列。为了确保实体类能被框架正确识别和操作，它需要满足一些基本要求：

• 实体类通常包含一个或多个属性，这些属性映射到数据库表的列。
• 实体类应该有一个主键属性，标识每条记录的唯一性。
• 实体类可以包含导航属性，用于表示实体之间的关系。

此外，实体类可以使用数据注解或Fluent API进行配置，以满足更复杂的场景需求。

2.1.2 实体属性的数据类型映射

数据类型映射是指将实体属性的 .NET 类型转换为数据库中相应列的数据类型。EF Core 会尝试自动处理这些映射，但有时需要手动进行配置，以符合特定数据库的要求。以下是一些常见的数据类型映射示例：

• int 、 long ：映射到 SQL Server 的 INT 、 BIGINT 。
• string ：映射到 SQL Server 的 VARCHAR 、 NVARCHAR 或 TEXT ，取决于字符串的最大长度。
• bool ：映射到 SQL Server 的 BIT 。
• DateTime 、 DateTimeOffset ：映射到 SQL Server 的 DATETIME 、 DATETIME2 或 DATETIMEOFFSET 。
• decimal 、 float 、 double ：映射到 SQL Server 的 DECIMAL 、 FLOAT 、 REAL 。

请注意，不同的数据库供应商可能有不同的数据类型。EF Core 为常用数据库类型提供了内置支持，但有时候可能需要进一步配置以确保正确映射。

2.2 实体关系的建立

2.2.1 一对多与多对多关系的定义

在数据模型中，实体之间的关系是至关重要的。实体关系在 EF Core 中可以通过一对多（1: N）或多对多（M: N）关系来表示。定义这些关系时，通常需要在实体类中使用导航属性：

• 一对多关系可以通过在父实体类中定义一个集合属性，以及在子实体类中定义一个指向父实体的引用属性来表示。
• 多对多关系稍微复杂一些，因为 EF Core 不直接支持多对多映射，需要通过一个中间表来实现。

例如，一对多关系的代码如下：

public class Department
{
    public int DepartmentId { get; set; }
    public string Name { get; set; }
    public List<Employee> Employees { get; set; } // 一对多关系导航属性
}

public class Employee
{
    public int EmployeeId { get; set; }
    public string Name { get; set; }
    public int DepartmentId { get; set; } // 外键属性
    public Department Department { get; set; } // 多对一关系导航属性
}

在多对多关系中，你需要创建一个额外的连接类，如下所示：

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

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

public class CourseStudent
{
    public int CourseId { get; set; }
    public Course Course { get; set; }
    public int StudentId { get; set; }
    public Student Student { get; set; }
}

2.2.2 实体集合与引用的配置

配置实体集合与引用主要是通过 Fluent API 实现的，它允许更详细的配置。例如，配置一对多关系和多对多关系的连接表：

modelBuilder.Entity<Department>()
    .HasMany(d => d.Employees)
    .WithOne(e => e.Department)
    .HasForeignKey(e => e.DepartmentId);

modelBuilder.Entity<CourseStudent>()
    .HasKey(cs => new { cs.CourseId, cs.StudentId });
modelBuilder.Entity<CourseStudent>()
    .HasOne(cs => cs.Course)
    .WithMany(c => c.CourseStudents)
    .HasForeignKey(cs => cs.CourseId);
modelBuilder.Entity<CourseStudent>()
    .HasOne(cs => cs.Student)
    .WithMany(s => s.CourseStudents)
    .HasForeignKey(cs => cs.StudentId);

请注意，对于复杂的实体关系配置，了解模型构建的生命周期和配置方法是至关重要的，这有助于确保数据模型的准确性和应用的性能。

代码逻辑解读：

• HasMany 和 WithOne 方法用于定义一对多关系。 HasMany 指明父实体中的集合， WithOne 指明子实体中的引用。
• HasForeignKey 方法设置外键，指向数据库中的对应列。
• HasKey 方法在多对多关系中定义连接表的复合主键。
• 在多对多关系配置中， HasOne 和 WithMany 方法用于表示连接表中的两个多对一关系，同时通过 HasForeignKey 方法指明两个外键属性。

3. 上下文（DbContext）的使用

3.1 DbContext的角色与配置

3.1.1 DbContext的作用与生命周期

DbContext 是 Entity Framework Core (EF Core) 中最为关键的类，它代表了数据库操作的会话。 DbContext 通过跟踪和处理实体的变化，负责将这些变化同步到数据库中。此外， DbContext 还能够作为仓储模式中数据访问层的核心，实现数据的查询、添加、删除和修改等操作。

DbContext 的生命周期通常与请求的生命周期相一致，也就是说，它通常在请求开始时创建，在请求结束时释放。在一个 Web 应用程序中，这意味着 DbContext 会在每个请求处理过程中创建，并在请求结束时被垃圾回收器回收。为了更好地管理 DbContext 的生命周期，可以使用依赖注入框架（如 *** Core内置的依赖注入容器）来管理其创建和释放。

3.1.2 数据库连接与配置管理

DbContext 通过依赖的 DbContextOptions 对象来配置数据库连接信息，如数据库提供者、连接字符串等。EF Core 支持多种数据库提供者，如 SQL Server、PostgreSQL 等，开发者需要根据实际使用的数据库选择合适的提供者并进行配置。

在 *** Core 应用中，可以在 Startup.cs 文件的 ConfigureServices 方法中通过 AddDbContext 或 AddDbContextPool 方法注册 DbContext 。 AddDbContextPool 通过使用对象池技术来重用 DbContext 实例，可以减少创建和释放实例的开销，提高性能。

下面是一个在 *** Core 应用中配置 DbContext 的示例：

public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<MyDbContext>(options =>
        options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
}

在此代码中， UseSqlServer 方法用于指定 SQL Server 数据库提供者，并通过 GetConnectionString 方法从配置文件中读取连接字符串。

3.2 数据操作与变更跟踪

3.2.1 数据的增删改查操作

在 EF Core 中，数据的增删改查操作非常直观。以下是一些基本操作的示例代码。

• 添加数据

using (var context = new MyDbContext())
{
    var newEntity = new Entity { ... };
    context.Entities.Add(newEntity);
    context.SaveChanges();
}

• 删除数据

using (var context = new MyDbContext())
{
    var entityToDelete = context.Entities.Find(1); // 假设我们要删除的实体主键为1
    context.Entities.Remove(entityToDelete);
    context.SaveChanges();
}

• 更新数据

using (var context = new MyDbContext())
{
    var entityToUpdate = context.Entities.Find(1); // 获取要更新的实体
    entityToUpdate.Property = newValue;
    context.SaveChanges();
}

• 查询数据

using (var context = new MyDbContext())
{
    var entities = context.Entities.ToList(); // 查询所有实体
}

3.2.2 变更跟踪的工作原理与使用场景

EF Core 使用变更跟踪器来监视实体的状态变化，并在调用 SaveChanges() 方法时同步这些变更到数据库。EF Core 中的实体可以通过三种状态来表示它们在变更跟踪器中的状态： Unchanged （未改变）、 Added （已添加）、 Modified （已修改）和 Deleted （已删除）。当 SaveChanges() 被调用时，EF Core 会检查这些状态，并生成相应的 SQL 命令来更新数据库。

变更跟踪在处理复杂事务时非常重要，它可以确保事务的一致性和数据的一致性。在涉及多个实体变更的情况下，如果某项操作失败，可以通过回滚事务来取消所有的变更，保证数据完整性。

在某些性能敏感的应用场景下，开发者可能需要绕过 EF Core 的自动变更跟踪机制，通过编写自定义的 SQL 语句或者使用 Dapper 等轻量级 ORM 来提高性能。

变更跟踪的详细信息通常对于开发者是透明的，但在处理异常或调试时了解其工作原理会非常有帮助。需要注意的是，变更跟踪是在内存中进行的，所以它不会影响到数据库中的实际数据，除非显式调用 SaveChanges() 方法。

4. 数据库迁移（Database Migrations）实践

在现代的软件开发中，数据库的版本控制和数据结构的变更管理显得尤为重要。Entity Framework Core 提供了强大的数据库迁移功能，允许开发者通过一系列命令来同步实体类的改变与数据库模式。本章将详细介绍数据库迁移的概念、步骤，以及在迁移过程中可能出现的数据操作问题和解决方案。

4.1 迁移的概念与步骤

4.1.1 迁移的作用与好处

在传统的数据库管理中，手动修改数据库结构是常见的做法。然而，这种方法在团队协作和应用迭代过程中，会带来版本控制混乱、数据丢失风险以及同步问题。数据库迁移的引入，解决了这些难题。

迁移允许开发者以代码的形式记录数据库结构的变更，将这些变更作为应用程序的一部分进行版本控制。其好处具体包括：

• 版本控制兼容性 ：迁移文件作为项目的一部分，可以被版本控制系统（如 Git）跟踪，便于团队协作。
• 自动化部署 ：迁移可以通过命令行工具自动化执行，减少了手动操作的错误。
• 历史记录与回滚 ：迁移记录了数据库结构的变更历史，一旦出现问题，可以通过回滚操作恢复到之前的版本。

4.1.2 迁移的创建与应用流程

数据库迁移的创建与应用涉及几个核心步骤，包括初始化迁移、更新数据库模式和维护迁移历史。

初始化迁移 ：初次使用迁移时，必须通过命令行创建一个初始迁移，它将记录当前数据库的结构。

Add-Migration InitialCreate -Context YourDbContext

此命令会生成一个迁移文件，其中包括了创建数据库所需的所有结构定义。

更新数据库模式 ：通过执行迁移命令，将迁移应用到数据库中，完成数据库结构的更新。

Update-Database -Context YourDbContext

此命令将会根据现有的迁移文件和数据库的当前状态，执行必要的数据库操作来同步变更。

维护迁移历史 ：随着时间的推移，应用程序可能会拥有多个迁移文件。数据库迁移历史记录了所有迁移的执行情况，以确保迁移操作的正确顺序和完整性。

4.2 迁移中的数据操作

4.2.1 数据丢失问题的处理

在进行数据库迁移时，可能会遇到数据丢失的问题，尤其是在执行降级（downgrade）迁移时。为防止数据丢失，开发者需采取预防措施，包括但不限于：

• 备份数据库 ：在执行迁移之前，对数据库进行完整备份是一个良好的实践，以防止数据丢失无法恢复。
• 小心使用数据丢失的迁移操作 ：有些迁移操作可能导致数据丢失，比如删除列或重命名表。在这些操作中，应当谨慎处理，如可能，优先考虑无损迁移。

4.2.2 复杂数据操作的迁移策略

对于包含复杂数据操作（如大量数据迁移、复杂的数据转换逻辑等）的迁移，需要特别的策略来确保操作的顺畅和数据的一致性。以下是一些常用的策略：

• 分批处理 ：对于大量数据的迁移，可以采用分批处理的方式来减少单次操作对数据库性能的影响。
• 使用临时表 ：在迁移过程中，可能需要借助临时表来辅助复杂的数据转换。
• 事务管理 ：确保迁移操作在事务的保护下执行，一旦出现异常，能够回滚到操作之前的状态。

using (var transaction = context.Database.BeginTransaction())
{
    try
    {
        // 迁移操作代码

        ***mit();
    }
    catch (Exception)
    {
        transaction.Rollback();
        throw;
    }
}

以上代码展示了如何在迁移操作中使用事务管理，以保证操作的一致性和可靠性。

总之，数据库迁移是 Entity Framework Core 中一个重要的概念，它能够帮助开发者管理数据库模式的变更，并通过自动化的方式提升开发效率和减少人为错误。本章节仅对迁移的概念与步骤、迁移中的数据操作做了详细介绍，希望对理解 Entity Framework Core 的数据库迁移功能有所助益。下一章将深入探讨关系映射的概念及其在 EF Core 中的应用。

5. 关系映射（Relationship Mapping）

5.1 关系映射的类型与配置

5.1.1 主键与外键的映射方法

在Entity Framework Core中，主键（Primary Key）和外键（Foreign Key）是定义实体间关系的重要部分。主键用于唯一标识实体中的每个记录，而外键则用于建立实体间的关联。关系映射通常是通过数据注解（Data Annotations）或Fluent API在模型构建时完成。

使用数据注解，可以在实体类中指定主键和外键，例如：

public class Blog
{
    [Key] // 指定主键
    public int BlogId { get; set; }
    public string Url { get; set; }

    // 外键属性
    [ForeignKey("BlogId")]
    public virtual ICollection<Post> Posts { get; set; }
}

public class Post
{
    [Key]
    public int PostId { get; set; }
    public string Title { get; set; }

    public int BlogId { get; set; } // 外键字段
    [ForeignKey("BlogId")]
    public virtual Blog Blog { get; set; }
}

使用Fluent API，可以在DbContext的 OnModelCreating 方法中配置，这种方式提供了更大的灵活性：

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Post>()
        .HasOne(p => p.Blog)
        .WithMany(b => b.Posts) // 一对多关系配置
        .HasForeignKey(p => p.BlogId); // 指定外键
}

5.1.2 依赖关系与导航属性的配置

依赖关系通常指实体间的引用关系，而导航属性则允许从一个实体导航到另一个实体。配置这些关系可以使得数据操作更加直观方便。

在一对多关系中，一个父实体可以包含多个子实体的集合，而一个子实体只有一个父实体：

public class Author
{
    public int AuthorId { get; set; }
    public string Name { get; set; }

    // 导航属性
    public virtual ICollection<Book> Books { get; set; }
}

public class Book
{
    public int BookId { get; set; }
    public string Title { get; set; }

    public int AuthorId { get; set; } // 外键字段
    [ForeignKey("AuthorId")]
    public virtual Author Author { get; set; }
}

在多对多关系中，实体间可以通过一个中间表进行关联，需要配置两个方向的导航属性和外键：

public class Student
{
    public int StudentId { get; set; }
    public string StudentName { get; set; }

    // 多对多关系配置
    public virtual ICollection<Course> Courses { get; set; }
}

public class Course
{
    public int CourseId { get; set; }
    public string CourseName { get; set; }

    public virtual ICollection<Student> Students { get; set; }
}

// 中间表实体
public class StudentCourse
{
    public int StudentId { get; set; }
    public Student Student { get; set; }

    public int CourseId { get; set; }
    public Course Course { get; set; }
}

5.2 关系映射的高级配置

5.2.1 索引的创建与配置

在数据库中，索引是提高查询性能的重要工具，Entity Framework Core提供了通过Fluent API配置索引的能力。索引可以在一个或多个列上创建，这有助于优化基于这些列的查询。

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Author>()
        .HasIndex(a => a.Name) // 在Name列上创建索引
        .HasDatabaseName("idx_author_name") // 指定索引名称
        .IsUnique(); // 确保Name列的唯一性
}

5.2.2 过滤器与数据完整性规则

过滤器（Filters）是在Entity Framework Core中定义跨表数据完整性规则的一种方式。使用过滤器，可以实现类似于数据库视图的逻辑，从而确保数据的一致性。

假设有一个需求，当 Post 实体被删除时，相关的 Comment 实体也需要被自动删除，可以通过添加一个删除触发器的方式来实现：

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Comment>()
        .HasOne(c => c.Post) // 指定Post是Comment的父实体
        .WithMany(p => ***ments) // 指定一对多关系
        .OnDelete(DeleteBehavior.Cascade); // 指定删除行为为级联删除
}

过滤器也可以用来在应用层实现数据的软删除（逻辑删除），而不是直接从数据库中删除记录：

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Post>()
        .HasQueryFilter(p => !p.IsDeleted); // 配置查询过滤器
}

这样，当获取 Post 数据时，自动应用查询过滤器，只返回那些 IsDeleted 为 false 的记录。

6. 查询（Queries）与LINQ的运用

6.1 查询基础知识

6.1.1 LINQ的作用与查询表达式

LINQ（Language Integrated Query）是.NET框架中的一项强大功能，它允许开发者使用统一的查询语法来操作不同种类的数据源，包括内存中的对象集合、SQL Server数据库、XML文档等。LINQ的核心优势在于它能够将查询操作以声明式的方式嵌入到.NET语言中，这样可以在编译时期检查查询表达式的正确性，从而降低运行时的错误。

在Entity Framework Core中，LINQ查询被转换成SQL语句，然后执行在数据库服务器上。这意味着开发者可以使用自己熟悉的.NET语言编写查询，而无需深入SQL语言的细节。这种查询模式特别适合那些不想深入学习SQL，但需要操作数据库的开发者。

6.1.2 查询运算符的使用方法

LINQ查询表达式通常由一系列查询运算符组成，这些运算符可以对数据进行筛选、排序、分组、聚合等操作。每个运算符都对应一个方法，例如 Where 用于筛选， Select 用于映射， OrderBy 用于排序等。

以下是一个简单的示例，演示了如何使用LINQ的几个基本运算符来查询学生信息：

using System;
using System.Linq;
using Microsoft.EntityFrameworkCore;
using System.Collections.Generic;

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

class Program
{
    static void Main(string[] args)
    {
        using var context = new SchoolContext();
        var query = context.Students
            .Where(s => s.Age > 18)  // 筛选年龄大于18岁的学生
            .OrderBy(s => s.Name)    // 按姓名排序
            .Select(s => new { s.Name, s.Age }); // 映射为匿名类型

        foreach(var student in query)
        {
            Console.WriteLine($"Name: {student.Name}, Age: {student.Age}");
        }
    }
}

public class SchoolContext : DbContext
{
    public DbSet<Student> Students { get; set; }

    // 配置数据库连接等...
}

在上述代码中， Where 、 OrderBy 和 Select 方法链式调用构成了一个查询表达式。它首先筛选出年龄超过18岁的学生，然后按姓名进行排序，并将结果映射为一个新的匿名对象，最后通过遍历输出每个学生的名字和年龄。

6.2 高级查询技巧

6.2.1 分组、排序与聚合函数的运用

LINQ还提供了分组（ GroupBy ）、排序（ OrderByDescending ）以及聚合函数（如 Count , Sum , Average 等）来支持更复杂的数据操作。这些高级功能在处理数据报告和分析时非常有用。

假设我们希望按照学生的年龄对他们进行分组，并计算每组的人数，可以使用以下查询：

using System;
using System.Linq;
using Microsoft.EntityFrameworkCore;

class Program
{
    static void Main(string[] args)
    {
        using var context = new SchoolContext();
        var query = context.Students
            .GroupBy(s => s.Age)
            .Select(g => new
            {
                Age = g.Key,
                Count = g.Count()
            });

        foreach (var group in query)
        {
            Console.WriteLine($"Age: {group.Age}, Count: {group.Count}");
        }
    }
}

public class SchoolContext : DbContext
{
    public DbSet<Student> Students { get; set; }

    // 配置数据库连接等...
}

在这个示例中， GroupBy 方法将学生按年龄进行分组，每组都包含相同年龄的所有学生。 Select 方法用于选择每个分组的键（年龄）以及该分组中学生的数量。最后，通过遍历输出了每个年龄组及其人数。

6.2.2 动态查询与性能优化

在实际应用中，动态查询需求非常常见，开发者可能需要根据用户的输入或某些运行时条件来构建查询。虽然LINQ提供了强大的灵活性，但不当的查询编写可能会导致性能问题。

为了编写高效的LINQ查询，开发者应该遵循以下几点最佳实践：

1. 尽量在内存中使用LINQ进行数据操作，避免不必要的数据库往返。
2. 使用延迟加载（Lazy Loading）或立即加载（Eager Loading）来加载相关实体，避免N+1查询问题。
3. 对于复杂的查询，可以在数据库层面进行分页和排序操作，减少数据传输量。
4. 使用 AsNoTracking 方法来提高只读查询的性能，因为它避免了EF Core追踪返回的实体实例的状态。

using System;
using System.Linq;
using Microsoft.EntityFrameworkCore;

class Program
{
    static void Main(string[] args)
    {
        using var context = new SchoolContext();
        int age = 20; // 假设这是动态输入的年龄
        var query = context.Students
            .AsNoTracking() // 提高性能，因为我们不需要更改跟踪
            .Where(s => s.Age == age)
            .OrderBy(s => s.Name)
            .Skip(10) // 跳过前10条数据
            .Take(5); // 仅获取接下来的5条数据

        foreach (var student in query)
        {
            Console.WriteLine($"{student.Name}, Age: {student.Age}");
        }
    }
}

public class SchoolContext : DbContext
{
    public DbSet<Student> Students { get; set; }

    // 配置数据库连接等...
}

在上面的代码中， Skip 和 Take 方法被用来进行数据分页，这样就可以高效地从数据库获取特定页的数据。通过使用 AsNoTracking ，我们告诉EF Core这个查询仅用于读取数据，无需追踪返回对象的状态变化，从而提高了性能。

7. 仓储模式（Repository Pattern）实现

仓储模式是一种常用的软件架构模式，它在业务逻辑层（Service Layer）和数据访问层（Data Access Layer）之间提供了一个抽象层。通过使用仓储模式，我们可以实现业务逻辑的清晰分离和数据访问代码的复用。

7.1 仓储模式的理解与设计

7.1.1 仓储模式的定义与目标

仓储模式的目的是将数据访问代码从业务逻辑中分离出来，使得业务逻辑不依赖于具体的数据访问技术。仓储模式定义了一组用于访问持久化数据的方法，这些方法通常被定义在仓储接口中，具体的实现则依赖于所使用的数据访问技术。

仓储模式的目标包括：

• 解耦业务逻辑与数据访问代码 ：这样，当数据访问技术需要变更时，业务逻辑层不受影响。
• 提供统一的数据访问接口 ：定义一系列标准操作方法，业务逻辑层通过这些方法与数据进行交互。
• 方便单元测试 ：通过模拟仓储接口，可以在不依赖数据库的情况下测试业务逻辑。

7.1.2 仓储接口的设计原则

设计仓储接口时，通常遵循以下原则：

• 领域驱动设计 ：仓储接口应该围绕业务实体进行设计，每个实体或实体的集合应该有一个对应的仓储。
• CRUD操作 ：基础的仓储接口应该包含创建(Create)、读取(Read)、更新(Update)和删除(Delete)的基本操作。
• 查询操作 ：虽然LINQ查询通常由业务逻辑层直接使用，但仓储接口也可以定义一些通用的查询方法，如按属性查询等。
• 事务管理 ：如果数据访问框架不直接支持事务管理，仓储接口应提供相应的方法来管理事务。

7.2 仓储模式的实现与应用

7.2.1 具体仓储类的实现

具体实现仓储类时，可以使用依赖注入来实现对DbContext的依赖，这样可以在单元测试中轻松替换为模拟对象。以下是一个简单的产品仓储类的实现示例：

public class ProductRepository : IProductRepository
{
    private readonly ApplicationDbContext _context;

    public ProductRepository(ApplicationDbContext context)
    {
        _context = context;
    }

    public async Task<Product> GetByIdAsync(int id)
    {
        return await _context.Products.FindAsync(id);
    }

    public async Task<IEnumerable<Product>> ListAllAsync()
    {
        return await _context.Products.ToListAsync();
    }

    public async Task CreateAsync(Product product)
    {
        _context.Products.Add(product);
        await _context.SaveChangesAsync();
    }

    // 其他方法的实现...
}

7.2.2 仓储模式在业务逻辑中的运用实例

仓储模式在业务逻辑层中的运用通常体现为依赖仓储接口。以下是一个使用产品仓储接口来实现一个业务逻辑的示例：

public class ProductService
{
    private readonly IProductRepository _productRepository;

    public ProductService(IProductRepository productRepository)
    {
        _productRepository = productRepository;
    }

    public async Task<ProductDetails> GetProductDetailsAsync(int id)
    {
        var product = await _productRepository.GetByIdAsync(id);
        if (product == null)
        {
            throw new Exception("Product not found.");
        }

        // 更多业务逻辑处理...

        return new ProductDetails
        {
            // ...映射产品信息到产品详情
        };
    }

    // 其他业务逻辑方法...
}

在上述例子中， ProductService 类不直接依赖于数据访问技术，而是依赖于抽象的 IProductRepository 接口。这样，即使未来数据访问技术发生了变更， ProductService 也无需更改。同时，仓储模式也使得测试业务逻辑变得容易，因为可以使用仓储接口的模拟对象来模拟数据访问过程。

通过仓储模式的实现和应用，可以显著提高代码的可维护性和可测试性，使得整个应用程序的架构更为清晰和健壮。

本文还有配套的精品资源，点击获取

简介：本课程资源专注于.NET框架中的Entity Framework Core ORM工具，使开发人员能够用C#操作数据库，减少SQL代码编写。涵盖了从基础概念到高级主题的各个方面，包括实体配置、数据库迁移、查询优化和代码优先开发等。同时，也介绍了T-SQL以帮助开发者更好地理解和调试数据库操作。通过实战练习和教程文档，学员将深入理解EF Core，并能有效地应用于实际项目。

本文还有配套的精品资源，点击获取