C# Code First自动化数据库表生成实践指南（附完整源码）

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

简介：C# Code First是Entity Framework中的一种开发模式，让开发者通过编写C#对象模型来自动生成或更新数据库表结构。本文深入剖析了Code First的工作机制及其在.NET开发中的应用，展示了如何通过Entity Framework及ORM工具SqlSugar实现数据库操作。内容包括安装必要的库、定义实体类、配置DbContext、启用迁移、应用迁移以及使用SqlSugar进行数据库操作。文章最后提供了完整的示例代码，帮助读者掌握Code First模式，提高.NET中的数据库编程效率。

1. C# Code First开发模式概述

Code First开发模式的定义和特点

Code First是一种直观且高效的开发方法，允许开发者以编写数据模型为中心，从这些模型自动生成数据库架构。它的核心理念是代码先行，数据库随后，从而使得数据模型的变更直接反映到数据库结构上。这种模式减少了传统数据库开发中的繁琐配置，让开发者能够专注于业务逻辑，提高开发效率。

Code First与其他数据库开发模式的比较

与传统的Database First和Model First开发模式相比，Code First具有以下优势： - 开发效率 : 开发者无需直接操作数据库，专注于编写业务逻辑代码。 - 灵活性 : 数据库结构随着代码的变更而更新，使得适应需求变化更为便捷。 - 数据模型驱动 : 以数据模型为核心，确保数据库结构与应用程序需求紧密对齐。

Code First的优势和使用场景

Code First的优势在于其直观的开发方式和对持续变化的敏捷响应。它特别适合于那些需求频繁变更、数据模型需要频繁调整的项目。同时，对于重视开发效率和代码清晰度的团队，Code First模式可以极大地简化数据库相关的操作，提高项目的整体迭代速度。然而，对于一些成熟的、变更频率较低的项目，传统的开发模式可能更有利于维护和稳定性。

Code First开发模式为现代Web应用的数据库开发提供了一个全新的视角，它使得数据存储的管理与业务逻辑的开发更加紧密地联系起来，为开发者带来了前所未有的便利。在后续章节中，我们将深入探讨如何使用Entity Framework实现Code First开发，以及如何高效地管理数据模型和数据库之间的映射。

2. 使用Entity Framework进行Code First开发

2.1 Entity Framework简介

2.1.1 Entity Framework的基本概念

Entity Framework（简称EF）是.NET平台下的一个对象关系映射（ORM）框架，它允许开发者通过面向对象的方式与关系型数据库交互。EF的核心在于减少开发者直接编写SQL语句的需要，通过抽象数据模型层，开发者可以使用.NET语言操作数据，EF负责将其转换为数据库的SQL命令。

EF的几个关键概念包括：

• Entity Data Model (EDM) : EDM定义了数据的结构，包括实体类型和关系。这些模型通常基于数据库表结构创建。
• Code First : 开发者首先编写实体类代码，然后EF根据这些类生成数据库模式。
• Database First : 开发者从已存在的数据库创建模型，EF映射这些数据库表到实体类。
• Model First : 开发者从模型开始设计，EF将这些模型转换成数据库模式。

2.1.2 Entity Framework的主要组件

Entity Framework主要组件包括：

• DbContext : 用于管理实体类型上下文的类，它包含了一系列的DbSet属性，每个属性对应到一个数据表。DbContext是EF与数据库交互的主要入口。
• DbSet : 表示一个实体集合，可以看做是数据表的映射。
• Entity Object : 实体对象代表数据库中的数据记录，它们被包含在DbSet集合中。
• Object State : 实体对象在EF中的状态（如附加、未附加、删除等）决定EF如何与数据库进行交互。
• Change Tracking : 跟踪实体对象状态的变化，EF使用它来生成正确的SQL命令。

2.2 Entity Framework中的Code First工作原理

2.2.1 Code First的工作流程

Code First工作流程如下：

1. 定义实体类 : 开发者首先编写数据模型的代码。
2. 配置DbContext : 开发者定义一个继承自 DbContext 的类，配置其 DbSet 属性。
3. 初始化数据库 : 当应用程序首次运行时，EF会检查数据库是否存在，如果不存在则根据实体类自动创建数据库。
4. 操作数据 : 开发者使用DbContext进行CRUD操作。
5. 数据库更新 : 当实体类发生变化时，EF提供迁移功能来同步数据库模式。

2.2.2 Code First的配置和约定

Code First使用约定和配置来决定如何处理实体类。约定是基于约定优于配置的理念，EF默认情况下会根据实体类的属性名和类型来推断数据库表结构和列类型。如果约定不能满足特定需求，开发者可以通过数据注解（Data Annotations）或Fluent API进行更精细的配置。

例如，通过数据注解配置外键关系：

public class Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public int AuthorId { get; set; }

    [ForeignKey("AuthorId")]
    public virtual Author Author { get; set; }
}

2.3 设计数据模型和实体类

2.3.1 实体类设计的原则和最佳实践

设计实体类时，以下原则和实践能帮助提高代码的可维护性和性能：

• 单一职责原则 : 每个实体类应该只有一个改变的理由，即它只负责一块数据。
• 避免双向关联 : 尽量使用单向关联来简化关系管理。
• 使用导航属性 : EF中的导航属性允许你容易地遍历和操作实体关系。
• 分离领域逻辑 : 数据模型应该与业务逻辑分离，通常通过服务层或领域驱动设计（DDD）模式实现。

2.3.2 实体类与数据库表映射的策略

实体类与数据库表映射的策略主要包括：

• 数据注解（Data Annotations） : 在实体类的属性上使用注解来配置数据库映射。
• Fluent API : 在DbContext的子类中使用配置方法来精确控制实体和数据库表的关系。

public class BlogContext : DbContext
{
    public DbSet<Blog> Blogs { get; set; }
    public DbSet<Post> Posts { get; set; }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Blog>().ToTable("Blogs");
        modelBuilder.Entity<Post>().ToTable("Posts")
            .HasRequired(p => p.Blog)
            .WithMany(b => b.Posts)
            .HasForeignKey(p => p.BlogId);
    }
}

以上示例代码展示了如何使用Fluent API配置Blog和Post实体类之间的关系。通过 HasRequired 和 WithMany 方法来表示一对多关系，同时指定了外键。

通过本章节的介绍，读者应当对Entity Framework的Code First开发模式有了更深刻的理解。下一章节我们将着手安装Entity Framework和数据库提供程序，并深入了解如何选择合适的数据库提供程序。

3. 安装Entity Framework和数据库提供程序

在开始创建数据驱动的.NET应用程序之前，安装Entity Framework (EF) 和适当的数据库提供程序是至关重要的一步。本章将详细介绍如何安装EF以及如何根据项目需求选择合适的数据库提供程序。

3.1 安装Entity Framework

3.1.1 在.NET项目中安装Entity Framework

安装EF通常涉及NuGet包管理器的使用，这是.NET平台的官方包管理器。安装过程可以手动执行，也可以通过项目配置文件进行自动化安装。以下是手动和自动化安装的步骤。

手动安装

1. 在Visual Studio中打开你的.NET项目。
2. 选择菜单中的“工具” > “NuGet包管理器” > “管理解决方案的NuGet程序包”。
3. 在“浏览”标签页搜索“EntityFramework”。
4. 找到“EntityFramework”包并点击“安装”，根据提示完成安装。

自动化安装

在项目的 csproj 文件中，可以直接添加 PackageReference 节点来自动化安装。例如，如果你想要安装最新版本的EF Core，可以在 <ItemGroup> 部分添加以下代码：

<ItemGroup>
  <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="6.0.0" />
</ItemGroup>

3.1.2 检查安装是否成功的方法

安装完成后，你可以通过以下方式检查EF是否安装成功：

1. 在Visual Studio的“解决方案资源管理器”中，右键点击“引用”或“依赖项”，查找是否有Entity Framework相关的条目。
2. 进入“工具” > “NuGet包管理器” > “包管理器控制台”，输入以下命令并回车执行：

Get-Package -ListAvailable | Where-Object { $_.Name -eq "EntityFramework" }

如果安装成功，上述命令将返回EF相关的包信息。

3.2 选择和安装数据库提供程序

3.2.1 常见的数据库提供程序介绍

数据库提供程序允许EF与不同的数据库管理系统进行通信。每种提供程序都有特定的执行策略，这些策略优化了与相应数据库的交互。以下是一些常见的数据库提供程序：

• Microsoft.EntityFrameworkCore.SqlServer：用于Microsoft SQL Server数据库。
• Pomelo.EntityFrameworkCore.MySql：用于MySQL数据库。
• NServiceBus.Persistence.Sql：用于NServiceBus持久化。

3.2.2 根据需求选择合适的数据库提供程序

选择提供程序时，需要考虑以下几个因素：

• 数据库类型 ：你正在使用的数据库系统是什么？
• 应用需求 ：应用对数据库性能、功能等有无特殊需求？
• 社区和文档 ：提供的支持和文档是否充足？

例如，如果你的项目使用的是SQL Server，那么应该选择 Microsoft.EntityFrameworkCore.SqlServer 。安装过程类似于安装EF本身：

通过NuGet包管理器安装

1. 同样打开NuGet包管理器。
2. 搜索目标数据库提供程序。
3. 选择相应包并安装。

通过包引用安装

在项目的 csproj 文件中，添加如下包引用：

<ItemGroup>
  <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="6.0.0" />
</ItemGroup>

使用适当的数据库提供程序，你的应用程序将能够与后端数据库成功交互，为你的项目带来数据持久化的能力。

4. 定义实体类与数据库表映射

4.1 实体类的基本定义

在Code First开发模式中，实体类是与数据库表一一对应的类。实体类的定义是实现Code First模式的第一步。

4.1.1 实体类的基本属性和方法

实体类通常包含以下基本属性：

• 标识属性（ID） ：每个实体类通常至少需要一个标识属性来唯一识别实体对象，例如主键。
• 其他数据属性 ：用于存储实体对象的数据，通常映射到数据库表的列。

基本方法通常包括：

• 构造函数 ：用于初始化对象。
• 属性的getter和setter ：用于获取和设置属性的值。

下面是一个简单的实体类示例：

public class Product
{
    public int ProductId { get; set; }
    public string ProductName { get; set; }
    public decimal Price { get; set; }
    public int Quantity { get; set; }
}

4.1.2 实体类的继承和接口实现

实体类可以继承自基类，或者实现某些接口以支持特定的功能。例如，实现 IEntity 接口可以表示该类是一个实体类。

public interface IEntity
{
    int Id { get; set; }
}

public class User : IEntity
{
    public int Id { get; set; }
    public string UserName { get; set; }
    public string Email { get; set; }
}

4.2 实体类与数据库表映射的配置

将实体类与数据库表映射通常有几种方式，包括使用Data Annotations和Fluent API。

4.2.1 使用Data Annotations进行配置

Data Annotations提供了属性级别的配置，通过在实体类属性上添加特定的注解来配置映射关系。

using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;

public class Product
{
    [Key]
    public int ProductId { get; set; }

    [Required]
    public string ProductName { get; set; }

    [Column(TypeName = "decimal(18,2)")]
    public decimal Price { get; set; }

    public int Quantity { get; set; }
}

4.2.2 使用Fluent API进行配置

Fluent API提供了更为灵活的配置方式，通过DbContext类的 OnModelCreating 方法进行配置。

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    modelBuilder.Entity<Product>()
        .HasKey(p => p.ProductId);

    modelBuilder.Entity<Product>()
        .Property(p => p.Price)
        .HasPrecision(18, 2);
}

4.3 配置复杂关系映射

在数据库设计中，关系映射是复杂且重要的一部分。Code First模式支持多种类型的关系映射。

4.3.1 一对多关系的配置

使用Data Annotations配置一对多关系：

public class Category
{
    [Key]
    public int CategoryId { get; set; }

    public string CategoryName { get; set; }

    public virtual ICollection<Product> Products { get; set; }
}

public class Product
{
    public int ProductId { get; set; }
    public string ProductName { get; set; }

    [ForeignKey("Category")]
    public int CategoryId { get; set; }
    public virtual Category Category { get; set; }
}

4.3.2 多对多关系的配置

多对多关系稍微复杂，通常需要一个中间表来实现映射。

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

    public virtual ICollection<Enrollment> Enrollments { get; set; }
}

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

    public virtual ICollection<Enrollment> Enrollments { get; set; }
}

public class Enrollment
{
    public int EnrollmentId { get; set; }
    public int CourseId { get; set; }
    public int StudentId { get; set; }

    [ForeignKey("StudentId")]
    public virtual Student Student { get; set; }

    [ForeignKey("CourseId")]
    public virtual Course Course { get; set; }
}

4.3.3 一对一关系的配置

一对一关系的配置相对简单，只需要在两个实体中配置相互的外键。

public class Employee
{
    public int EmployeeId { get; set; }
    public string EmployeeName { get; set; }

    public virtual EmployeeDetails EmployeeDetails { get; set; }
}

public class EmployeeDetails
{
    public int EmployeeDetailId { get; set; }
    public string Address { get; set; }
    public DateTime DateOfBirth { get; set; }

    [ForeignKey("Employee")]
    public int EmployeeId { get; set; }
    public virtual Employee Employee { get; set; }
}

通过上述章节的详细讲解，我们已经了解到实体类的基本定义、如何配置实体类与数据库表的映射关系以及如何处理复杂关系映射。这些内容是Code First开发模式中不可或缺的一部分，对于理解和实施高效的数据模型设计至关重要。在实际开发过程中，开发者应该根据具体的业务需求灵活运用上述技术和方法，实现数据模型和数据库结构的精确映射。

5. 配置DbContext类管理数据库连接

5.1 DbContext类的作用和特点

5.1.1 DbContext类的基本概念

DbContext 是Entity Framework中用于管理数据访问的核心类。它代表应用程序和数据库之间的会话。通过 DbContext ，开发者能够执行各种操作，如查询数据、添加、修改、删除实体等。 DbContext 实例封装了 DbSet 属性，每个 DbSet 对应于数据库中的表，通过 DbSet 可以进行CRUD操作。 DbContext 类还负责管理对象的生命周期和变更跟踪。

5.1.2 DbContext类的主要功能

DbContext 提供了许多功能，包括但不限于： - Entity Tracking（实体跟踪） ：DbContext能够自动跟踪被附加的实体的更改，帮助开发者管理实体状态。 - Change Tracking（变更跟踪） ：自动识别哪些实体被添加、修改或删除，并将这些更改应用到数据库。 - LINQ查询支持 ：利用LINQ，可以编写类型安全的查询来从数据库检索数据。 - 事务处理 ：提供了对数据库事务的高级支持，可以使用 DbContext.Database 属性来操作事务。 - 连接管理 ：自动打开和关闭与数据库的连接。

5.2 配置DbContext类以管理连接

5.2.1 配置连接字符串

配置 DbContext 的第一步通常是设置连接字符串，它告诉 DbContext 如何连接到数据库。连接字符串通常包含数据提供程序、数据库服务器的地址、数据库名称以及登录凭据。

public class BloggingContext : DbContext
{
    public BloggingContext() : base("name=DefaultConnection")
    {
    }
    public DbSet<Blog> Blogs { get; set; }
    public DbSet<Post> Posts { get; set; }
}

在上面的示例代码中， DbContext 的构造函数使用了一个名为 DefaultConnection 的连接字符串。这个字符串需要在应用的配置文件中定义，例如 app.config 或 web.config 。

<connectionStrings>
    <add name="DefaultConnection" connectionString="Data Source=(localdb)\MSSQLLocalDB;Initial Catalog=BlogDB;Integrated Security=True;" providerName="System.Data.SqlClient" />
</connectionStrings>

5.2.2 配置连接超时和隔离级别

在处理数据库连接时，有时需要对连接的超时设置和事务的隔离级别进行配置，以确保操作的可靠性和一致性。

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
    optionsBuilder.UseSqlServer(
        @"Server=(localdb)\mssqllocaldb;Database=BlogDB;Integrated Security=True",
        providerOptions => providerOptions.CommandTimeout(30) // 设置命令超时为30秒
    );
}

using (var context = new BloggingContext())
{
    context.Database.BeginTransaction(System.Data.IsolationLevel.RepeatableRead);
}

在 OnConfiguring 方法中，我们通过 UseSqlServer 方法配置了数据库提供程序和连接字符串，并设置了命令超时。在实际代码中，我们还可以指定事务的隔离级别，以确保数据的正确性和一致性。

5.3 使用DbContext类操作数据库

5.3.1 查询数据

查询是数据库操作中最常见的任务之一。使用 DbContext 类，开发者可以利用LINQ编写查询，而不需要编写原始的SQL语句。例如，查询所有博客记录：

using (var context = new BloggingContext())
{
    var blogs = context.Blogs.ToList();
}

5.3.2 插入、更新和删除数据

DbContext 提供了方法来执行插入、更新和删除操作。这些操作会改变实体的状态，并将更改保存到数据库。

using (var context = new BloggingContext())
{
    // 插入数据
    var newBlog = new Blog { Name = "My New Blog", Url = "http://blog.mynewblog.com" };
    context.Blogs.Add(newBlog);
    context.SaveChanges();

    // 更新数据
    var blogToUpdate = context.Blogs.Find(1);
    blogToUpdate.Name = "Updated Name";
    context.SaveChanges();

    // 删除数据
    var blogToDelete = context.Blogs.Find(2);
    context.Blogs.Remove(blogToDelete);
    context.SaveChanges();
}

在上面的代码中， Add , Find , Remove , 和 SaveChanges 是 DbContext 类中用于操作实体的方法。 Add 用于添加新实体， Find 用于查找实体， Remove 用于删除实体，而 SaveChanges 则是将所有未提交的更改保存到数据库。

至此，我们已经详细了解了 DbContext 类的作用、特点以及如何配置和使用它来管理数据库连接。接下来的章节我们将介绍如何使用Entity Framework的Migration特性来管理数据库模式的版本控制和自动更新。

6. 通过Migration实现数据库结构的自动创建与更新

随着应用的持续迭代，数据库结构也经常需要更新，以适应新的业务需求。为了简化数据库结构的更新和管理，Entity Framework引入了Migration特性，它允许开发者以声明式的方式来描述数据库的变更，并且能够自动地创建和更新数据库结构。

6.1 什么是Migration

6.1.1 Migration的基本概念

Migration是Entity Framework Core中用于版本化数据库模式的一种机制。它可以跟踪你的数据模型的更改，并将这些更改应用到数据库中。开发者通过定义一系列的迁移脚本，就能够控制如何向数据库添加新表、字段或索引，以及如何修改或删除现有对象。

6.1.2 迁移与数据库版本控制

迁移是数据库版本控制的关键组成部分。通过迁移，团队成员可以同步模型的更改，并且数据库模式能够保持与代码的同步。当你部署应用时，迁移将确保数据库结构与当前应用的数据模型保持一致。

6.2 使用Migration创建和更新数据库

6.2.1 添加新的数据模型变更

当数据模型发生变化时，我们需要通过EF Core的迁移命令来添加新的变更。这涉及到几个步骤：

1. 修改数据模型（在Entity类中添加或删除属性等）。
2. 使用PMC（Package Manager Console）添加一个新的迁移命令，例如： Add-Migration AddNewColumnToUserTable 。
3. 更新迁移脚本中的方法，以反映数据模型的变化。EF Core会自动生成一个骨架，你可能需要添加额外的逻辑。
4. 使用PMC命令 Update-Database 来应用迁移到数据库。

6.2.2 更新数据库结构的操作步骤

Update-Database 命令执行以下操作步骤：

1. 验证迁移的依赖关系，确保迁移顺序正确。
2. 生成数据库的更新脚本，这可能涉及到创建新的数据库对象或修改现有对象。
3. 执行数据库更新脚本，实际在数据库中创建或修改相应的结构。

6.3 自定义Migration脚本

6.3.1 编写自定义迁移操作

有时，EF Core的默认迁移操作可能无法满足你的特定需求。在这种情况下，你可以编写自定义的迁移操作。通过在迁移类中添加自定义的 Up 和 Down 方法，可以执行更复杂的数据库操作。

public partial class AddCustomFunctions : Migration
{
    protected override void Up(MigrationBuilder migrationBuilder)
    {
        // 自定义数据库创建逻辑
        migrationBuilder.Sql("CREATE FUNCTION dbo.CustomFunction (...) RETURNS ... AS BEGIN ... END");
    }

    protected override void Down(MigrationBuilder migrationBuilder)
    {
        // 自定义数据库回滚逻辑
        migrationBuilder.Sql("DROP FUNCTION dbo.CustomFunction");
    }
}

6.3.2 配置和执行自定义迁移

自定义迁移的配置和执行如下：

1. 在PMC中使用 Add-Migration CustomFunctionMigration 添加迁移。
2. 根据需要修改迁移类中的 Up 和 Down 方法来包含自定义逻辑。
3. 使用 Update-Database 命令执行迁移，自定义逻辑将随之应用。

通过这种方式，开发者可以精确控制数据库的每一个更改，确保数据库结构的变更更加稳健和可控。

示例代码块分析

migrationBuilder.CreateTable(
    name: "User",
    columns: table => new
    {
        UserID = table.Column<int>(nullable: false)
            .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
        UserName = table.Column<string>(maxLength: 256, nullable: false),
        PasswordHash = table.Column<byte[]>(maxLength: 128, nullable: false),
        PasswordSalt = table.Column<byte[]>(maxLength: 128, nullable: false),
    },
    constraints: table =>
    {
        table.PrimaryKey("PK_User", x => x.UserID);
    });

在上述代码中，我们使用Fluent API定义了一个 User 表。 Annotation 方法用于指定使用SQL Server的 IdentityColumn 作为主键生成策略。这允许SQL Server自动为每条新记录生成一个唯一的ID值。

migrationBuilder.CreateIndex(
    name: "IX_User_UserName",
    table: "User",
    column: "UserName",
    unique: true);

以上代码块创建了一个名为 IX_User_UserName 的索引，用于 UserName 列，并且设置为唯一索引，确保不会有重复的用户名。

小结

通过本章节的介绍，我们了解了Entity Framework Core的Migration是如何工作的，学习了如何通过迁移添加新的数据模型变更，以及如何编写和执行自定义迁移。使用Migration可以极大地简化数据库结构的更新和版本控制，使得数据库管理更加高效和可靠。在实际开发中，合理运用Migration不仅可以保证数据模型与数据库结构的一致性，还可以优化团队协作和应用的部署过程。

7. 结合SqlSugar进行高效数据操作

7.1 SqlSugar简介

7.1.1 SqlSugar的功能特点

SqlSugar是一个轻量级且功能强大的.NET ORM库。它支持多种数据库系统，如SQL Server、MySQL、SQLite等，并且提供了一系列便捷的功能来简化数据操作。它的特点包括：

• 简单易用的API设计
• 支持多种数据库和连接池管理
• 高性能的数据操作
• 支持原生SQL和Lambda表达式查询
• 配合Code First模式和自动生成数据库表结构
• 支持缓存查询结果来提高性能

7.1.2 SqlSugar的安装和配置

要使用SqlSugar，首先需要在.NET项目中安装对应的NuGet包。以下是安装步骤：

Install-Package SqlSugar

安装成功后，你需要配置SqlSugar以连接到你的数据库。这可以通过创建一个 DbConfig 类来完成，如下所示：

public class DbConfig
{
    public static string ConnectionString = "Your Connection String";
    public static SqlSugarClient Instance;
    public static void Init()
    {
        Instance = new SqlSugarClient(new SqlSugarConfig
        {
            ConnectionString = ConnectionString,
            DbType = DbType.SqlServer,
            IsAutoCloseConnection = true,
        });
    }
}

在应用程序的启动代码中调用 DbConfig.Init() 方法来初始化 SqlSugarClient 实例。

7.2 使用SqlSugar进行CRUD操作

7.2.1 查询数据

SqlSugar允许你使用Lambda表达式进行复杂的数据查询。以下是一个查询示例：

var query = Db糖糖Client.SqlQuery<User>(@"
SELECT * 
FROM Users 
WHERE Age > @age 
ORDER BY Age DESC
", new { age = 18 });

var result = query.ToList();

7.2.2 插入、更新和删除数据

通过使用SqlSugar，你可以轻松地进行数据的插入、更新和删除操作：

// 插入数据
var newUser = new User { Name = "Alice", Age = 20 };
Db糖糖Client.Insertable(newUser).ExecuteCommand();

// 更新数据
newUser.Name = "Alice Smith";
Db糖糖Client.Updateable(newUser).ExecuteCommand();

// 删除数据
Db糖糖Client.Deleteable<User>(1).ExecuteCommand(); // 删除ID为1的用户

7.3 高级查询技巧

7.3.1 分页查询

分页是常见的查询需求，SqlSugar提供了简单的方法来实现分页查询：

var pagedData = Db糖糖Client.Ado.SqlQuery<User>(
    "SELECT * FROM Users",
    new { pageSize = 10, pageIndex = 1 });

var totalRecord = pagedData.TotalCount;
var pageData = pagedData.ToPageList(totalRecord, 1, 10);

7.3.2 多表连接查询

进行多表查询时，SqlSugar同样支持：

var query = Db糖糖Client.Queryable<User>()
    .LeftJoin<UserRole>((u, ur) => u.Id == ur.UserId)
    .LeftJoin<Role>((ur, r) => ur.RoleId == r.Id)
    .Where((u, ur, r) => u.Age > 20)
    .Select((u, ur, r) => new { u.Name, r.Name as RoleName })
    .ToList();

7.3.3 复杂条件查询

对于复杂的查询条件，你可以使用SqlSugar提供的组合查询方法：

var complexConditionQuery = Db糖糖Client.Queryable<User>()
    .Where(u => u.Age > 18 && u.Age < 30)
    .OrIF(u => u.Name.Contains("Alice"))
    .OrderBy(u => u.Id, OrderByType.Desc)
    .ToList();

以上章节介绍了SqlSugar的基本使用方法，包括安装、配置、CRUD操作以及高级查询技巧。这些内容为数据库操作提供了一套高效的解决方案，可以大大简化.NET项目中的数据库处理过程。

文尾附上完整的源码和配置文件，供读者参考和实践。在阅读完本文后，你应该能够掌握SqlSugar的基本使用，并将其应用于你的项目中以提高开发效率和数据处理能力。

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

简介：C# Code First是Entity Framework中的一种开发模式，让开发者通过编写C#对象模型来自动生成或更新数据库表结构。本文深入剖析了Code First的工作机制及其在.NET开发中的应用，展示了如何通过Entity Framework及ORM工具SqlSugar实现数据库操作。内容包括安装必要的库、定义实体类、配置DbContext、启用迁移、应用迁移以及使用SqlSugar进行数据库操作。文章最后提供了完整的示例代码，帮助读者掌握Code First模式，提高.NET中的数据库编程效率。

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