C#与RESTful API开发实战（ASP.NET Core）

1. 理解 RESTful API

1.1 RESTful 架构风格概述

REST（Representational State Transfer）是一种用于设计网络应用程序的架构风格，由 Roy Fielding 在 2000 年的博士论文中提出。RESTful API 遵循 REST 架构风格的原则，旨在提供一种简单、可扩展且易于理解的方式来通过 HTTP 协议进行资源交互。

REST 的核心概念围绕资源展开，资源是可以通过 URI（Uniform Resource Identifier）进行标识的任何事物，比如一篇文章、一个用户或者一个订单。客户端通过标准的 HTTP 方法（GET、POST、PUT、DELETE 等）来操作这些资源，每个方法对应不同的操作语义。例如，GET 用于获取资源，POST 用于创建新资源，PUT 用于更新资源，DELETE 用于删除资源。这种基于资源和标准 HTTP 方法的设计使得 RESTful API 易于理解和使用，同时也具备良好的可扩展性和跨平台性。

1.2 RESTful API 的设计原则

• 资源标识：每个资源都应该有一个唯一的 URI 来标识。例如，一个博客系统中，文章资源可以通过 /api/articles/{articleId} 这样的 URI 来标识，其中 {articleId} 是文章的唯一标识符。
• 统一接口：使用标准的 HTTP 方法来操作资源，确保接口的一致性。如前面提到的 GET、POST、PUT 和 DELETE 方法。同时，响应应该使用标准的 HTTP 状态码来表示操作的结果，比如 200 表示成功，404 表示资源未找到，500 表示服务器内部错误等。
• 无状态：服务器不应该在不同的请求之间维护客户端的状态。每个请求都应该包含足够的信息，使得服务器能够独立处理该请求，而不需要依赖之前的请求信息。这样可以提高系统的可扩展性和容错性。
• 分层系统：RESTful 架构可以采用分层设计，客户端和服务器之间可以存在多个中间层，如缓存层、代理层等。这些中间层可以提供额外的功能，如缓存数据以提高性能，或者进行安全过滤等。
• 按需代码（可选）：客户端可以根据需要从服务器获取可执行代码，例如 JavaScript 脚本等，以扩展客户端的功能。但这一原则在实际应用中并不总是必需的。

2. ASP.NET Core 基础

2.1 ASP.NET Core 简介

ASP.NET Core 是一个跨平台、高性能、开源的框架，用于构建现代 Web 应用程序，包括 Web 应用、Web API 和微服务等。它由微软开发，融合了传统 ASP.NET 的优点，并进行了大量的改进和优化，以适应现代软件开发的需求。

ASP.NET Core 具有以下显著特点：

• 跨平台：可以在 Windows、Linux 和 macOS 等多种操作系统上运行，这使得开发者能够根据项目需求灵活选择服务器平台。
• 高性能：采用了轻量级的设计和高效的运行时，能够处理大量的并发请求，提供出色的性能表现。
• 开源：源代码在 GitHub 上公开，社区活跃度高，开发者可以参与贡献代码、获取最新的更新以及使用丰富的社区资源。
• 依赖注入：内置了强大的依赖注入（Dependency Injection，DI）容器，使得代码的可测试性和可维护性大大提高。通过依赖注入，开发者可以将对象的创建和依赖关系管理分离，降低代码的耦合度。
• 中间件：中间件是 ASP.NET Core 的核心概念之一，它提供了一种强大的方式来对请求和响应进行处理。中间件可以按照顺序依次执行，每个中间件可以对请求进行预处理、修改，或者对响应进行后处理等操作。例如，日志记录中间件可以记录每个请求的详细信息，身份验证中间件可以验证请求的用户身份等。

2.2 创建 ASP.NET Core 项目

在开始使用 ASP.NET Core 开发 RESTful API 之前，我们需要先创建一个项目。以下以 Visual Studio 2022 为例，介绍创建项目的步骤：

1. 打开 Visual Studio 2022，点击 “创建新项目”。
2. 在项目模板搜索框中输入 “ASP.NET Core Web 应用”，然后选择 “ASP.NET Core Web 应用” 模板，点击 “下一步”。
3. 在 “配置新项目” 页面，输入项目名称和位置，然后点击 “下一步”。
4. 在 “Additional information” 页面，选择 “.NET 6.0 (Long - term support)”，项目类型选择 “API”，取消勾选 “Enable Docker Support”（如果不需要 Docker 支持），然后点击 “创建”。

创建完成后，Visual Studio 会生成一个基本的 ASP.NET Core Web API 项目结构，其中包含了一些默认的文件和代码。主要文件和文件夹结构如下：

• Controllers 文件夹：用于存放控制器类，控制器负责处理 HTTP 请求并返回响应。在 RESTful API 开发中，控制器通常对应不同的资源操作。
• Program.cs：这是应用程序的入口点，在该文件中配置应用程序的启动逻辑、中间件等。
• appsettings.json：用于存储应用程序的配置信息，如数据库连接字符串、日志级别等。这些配置信息可以在运行时被应用程序读取和使用。

2.3 理解 ASP.NET Core 中的路由

路由在 ASP.NET Core 中起着至关重要的作用，它负责将 incoming HTTP 请求映射到相应的控制器和操作方法。ASP.NET Core 支持两种主要的路由方式：传统路由和 Attribute 路由。

2.3.1 传统路由

在传统路由中，路由规则是在 Startup.cs 文件的 Configure 方法中通过 MapControllerRoute 方法进行配置的。例如：

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;

namespace WebApiSample
{
    public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllers();
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            app.UseRouting();

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllerRoute(
                    name: "default",
                    pattern: "{controller=Home}/{action=Index}/{id?}");
            });
        }
    }
}

在上述代码中，MapControllerRoute 方法定义了一个名为 “default” 的路由规则。该规则表示：如果请求的 URL 没有指定控制器名称，则默认使用 “Home” 控制器；如果没有指定操作方法名称，则默认使用 “Index” 操作方法；{id?} 表示 id 是一个可选参数。

2.3.2 Attribute 路由

Attribute 路由则是通过在控制器或操作方法上添加路由特性来定义路由规则。这种方式更加灵活和直观，并且可以在控制器级别和操作方法级别分别定义路由。例如：

using Microsoft.AspNetCore.Mvc;

namespace WebApiSample.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class ArticlesController : ControllerBase
    {
        [HttpGet]
        public IActionResult Get()
        {
            // 返回文章列表的逻辑
            return Ok("文章列表");
        }

        [HttpGet("{id}")]
        public IActionResult Get(int id)
        {
            // 根据 id 获取文章的逻辑
            return Ok($"文章 {id}");
        }

        [HttpPost]
        public IActionResult Post([FromBody] Article article)
        {
            // 创建新文章的逻辑
            return CreatedAtAction(nameof(Get), new { id = article.Id }, article);
        }

        [HttpPut("{id}")]
        public IActionResult Put(int id, [FromBody] Article article)
        {
            // 更新文章的逻辑
            return NoContent();
        }

        [HttpDelete("{id}")]
        public IActionResult Delete(int id)
        {
            // 删除文章的逻辑
            return NoContent();
        }
    }
}

在上述代码中，[Route("api/[controller]")] 定义了控制器级别的路由，[controller] 会被替换为实际的控制器名称（去掉 “Controller” 后缀），即 “api/articles”。每个操作方法上的 HttpGet、HttpPost 等特性进一步定义了具体的路由规则，例如 [HttpGet("{id}")] 表示获取单个文章的路由为 “api/articles/{id}”。

3. 使用 C# 在 ASP.NET Core 中开发 RESTful API

3.1 创建控制器

在 ASP.NET Core 中，控制器是处理 HTTP 请求的核心组件。如前面提到的 ArticlesController，它继承自 ControllerBase 类。ControllerBase 提供了许多用于处理请求和生成响应的方法和属性。

在控制器中，每个公共方法通常对应一个特定的 HTTP 操作。例如，Get 方法通常用于处理 GET 请求，Post 方法用于处理 POST 请求等。方法的参数可以用于接收请求中的数据，如通过 [FromBody] 特性可以从请求体中获取 JSON 格式的数据并自动反序列化为对应的对象。

下面以一个简单的 ProductController 为例，展示如何在控制器中实现基本的 RESTful API 操作：

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;

namespace WebApiSample.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class ProductController : ControllerBase
    {
        private static List<Product> products = new List<Product>()
        {
            new Product { Id = 1, Name = "Product 1", Price = 10.99m },
            new Product { Id = 2, Name = "Product 2", Price = 19.99m }
        };

        [HttpGet]
        public IActionResult Get()
        {
            return Ok(products);
        }

        [HttpGet("{id}")]
        public IActionResult Get(int id)
        {
            var product = products.Find(p => p.Id == id);
            if (product == null)
            {
                return NotFound();
            }
            return Ok(product);
        }

        [HttpPost]
        public IActionResult Post([FromBody] Product product)
        {
            product.Id = products.Count + 1;
            products.Add(product);
            return CreatedAtAction(nameof(Get), new { id = product.Id }, product);
        }

        [HttpPut("{id}")]
        public IActionResult Put(int id, [FromBody] Product product)
        {
            var index = products.FindIndex(p => p.Id == id);
            if (index == -1)
            {
                return NotFound();
            }
            product.Id = id;
            products[index] = product;
            return NoContent();
        }

        [HttpDelete("{id}")]
        public IActionResult Delete(int id)
        {
            var index = products.FindIndex(p => p.Id == id);
            if (index == -1)
            {
                return NotFound();
            }
            products.RemoveAt(index);
            return NoContent();
        }
    }

    public class Product
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public decimal Price { get; set; }
    }
}

在上述代码中，ProductController 实现了对 Product 资源的 GET（获取列表和单个产品）、POST（创建新产品）、PUT（更新产品）和 DELETE（删除产品）操作。

3.2 处理请求和响应

3.2.1 接收请求数据

在 RESTful API 中，请求数据可以通过不同的方式传递，如查询字符串、请求体等。在 ASP.NET Core 控制器中，通过不同的特性可以方便地获取这些数据。

• 从查询字符串获取数据：可以直接在操作方法的参数中定义与查询字符串参数同名的变量。例如：

[HttpGet]
public IActionResult Get(string category)
{
    // 根据 category 过滤产品的逻辑
    return Ok();
}

在上述代码中，category 参数会自动从请求的查询字符串中获取对应的值。

• 从请求体获取数据：当请求体中包含 JSON 格式的数据时，可以使用 [FromBody] 特性将其反序列化为对应的对象。如前面 ProductController 的 Post 和 Put 方法中的 [FromBody] Product product 参数，ASP.NET Core 会自动将请求体中的 JSON 数据反序列化为 Product 对象。

3.2.2 返回响应数据

ASP.NET Core 提供了多种方式来返回响应数据，常见的有以下几种：

• 返回 JSON 数据：使用 Ok 方法可以返回状态码为 200 的成功响应，并将数据以 JSON 格式返回。例如 return Ok(products);，其中 products 是一个对象或集合，会被自动序列化为 JSON 格式。
• 返回特定状态码：除了 Ok 方法，还有许多其他方法用于返回不同的状态码。例如，NotFound 方法返回 404 状态码，表示资源未找到；CreatedAtAction 方法返回 201 状态码，表示资源已成功创建，并可以指定创建资源的 URI。
• 返回文件：如果需要返回文件，如图片、文档等，可以使用 File 方法。例如：

[HttpGet("download")]
public IActionResult Download()
{
    var filePath = "path/to/file.pdf";
    var fileBytes = System.IO.File.ReadAllBytes(filePath);
    return File(fileBytes, "application/pdf", "file.pdf");
}

上述代码返回一个 PDF 文件，File 方法的第一个参数是文件的字节数组，第二个参数是文件的 MIME 类型，第三个参数是文件名。

3.3 数据验证

在接收请求数据时，进行数据验证是非常重要的，以确保数据的合法性和完整性。ASP.NET Core 提供了强大的数据验证功能，主要通过数据注解（Data Annotations）和模型绑定（Model Binding）来实现。

3.3.1 数据注解

数据注解是一组特性，可以应用于模型类的属性上，用于指定验证规则。例如，在 Product 类中，可以添加以下数据注解：

using System.ComponentModel.DataAnnotations;

public class Product
{
    public int Id { get; set; }

    [Required(ErrorMessage = "产品名称是必需的")]
    [StringLength(100, ErrorMessage = "产品名称长度不能超过 100 个字符")]
    public string Name { get; set; }

    [Range(0.01, double.MaxValue, ErrorMessage = "价格必须大于 0")]
    public decimal Price { get; set; }
}

在上述代码中，[Required] 表示 Name 属性是必需的，[StringLength] 限制了 Name 属性的长度，[Range] 限制了 Price 属性的取值范围。

3.3.2 模型验证在控制器中的应用

当请求数据被反序列化为模型对象后，ASP.NET Core 会自动根据数据注解进行模型验证。在控制器中，可以通过 ModelState.IsValid 属性来检查模型是否有效。例如：

[HttpPost]
public IActionResult Post([FromBody] Product product)
{
    if (!ModelState.IsValid)
    {
        return BadRequest(ModelState);
    }
    // 处理创建产品的逻辑
    return CreatedAtAction(nameof(Get), new { id = product.Id }, product);
}

在上述代码中，如果 ModelState.IsValid 为 false，表示模型验证失败，返回状态码为 400 的 BadRequest 响应，并将验证错误信息包含在响应体中。

4. 集成数据库

4.1 选择数据库

在实际的 RESTful API 开发中，通常需要与数据库进行交互来存储和检索数据。常见的数据库选择有关系型数据库（如 SQL Server、MySQL、Oracle 等）和非关系型数据库（如 MongoDB、Redis 等）。

• 关系型数据库：适用于数据结构固定、需要复杂查询和事务处理的场景。例如，在一个电商系统中，订单、用户等数据通常存储在关系型数据库中，因为这些数据之间存在复杂的关联关系，并且对数据的一致性要求较高。
• 非关系型数据库：则更适合处理海量数据、数据结构灵活的场景。例如，在日志记录、缓存数据存储等场景中，非关系型数据库如 Redis 可以提供高性能的读写操作，而 MongoDB 可以方便地存储和查询半结构化或非结构化的数据。

4.2 使用 Entity Framework Core 进行数据库交互

Entity Framework Core（EF Core）是一个对象关系映射（ORM）框架，它允许开发者使用.NET 代码来与数据库进行交互，而无需编写大量的 SQL 语句。EF Core 支持多种数据库，包括 SQL Server、MySQL、PostgreSQL 等。

4.2.1 安装 EF Core 相关包

首先，需要在项目中安装 EF Core 相关的 NuGet 包。如果使用 SQL Server 数据库，可以安装 Microsoft.EntityFrameworkCore.SqlServer 和 Microsoft.EntityFrameworkCore.Tools 包。在 Visual Studio 中，可以通过 “管理 NuGet 程序包” 来搜索并安装这些包。

4.2.2 创建数据模型和数据库上下文

假设我们有一个简单的博客系统，需要存储文章和作者信息。首先定义数据模型类：

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;

namespace BlogApi.Models
{
    public class Author
    {
        [Key]
        public int Id { get; set; }

        [Required]
        [StringLength(100)]
        public string Name { get; set; }

        public ICollection<Article> Articles { get; set; }
    }

    public class Article
    {
        [Key]
        public int Id { get; set; }

        [Required]
        [StringLength(200)]
        public string Title { get; set; }

        public string Content { get; set; }

        public DateTime PublishedDate { get; set; }

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

然后创建数据库上下文类，用于与数据库进行交互：

using Microsoft.EntityFrameworkCore;

namespace BlogApi.Models
{
    public class BlogDbContext : DbContext
    {
        public BlogDbContext(DbContextOptions<BlogDbContext> options) : base(options)
        {
        }

        public DbSet<Author> Authors { get; set; }
        public DbSet<Article> Articles { get; set; }
    }
}

在上述代码中，BlogDbContext 继承自 DbContext，并定义了 Authors 和 Articles 两个 DbSet，分别对应数据库中的 Authors 表和 Articles 表。

4.2.3 配置数据库连接和迁移

在 Startup.cs 文件中，配置数据库连接和 EF Core 服务：

using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;

namespace BlogApi
{
    public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        public void ConfigureServices(IServiceCollection services)
        {
            services.AddDbContext<BlogDbContext>(options =>
                options.UseSqlServer(Configuration.GetConnectionString("BlogDbConnection")));

            services.AddControllers();
        }

        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            // 其他配置代码
        }
    }
}

在 appsettings.json 文件中添加数据库连接字符串：

{
  "ConnectionStrings": {
    "BlogDbConnection": "Server=YOUR_SERVER_NAME;Database=BlogDb;User ID=YOUR_USERNAME;Password=YOUR_PASSWORD"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*"
}

为了创建数据库表，可以使用 EF Core 的迁移命令。在 Visual Studio 的 “程序包管理器控制台” 中，执行以下命令：

Add - Migration InitialCreate
Update - Database

Add - Migration 命令会根据数据模型的变化生成迁移脚本，Update - Database 命令会将这些迁移脚本应用到数据库中，创建相应的表结构。

4.2.4 在控制器中使用数据库

在控制器中，可以通过依赖注入获取数据库上下文对象，并进行数据的增删改查操作。例如，在 ArticleController 中：

using Microsoft.AspNetCore.Mvc;
using BlogApi.Models;
using System.Linq;

namespace BlogApi.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class ArticleController : ControllerBase
    {
        private readonly BlogDbContext _context;

        public ArticleController(BlogDbContext context)
        {
            _context = context;
        }

        [HttpGet]
        public IActionResult Get()
        {
            var articles = _context.Articles.Include(a => a.Author).ToList();
            return Ok(articles);
        }

        [HttpGet("{id}")]
        public IActionResult Get(int id)
        {
            var article = _context.Articles.Include(a => a.Author).FirstOrDefault(a => a.Id == id);
            if (article == null)
            {
                return NotFound();
            }
            return Ok(article);
        }

        [HttpPost]
        public IActionResult Post([FromBody] Article article)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }
            _context.Articles.Add(article);
            _context.SaveChanges();
            return CreatedAtAction(nameof(Get), new { id = article.Id }, article);
        }

        [HttpPut("{id}")]
        public IActionResult Put(int id, [FromBody] Article article)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }
            var existingArticle = _context.Articles.FirstOrDefault(a => a.Id == id);
            if (existingArticle == null)
            {
                return NotFound();
            }
            existingArticle.Title = article.Title;
            existingArticle.Content = article.Content;
            existingArticle.PublishedDate = article.PublishedDate;
            existingArticle.AuthorId = article.AuthorId;
            _context.SaveChanges();
            return NoContent();
        }

        [HttpDelete("{id}")]
        public IActionResult Delete(int id)
        {
            var article = _context.Articles.FirstOrDefault(a => a.Id == id);
            if (article == null)
            {
                return NotFound();
            }
            _context.Articles.Remove(article);
            _context.SaveChanges();
            return NoContent();
        }
    }
}

在上述代码中，通过构造函数注入了 BlogDbContext 对象，然后在各个操作方法中使用该对象进行数据库操作，如查询文章列表、根据 ID 获取文章、创建新文章、更新文章和删除文章等。

5. 安全性

5.1 身份验证和授权

5.1.1 身份验证

身份验证是确定请求者身份的过程。在 ASP.NET Core 中，有多种身份验证方案可供选择，如基于 Cookie 的身份验证、JWT（JSON Web Token）身份验证等。

• JWT 身份验证：JWT 是一种开放标准（RFC 7519），它定义了一种紧凑且自包含的方式，用于在各方之间以 JSON 对象的形式安全地传输信息。JWT 通常由三部分组成：头部（Header）、负载（Payload）和签名（Signature）。

在 ASP.NET Core 项目中使用 JWT 身份验证，首先需要安装 Microsoft.AspNetCore.Authentication.JwtBearer 包。然后在 Startup.cs 文件中进行配置：

using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.IdentityModel.Tokens;
using System.Text;

public void ConfigureServices(IServiceCollection services)
{
    var key = Encoding.UTF8.GetBytes(Configuration["Jwt:Key"]);
    services.AddAuthentication(options =>
    {
        options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
        options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
    })
   .AddJwtBearer(options =>
    {
        options.RequireHttpsMetadata = false;
        options.SaveToken = true;
        options.TokenValidationParameters = new TokenValidationParameters
        {
            ValidateIssuer = true,
            ValidateAudience = true,
            ValidateLifetime = true,
            ValidateIssuerSigningKey = true,
            ValidIssuer = Configuration["Jwt:Issuer"],
            ValidAudience = Configuration["Jwt:Audience"],
            IssuerSigningKey = new SymmetricSecurityKey(key)
        };
    });

    services.AddControllers();
}

在 appsettings.json 文件中添加 JWT 相关配置：

{
  "Jwt": {
    "Key": "YOUR_SECRET_KEY",
    "Issuer": "YOUR_ISSUER",
    "Audience": "YOUR_AUDIENCE"
  },
  // 其他配置
}

在控制器中，可以通过 [Authorize] 特性来要求请求必须经过身份验证。例如：

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("api/[controller]")]
[Authorize]
public class SecureController : ControllerBase
{
    [HttpGet]
    public IActionResult Get()
    {
        return Ok("这是一个需要身份验证的 API");
    }
}

5.1.2 授权

授权是确定经过身份验证的用户是否有权限执行特定操作的过程。在 ASP.NET Core 中，可以通过基于策略的授权来实现。

首先，在 Startup.cs 的 ConfigureServices 方法中定义授权策略：

services.AddAuthorization(options =>
{
    options.AddPolicy("AdminOnly", policy =>
        policy.RequireRole("Admin"));
});

上述代码定义了一个名为 “AdminOnly” 的授权策略，要求用户具有 “Admin” 角色。

然后在控制器或操作方法上应用该策略：

[ApiController]
[Route("api/[controller]")]
[Authorize(Policy = "AdminOnly")]
public class AdminController : ControllerBase
{
    [HttpGet]
    public IActionResult Get()
    {
        return Ok("这是一个只有管理员才能访问的 API");
    }
}

在上述代码中，只有具有 “Admin” 角色的用户才能访问 AdminController 的 Get 方法。

5.2 防止常见的安全漏洞

5.2.1 SQL 注入防范

SQL 注入是一种常见的安全漏洞，攻击者通过在输入字段中插入恶意的 SQL 语句，从而获取或修改数据库中的数据。使用 EF Core 可以有效防范 SQL 注入，因为 EF Core 使用参数化查询。例如：

var article = _context.Articles.FirstOrDefault(a => a.Title == title);

上述代码中，title 参数会被正确地处理，不会导致 SQL 注入风险。如果使用原始的 ADO.NET 进行数据库操作，需要手动使用参数化查询，例如：

using (SqlConnection connection = new SqlConnection(connectionString))
{
    string query = "SELECT * FROM Articles WHERE Title = @Title";
    SqlCommand command = new SqlCommand(query, connection);
    command.Parameters.AddWithValue("@Title", title);
    // 执行查询的代码
}

通过使用参数化查询，输入的值会被作为普通数据处理，而不是 SQL 语句的一部分，从而防止 SQL 注入。

5.2.2 跨站脚本攻击（XSS）防范

XSS 攻击是攻击者在网页中注入恶意脚本，当用户访问该网页时，恶意脚本会在用户浏览器中执行，从而窃取用户信息等。在 ASP.NET Core 中，视图引擎默认会对输出进行 HTML 编码，以防止 XSS 攻击。例如，在 Razor 视图中：

@model string
<p>@Model</p>

如果 Model 中包含 <script>alert('XSS')</script>，视图引擎会将其编码为 <script>alert('XSS')</script>，从而使其不会在浏览器中执行。在 API 开发中，如果返回的数据可能包含用户输入内容，也应该进行适当的编码或过滤处理，以防止 XSS 攻击。

6. 性能优化

6.1 缓存

缓存是提高 RESTful API 性能的重要手段之一。通过缓存经常访问的数据，可以减少数据库查询次数，从而提高响应速度。在 ASP.NET Core 中，可以使用内存缓存或分布式缓存（如 Redis）。

6.1.1 内存缓存

使用内存缓存非常简单，首先在 Startup.cs 的 ConfigureServices 方法中添加内存缓存服务：

services.AddMemoryCache();

然后在控制器中使用内存缓存：

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Caching.Memory;
using System.Collections.Generic;

public class ProductController : ControllerBase
{
    private readonly IMemoryCache _memoryCache;

    public ProductController(IMemoryCache memoryCache)
    {
        _memoryCache = memoryCache;
    }

    [HttpGet]
    public IActionResult Get()
    {
        const string cacheKey = "products";
        if (!_memoryCache.TryGetValue(cacheKey, out List<Product> products))
        {
            // 从数据库获取产品列表的逻辑
            products = new List<Product>();
            var cacheEntryOptions = new MemoryCacheEntryOptions()
               .SetSlidingExpiration(TimeSpan.FromMinutes(5))
               .SetAbsoluteExpiration(TimeSpan.FromHours(1));
            _memoryCache.Set(cacheKey, products, cacheEntryOptions);
        }
        return Ok(products);
    }
}

在上述代码中，首先尝试从内存缓存中获取产品列表，如果不存在，则从数据库中获取，并将其存入缓存中。MemoryCacheEntryOptions 可以设置缓存的过期策略，如滑动过期时间（SetSlidingExpiration）和绝对过期时间（SetAbsoluteExpiration）。

6.1.2 分布式缓存（Redis）

使用 Redis 作为分布式缓存，需要安装 Microsoft.Extensions.Caching.Redis 包。然后在 Startup.cs 中配置 Redis 缓存：

services.AddDistributedRedisCache(options =>
{
    options.Configuration = "localhost:6379";
    options.InstanceName = "SampleInstance_";
});

在控制器中使用 Redis 缓存：

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Caching.Distributed;
using System.Collections.Generic;
using System.Text.Json;

public class ProductController : ControllerBase
{
    private readonly IDistributedCache _distributedCache;

    public ProductController(IDistributedCache distributedCache)
    {
        _distributedCache = distributedCache;
    }

    [HttpGet]
    public IActionResult Get()
    {
        const string cacheKey = "products";
        var productBytes = _distributedCache.Get(cacheKey);
        if (productBytes == null)
        {
            // 从数据库获取产品列表的逻辑
            var products = new List<Product>();
            var productJson = JsonSerializer.Serialize(products);
            var cacheEntryOptions = new DistributedCacheEntryOptions()
               .SetSlidingExpiration(TimeSpan.FromMinutes(5))
               .SetAbsoluteExpiration(TimeSpan.FromHours(1));
            _distributedCache.Set(cacheKey, Encoding.UTF8.GetBytes(productJson), cacheEntryOptions);
            return Ok(products);
        }
        var productJsonString = Encoding.UTF8.GetString(productBytes);
        var productsFromCache = JsonSerializer.Deserialize<List<Product>>(productJsonString);
        return Ok(productsFromCache);
    }
}

在上述代码中，使用 IDistributedCache 接口与 Redis 进行交互，将产品列表以 JSON 格式存储在 Redis 中，并根据缓存情况返回数据。

6.2 异步编程

在 ASP.NET Core 中，使用异步编程可以提高应用程序的性能和可伸缩性，特别是在处理 I/O 密集型操作（如数据库查询、文件读取等）时。EF Core 支持异步操作，例如：

[HttpGet]
public async Task<IActionResult> Get()
{
    var articles = await _context.Articles.Include(a => a.Author).ToListAsync();
    return Ok(articles);
}

在上述代码中，ToListAsync 方法是异步的，它不会阻塞当前线程，而是在等待数据库查询结果时释放线程资源，使得应用程序可以处理其他请求。通过在控制器操作方法中使用异步方法，可以显著提高应用程序在高并发场景下的性能。同时，在处理文件上传、下载等 I/O 操作时，也应该尽量使用异步方法，以充分利用系统资源，提高应用程序的整体性能。