ASP.NET数据库编程教程如何快速上手？

3 步骤一：安装 EF Core 包

在 NuGet 包管理器控制台中运行：

# 对于 SQL Server
Install-Package Microsoft.EntityFrameworkCore.SqlServer
# 用于设计时创建迁移的包
Install-Package Microsoft.EntityFrameworkCore.Tools

4 步骤二：创建数据模型 (Entity)

在 Models 文件夹下创建 Product.cs：

// Models/Product.cs
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
namespace MyWebApp.Models
{
    public class Product
    {
        public int Id { get; set; }
        [Required]
        [StringLength(100)]
        public string Name { get; set; }
        [Column(TypeName = "decimal(18, 2)")]
        public decimal Price { get; set; }
    }
}

我们添加了数据注解来验证和配置模型。

5 步骤三：创建 DbContext

在 Models 文件夹下创建 ApplicationDbContext.cs：

// Models/ApplicationDbContext.cs
using Microsoft.EntityFrameworkCore;
using MyWebApp.Models;
namespace MyWebApp.Models
{
    public class ApplicationDbContext : DbContext
    {
        public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
            : base(options)
        {
        }
        public DbSet<Product> Products { get; set; }
    }
}

6 步骤四：配置数据库连接字符串

打开 Program.cs，将 DbContext 注册到依赖注入容器中。

// Program.cs
using Microsoft.EntityFrameworkCore;
using MyWebApp.Models;
var builder = WebApplication.CreateBuilder(args);
// 1. 添加服务到容器。
builder.Services.AddControllersWithViews();
// 2. 注册 DbContext
builder.Services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));
var app = builder.Build();
// ... 其余代码

7 步骤五：创建并应用数据库迁移

1. 在 Visual Studio 的 “工具” 菜单中，打开 “NuGet 包管理器” -> “包管理器控制台”。

2. 确保默认项目是你的 ASP.NET Core 项目。

3. 运行以下命令：

   # 创建初始迁移
   Add-Migration InitialCreate
   # 将迁移应用到数据库
   Update-Database

   执行后,EF Core 会在你的数据库中自动创建一个 Products 表。

8 步骤六：使用 EF Core 进行 CRUD 操作

我们可以修改 HomeController 来使用 EF Core。

修改 HomeController.cs

using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using MyWebApp.Models;
using System.Threading.Tasks;
namespace MyWebApp.Controllers
{
    public class HomeController : Controller
    {
        private readonly ApplicationDbContext _context;
        // 通过构造函数注入 DbContext
        public HomeController(ApplicationDbContext context)
        {
            _context = context;
        }
        // GET: /Home/Index
        public async Task<IActionResult> Index()
        {
            // 使用 LINQ 查询，EF Core 会将其翻译成 SQL
            var products = await _context.Products.ToListAsync();
            return View(products);
        }
        // GET: /Home/Create
        public IActionResult Create()
        {
            return View();
        }
        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> Create([Bind("Name,Price")] Product product)
        {
            if (ModelState.IsValid)
            {
                _context.Add(product);
                await _context.SaveChangesAsync();
                return RedirectToAction(nameof(Index));
            }
            return View(product);
        }
        // GET: /Home/Edit/5
        public async Task<IActionResult> Edit(int? id)
        {
            if (id == null)
            {
                return NotFound();
            }
            var product = await _context.Products.FindAsync(id);
            if (product == null)
            {
                return NotFound();
            }
            return View(product);
        }
        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> Edit(int id, [Bind("Id,Name,Price")] Product product)
        {
            if (id != product.Id)
            {
                return NotFound();
            }
            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(product);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!ProductExists(product.Id))
                    {
                        return NotFound();
                    }
                    else
                    {
                        throw;
                    }
                }
                return RedirectToAction(nameof(Index));
            }
            return View(product);
        }
        // GET: /Home/Delete/5
        public async Task<IActionResult> Delete(int? id)
        {
            if (id == null)
            {
                return NotFound();
            }
            var product = await _context.Products
                .FirstOrDefaultAsync(m => m.Id == id);
            if (product == null)
            {
                return NotFound();
            }
            return View(product);
        }
        [HttpPost, ActionName("Delete")]
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> DeleteConfirmed(int id)
        {
            var product = await _context.Products.FindAsync(id);
            _context.Products.Remove(product);
            await _context.SaveChangesAsync();
            return RedirectToAction(nameof(Index));
        }
        private bool ProductExists(int id)
        {
            return _context.Products.Any(e => e.Id == id);
        }
    }
}

创建对应的视图 (Create.cshtml, Edit.cshtml, Delete.cshtml) 这些视图的创建方式与 Index.cshtml 类似，但包含一个 HTML 表单来输入数据，可以使用 Visual Studio 的 “添加视图” -> “Razor 视图 - 使用实体框架” 功能来自动生成这些视图，非常方便。

第四部分：最佳实践与高级技巧

1 依赖注入

我们已经看到了在 HomeController 中通过构造函数注入 ApplicationDbContext，这是 ASP.NET Core 推荐的做法，它使你的组件更易于测试和解耦。

2 异步编程 (async/await)

所有与数据库交互的 EF Core 和 Dapper 方法都提供了异步版本（以 Async ，在 Web 应用中，始终使用异步方法！这样可以避免阻塞 Web 请求线程，提高服务器的吞吐量和可伸缩性。

// 好的做法
var products = await _context.Products.ToListAsync();
// 不好的做法 (会阻塞线程)
var products = _context.Products.ToList(); 

3 处理并发冲突

当多个用户同时尝试修改同一条数据时,可能会发生并发冲突，EF Core 通过 ConcurrencyCheck 或 RowVersion 属性来处理。

在模型中添加 Timestamp 属性：

[Timestamp]
public byte[] RowVersion { get; set; }

EF Core 会在 UPDATE 语句中包含此列，如果数据库中的值与从实体中读取的值不匹配，就会抛出 DbUpdateConcurrencyException，你可以在 Edit 方法中捕获此异常并提示用户。

4 仓储模式

对于大型项目,通常会创建一个仓储层来封装数据访问逻辑，进一步解耦控制器和 EF Core。

// 仓储接口
public interface IProductRepository
{
    Task<IEnumerable<Product>> GetAllAsync();
    Task<Product> GetByIdAsync(int id);
    // ... 其他方法
}
// EF Core 实现的仓储
public class ProductRepository : IProductRepository
{
    private readonly ApplicationDbContext _context;
    public ProductRepository(ApplicationDbContext context) => _context = context;
    public async Task<IEnumerable<Product>> GetAllAsync() => await _context.Products.ToListAsync();
    public async Task<Product> GetByIdAsync(int id) => await _context.Products.FindAsync(id);
    // ...
}
// 在 Startup.cs/Program.cs 中注册仓储
builder.Services.AddScoped<IProductRepository, ProductRepository>();
// 在 Controller 中使用
public class ProductsController : Controller
{
    private readonly IProductRepository _repository;
    public ProductsController(IProductRepository repository) => _repository = repository;
    // ...
}

第五部分：实战项目 - 构建一个简单的博客系统

这个项目将综合运用 EF Core 和 MVC 知识。

1. 创建项目: 按照第一部分创建一个新的 ASP.NET Core MVC 项目。
2. 创建模型:
   • Post.cs: Id, Title, Content, PublishDate
   • Tag.cs: Id, Name
   • PostTag.cs (多对多关系): PostId, TagId
3. 创建 DbContext: BlogDbContext.cs，包含 DbSet<Post>, DbSet<Tag>, DbSet<PostTag>。
4. 配置依赖注入和迁移: 在 Program.cs 中注册 BlogDbContext，然后使用 PMC 创建并应用迁移。
5. 创建控制器和视图:
   • PostsController: 实现列表、详情、创建、编辑、删除功能。
   • 为每个 Action 创建对应的 View。
6. 添加路由和导航: 在 _Layout.cshtml 中添加指向博客列表和创建新文章的链接。

这个项目将让你对整个数据流有更深刻的理解。

第六部分：总结与学习资源

• ADO.NET/Dapper: 底层、高性能、代码量多，适合性能要求极高或需要执行复杂/特定 SQL 的场景。
• Entity Framework Core: 现代、高效、开发效率高，绝大多数应用场景下的首选，它为你处理了大部分复杂性，让你能专注于业务逻辑。

学习资源

• 微软官方文档 (最权威):
  • ASP.NET Core Overview
  • Entity Framework Core
  • Get started with ASP.NET Core MVC
• 视频教程:
  • Philipp Bauknecht (德语，但代码通用): 他的 EF Core 教程非常深入。
  • FreeCodeCamp: 有很多高质量的 ASP.NET Core 全栈教程。
  • Udemy / Pluralsight: 搜索 "ASP.NET Core" 和 "Entity Framework Core"，有很多付费和免费课程。
• 社区:
  • Stack Overflow: 遇到问题，先搜索，大概率能找到答案。
  • GitHub: 查看 EF Core 和 ASP.NET Core 的源码，了解内部实现。

希望这份详细的教程能帮助你顺利掌握 ASP.NET 数据库编程！祝你编码愉快！