【ASP.NET Core 基础知识】--MVC框架--Models和数据绑定

Models和数据绑定在ASP.NET Core MVC中扮演着关键的角色，对于构建强大、灵活和可维护的Web应用程序至关重要。这一节我们就来讲一下。

一、Models

1.1 Models的定义和作用

在ASP.NET Core MVC中，Model是应用程序中用于表示数据结构和业务逻辑的一种抽象。Models充当了MVC（Model-View-Controller）模式中的"M"（Model）部分，负责管理应用程序的数据、状态和业务规则。以下是Models的定义和作用：

1. 定义：
   • 数据结构： Models定义了应用程序中的数据结构，包括实体、对象和数据字段。
   • 业务逻辑： Models包含与数据相关的业务规则，例如验证规则、计算逻辑和数据转换。
2. 作用：
   • 数据表示： Models是数据在应用程序中的逻辑表示。它们定义了数据的组织方式，使其更易于理解和处理。
   • 业务规则： Models中包含的业务逻辑规则确保数据的有效性、完整性和一致性。
   • 状态管理： Models可以跟踪应用程序中的状态变化，使得能够更好地管理数据的生命周期。
   • 数据验证： Models中定义的验证规则用于验证用户输入，确保输入的数据符合应用程序的期望。
   • 模型绑定： Models通过模型绑定将用户提交的数据映射到控制器中，实现了用户请求和应用程序数据的解耦。

通过定义和使用Models，开发人员能够更清晰地组织和管理应用程序的数据，提高代码的可维护性和可测试性。 Models的作用不仅仅是存储数据，还包括在应用程序中对数据进行操作和管理的一系列任务。

1.2 创建Models类

在ASP.NET Core MVC中创建Models类通常是通过定义C#类来表示应用程序中的数据结构。下面是一个简单的示例，展示如何创建一个名为 Product 的Models类：

using System.ComponentModel.DataAnnotations;

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

    public string Description { get; set; }
}

在这个示例中，Product 类有四个属性：Id、Name、Price 和 Description。这个 Product 类可以被用作控制器的参数，也可以在视图中通过模型绑定进行处理。在ASP.NET Core MVC中，Models类是连接控制器（Controller）和视图（View）之间的桥梁，使得数据的传递更为灵活和高效。

1.3 数据验证和注解

在ASP.NET Core MVC中，数据验证是通过注解（Attributes）来实现的，这些注解用于在Models类上标记属性，定义数据验证规则。以下是一些常用的数据验证注解：

1. [Required]：

   • 用于标记一个属性为必填项，不能为null。如果未提供值，会产生验证错误。

   [Required(ErrorMessage = "Name is required")]
   public string Name { get; set; }

2. [StringLength]：

   • 用于指定字符串属性的长度范围。

   [StringLength(100, MinimumLength = 2, ErrorMessage = "Name length must be between 2 and 100")]
   public string Name { get; set; }

3. [Range]：

   • 用于指定数字属性的范围。

   [Range(1, 100, ErrorMessage = "Price must be between 1 and 100")]
   public int Price { get; set; }

4. [RegularExpression]：

   • 用于指定字符串属性的正则表达式验证。

   [RegularExpression(@"^[a-zA-Z0-9]+$", ErrorMessage = "Invalid characters in the code")]
   public string ProductCode { get; set; }

5. [Compare]：

   • 用于比较两个属性的值，通常用于确认密码等场景。

   [Compare("Password", ErrorMessage = "Password and Confirm Password must match")]
   public string ConfirmPassword { get; set; }

6. [EmailAddress]：

   • 用于验证电子邮件地址的格式。

   [EmailAddress(ErrorMessage = "Invalid email address")]
   public string Email { get; set; }

7. [DataType]：

   • 用于指定属性的数据类型。

   [DataType(DataType.Date, ErrorMessage = "Invalid date format")]
   public DateTime BirthDate { get; set; }

8. [CustomValidation]：

   • 用于自定义验证逻辑，需要指定验证方法的名称。

   [CustomValidation(typeof(CustomValidator), "ValidateProductName")]
   public string ProductName { get; set; }

这些数据验证注解通过在Models类的属性上使用，提供了一种声明性的方式来定义数据验证规则。在运行时，ASP.NET Core MVC框架会根据这些注解来执行相应的验证，并将验证结果反馈给开发人员或用户。这有助于确保应用程序接收到有效和符合要求的数据。

二、数据绑定基础

2.1 数据绑定概述

数据绑定是将用户界面（View）上的控件和数据模型（Model）之间建立关联的过程。在ASP.NET Core MVC中，数据绑定允许开发人员以一种简单而灵活的方式将HTTP请求中的数据映射到应用程序的模型对象中，同时也可以将模型对象中的数据传递给用户界面。

以下是数据绑定的概述：

1. 输入数据绑定：
   • 输入数据绑定是将用户提交的数据映射到控制器的动作方法参数或模型中的过程。
   • ASP.NET Core MVC框架通过模型绑定器（Model Binder）来执行输入数据绑定的任务。
   • 控制器的动作方法可以直接接收参数，或者通过在方法参数上使用 [FromBody]、[FromQuery]等特性来指定数据来源。
2. 模型绑定：
   • 模型绑定是将模型对象与HTTP请求中的数据进行关联的过程。
   • 在控制器的动作方法中，可以通过参数接收模型对象，并通过模型绑定器将请求数据映射到该模型对象中。
   • 模型绑定器会自动尝试将请求数据与模型对象的属性进行匹配。
3. 输出数据绑定：
   • 输出数据绑定是将模型对象中的数据传递到用户界面的过程。
   • 在视图（View）中，可以通过@model指令声明绑定到视图的模型类型。
   • Razor视图引擎通过模型对象的属性进行输出数据绑定，将模型中的数据渲染到HTML中。
4. 显式数据绑定：
   • 在某些情况下，开发人员可能需要显式地执行数据绑定操作，而不依赖于框架的自动绑定。
   • 这可以通过在控制器中手动调用 TryUpdateModel 或 UpdateModel 方法来实现。
5. 自定义模型绑定：
   • ASP.NET Core MVC允许开发人员创建自定义的模型绑定器，以满足特定的业务需求。
   • 通过实现 IModelBinder 接口，可以创建自定义的绑定器，并在应用程序配置中注册它们。
6. 复杂对象绑定：
   • 数据绑定支持复杂对象，包括嵌套对象、集合和数组。
   • 框架会尝试递归地将请求数据映射到复杂对象的所有层次。

数据绑定是ASP.NET Core MVC中重要的机制之一，它简化了处理用户输入和管理模型数据的过程，同时提供了灵活性和可扩展性，使开发人员能够更容易地构建出强大而高效的Web应用程序。

2.2 基本数据绑定

在ASP.NET Core MVC中，基本数据绑定涉及将用户提交的数据映射到控制器的动作方法参数或直接映射到模型中。以下是一些基本数据绑定的示例：

1. 从查询字符串获取数据（Query String）：

   public IActionResult Index([FromQuery] string searchTerm)
   {
       // 通过查询字符串获取数据
       // ...
       return View();
   }

   在这个例子中，searchTerm 参数使用 [FromQuery] 特性，表示它的值将从查询字符串中获取。

2. 从表单提交获取数据（Form Post）：

   [HttpPost]
   public IActionResult ProcessForm([FromBody] FormData formData)
   {
       // 通过表单提交获取数据
       // ...
       return View();
   }

   在这个例子中，ProcessForm 动作方法使用 [FromBody] 特性，表示它从请求的正文中获取数据，通常用于处理以 JSON 格式提交的数据。

3. 直接从路由获取数据：

   public IActionResult Details([FromRoute] int id)
   {
       // 直接从路由获取数据
       // ...
       return View();
   }

   在这个例子中，id 参数使用 [FromRoute] 特性，表示它的值将从路由中获取。

4. 从请求头获取数据：

   public IActionResult ProcessHeaders([FromHeader] string acceptLanguage)
   {
       // 从请求头获取数据
       // ...
       return View();
   }

   在这个例子中，acceptLanguage 参数使用 [FromHeader] 特性，表示它的值将从请求头中获取。

5. 从请求获取全部数据：

   public IActionResult ProcessRequest([FromForm] FormData formData, [FromQuery] string searchTerm)
   {
       // 通过表单和查询字符串获取数据
       // ...
       return View();
   }

   在这个例子中，ProcessRequest 方法同时接收表单数据和查询字符串数据。

这些例子展示了如何在控制器的动作方法中使用数据绑定特性，从不同的来源获取数据。ASP.NET Core MVC框架将负责在运行时将请求中的数据映射到指定的参数或模型对象中，使得开发人员可以方便地处理用户的输入。

2.3 复杂数据绑定

复杂数据绑定涉及将复杂对象、嵌套对象、集合或数组等数据结构映射到控制器的动作方法参数或模型中。ASP.NET Core MVC提供了强大的数据绑定功能，可以自动解析和映射这些复杂的数据结构。以下是一些示例：

1. 复杂对象绑定：
   假设有一个包含多个属性的复杂对象 Person：

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public Address Address { get; set; }
}

动作方法：

public IActionResult CreatePerson([FromBody] Person person)
{
    // 通过复杂对象绑定获取数据
    // ...
    return View();
}

在这个例子中，Person 对象包含了 Address 对象作为其属性，ASP.NET Core MVC框架会递归地执行数据绑定，将请求的数据映射到 Person 对象中。

2. 集合绑定：

假设有一个包含多个元素的集合：

public class Order
{
    public int OrderId { get; set; }
    public List<string> Items { get; set; }
}

动作方法：

public IActionResult ProcessOrder([FromBody] Order order)
{
    // 通过集合绑定获取数据
    // ...
    return View();
}

在这个例子中，Items 属性是一个字符串列表，ASP.NET Core MVC框架将尝试将请求中的数据映射到该列表中。

3. 数组绑定：

与集合绑定类似，但是对于数组类型的属性，也可以进行绑定：

public class ShoppingCart
{
    public int CartId { get; set; }
    public string[] Products { get; set; }
}

动作方法：

public IActionResult UpdateCart([FromBody] ShoppingCart cart)
{
    // 通过数组绑定获取数据
    // ...
    return View();
}

4. 嵌套对象绑定：
   在复杂对象中嵌套其他对象也是常见的场景，数据绑定会自动处理这种情况：

public class Book
{
    public string Title { get; set; }
    public Author Author { get; set; }
}

public class Author
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

动作方法：

public IActionResult AddBook([FromBody] Book book)
{
    // 通过嵌套对象绑定获取数据
    // ...
    return View();
}

这些例子展示了如何处理在ASP.NET Core MVC中进行复杂数据绑定，包括嵌套对象、集合和数组等不同类型的数据结构。框架在执行数据绑定时会自动识别和映射这些复杂的数据结构，使得开发人员能够更方便地处理和管理应用程序的数据。

2.4 视图中的模型绑定

在ASP.NET Core MVC中，视图中的模型绑定是指将控制器传递给视图的模型数据与视图中的元素进行关联的过程。通过模型绑定，视图能够轻松地显示控制器传递的模型数据，而无需手动处理每个数据项。以下是一些视图中的模型绑定的基本概念和示例：

1. 声明视图模型类型：
   在视图中，通过使用 @model 指令声明视图将要绑定的模型类型。这通常在视图的开头部分完成，指定视图的模型类型，例如：

@model YourNamespace.YourModelType

2. 模型数据绑定：
   一旦声明了模型类型，视图可以通过 Model 属性来访问模型中的数据，并将数据绑定到HTML元素。以下是一些示例：

<!-- 显示模型属性 -->
<h1>@Model.Title</h1>

<!-- 使用模型中的集合 -->
<ul>
    @foreach (var item in Model.Items)
    {
        <li>@item</li>
    }
</ul>

<!-- 使用模型中的嵌套对象 -->
<p>Author: @Model.Author.FirstName @Model.Author.LastName</p>

3. 表单绑定：
   在表单中，可以使用 HtmlHelper 的一些辅助方法来实现表单元素与模型属性的双向绑定。例如，使用 Html.EditorFor 或 Html.TextBoxFor：

@model YourNamespace.Person

<form asp-action="CreatePerson" method="post">
    <label asp-for="FirstName">First Name:</label>
    <input asp-for="FirstName" />

    <label asp-for="LastName">Last Name:</label>
    <input asp-for="LastName" />

    <button type="submit">Create Person</button>
</form>

在这个例子中，asp-for 属性用于建立视图中的元素与模型属性之间的关联。这样，当用户提交表单时，框架会自动将表单数据绑定到模型对象中。

4. 选择列表绑定：

使用 Html.DropDownListFor 辅助方法实现选择列表与模型属性的绑定：

@model YourNamespace.Student

<form asp-action="Enroll" method="post">
    <label asp-for="StudentId">Student:</label>
    <select asp-for="StudentId" asp-items="ViewBag.StudentList">
        <option>Please select</option>
    </select>

    <button type="submit">Enroll Student</button>
</form>

在这个例子中，asp-items 属性指定了选择列表的数据源，而 asp-for 属性将选择列表的值与模型属性进行关联。

通过这些模型绑定技术，视图能够轻松地与控制器中传递的模型数据进行交互，使开发人员能够更方便地呈现和处理用户界面。

三、输入验证

3.1 数据验证的重要性

数据验证在软件开发中非常重要，尤其在Web应用程序中更是至关重要。以下是数据验证的一些重要性：

1. 确保数据的有效性：
   • 数据验证有助于确保应用程序接收到的数据是有效和合法的。有效的数据符合应用程序的预期格式、范围和规则。
2. 防止恶意攻击：
   • 数据验证可以有效地防止恶意用户提交恶意数据，例如SQL注入、跨站脚本（XSS）攻击等。通过验证输入数据，可以减轻安全风险。
3. 提高数据完整性：
   • 数据验证确保数据的完整性，防止无效或缺失的数据进入数据库。这有助于保持数据的一致性，提高数据质量。
4. 减少错误和异常：
   • 通过在用户输入之前进行数据验证，可以减少由于错误输入而引起的异常。这有助于提高应用程序的稳定性和可靠性。
5. 改善用户体验：
   • 合适的数据验证提高了用户界面的友好性。通过在前端进行验证，用户能够更早地得知输入错误，而不是等到提交表单后才得知。
6. 降低后期成本：
   • 在开发阶段实施强大的数据验证可以降低维护和修复错误的成本。在开发过程中，及时解决和规避数据验证问题可以减少在生产环境中发生的错误。
7. 支持业务规则和逻辑：
   • 数据验证是实施业务规则和逻辑的关键步骤。通过验证数据，确保数据符合业务规则，有助于保持业务逻辑的一致性。
8. 遵循法规和标准：
   • 数据验证是遵循法规和行业标准的一部分。特定行业可能有数据保护和隐私方面的法规要求，数据验证有助于满足这些法规。

数据验证是构建健壮、安全和高质量应用程序的关键组成部分。通过在应用程序的各个层次进行细致的数据验证，可以提高系统的可维护性和稳定性，同时保护用户数据的安全性。

3.2 服务器端验证

服务器端验证是在Web应用程序的服务器端执行的一种数据验证形式。它是确保用户提交的数据符合应用程序要求和安全标准的重要手段。与客户端验证相比，服务器端验证更为可靠，因为客户端验证可以被绕过，而服务器端验证是在实际的服务器上执行的。以下是关于服务器端验证的一些关键方面：

1. 验证框架和库：

   • ASP.NET Core提供了一系列内置的验证框架和库，如 System.ComponentModel.DataAnnotations 命名空间，用于在服务器端执行验证。这包括一系列的验证特性，例如 [Required]、[StringLength]、[Range] 等，用于标记在模型类中的属性上。

2. 自定义验证规则：

   • 除了内置的验证特性外，开发人员还可以创建自定义的验证规则，以适应应用程序特定的验证需求。这通常涉及创建自定义验证特性或在服务器端验证逻辑中进行手动验证。

   public class CustomValidationAttribute : ValidationAttribute
   {
       protected override ValidationResult IsValid(object value, ValidationContext validationContext)
       {
           // 自定义验证逻辑
           // ...
   
           return ValidationResult.Success; // 或者返回 ValidationResult.Error
       }
   }

3. 在控制器中执行验证：

   • 在ASP.NET Core MVC中，服务器端验证通常在控制器的动作方法中执行。使用 ModelState 对象可以获取和处理验证结果，以便根据验证状态采取相应的行动。

   [HttpPost]
   public IActionResult Create([FromBody] YourModel model)
   {
       if (ModelState.IsValid)
       {
           // 处理有效的数据
           // ...
           return RedirectToAction("Success");
       }
       else
       {
           // 处理验证失败的情况
           // ...
           return View(model);
       }
   }

4. 返回验证错误信息：

   • 在服务器端验证失败时，通常需要将相应的错误信息返回给用户。这可以通过在 ModelState 对象中添加错误消息来实现。

   ModelState.AddModelError("PropertyName", "Error Message");

   然后，这些错误信息可以在视图中用于显示错误消息，以帮助用户正确填写表单或提交数据。

服务器端验证是保护应用程序免受无效数据影响的重要手段，尤其是在涉及敏感信息和关键业务逻辑的场景下。它是构建安全、稳定和符合规范的Web应用程序的关键组成部分。

3.3 客户端验证

客户端验证是在用户的浏览器上执行的一种数据验证形式，用于提供更即时的反馈和改进用户体验。虽然客户端验证是有益的，但由于安全性考虑，它不能替代服务器端验证。以下是客户端验证的一些关键方面：

1. 前端验证框架和库：

   • 常见的前端验证框架和库如 jQuery Validation、Validator.js、或是在框架中内建的验证机制（如在React中使用的Formik或在Angular中使用的Reactive Forms）等，它们提供了一系列验证规则、方法和事件，使得在客户端对用户输入进行验证更加方便。

2. HTML5表单验证：

   • HTML5引入了一些新的表单元素和属性，可以用于在客户端执行一些基本的验证，如 required、pattern、min、max 等。这使得可以在不使用JavaScript的情况下进行一些简单的客户端验证。

   <input type="text" name="username" required pattern="[a-zA-Z0-9]+" />

3. JavaScript验证：

   • 使用JavaScript编写客户端验证逻辑是一种常见的方式。通过在页面上嵌入JavaScript代码或通过外部脚本文件，可以在用户输入数据之前对其进行验证。

   <script>
       function validateForm() {
           var username = document.getElementById("username").value;
           if (username.length < 3) {
               alert("Username must be at least 3 characters long");
               return false;
           }
           return true;
       }
   </script>
   
   <form onsubmit="return validateForm()">
       <!-- form elements -->
   </form>

4. Ajax验证：

   • 使用Ajax技术，可以在不刷新整个页面的情况下向服务器发送验证请求。这使得可以在用户填写表单的同时异步地验证输入数据。

5. 即时反馈：

   • 客户端验证允许即时反馈，使用户在提交表单之前就能看到可能的错误信息。这有助于提高用户体验和减少用户填写无效数据的可能性。

客户端验证有助于提高用户体验，减轻服务器负担，并在用户输入之前快速捕获错误。然而，需要注意客户端验证不能替代服务器端验证，因为客户端验证可能被绕过或禁用，而服务器端验证是安全的最后一道防线，确保无论什么情况下都对数据进行正确验证。因此，综合使用客户端验证和服务器端验证是构建安全、稳定和用户友好的Web应用程序的最佳实践。

四、自定义绑定

4.1 自定义模型绑定器

在ASP.NET Core MVC中，可以通过自定义模型绑定器来实现特定类型的自定义绑定逻辑。模型绑定器负责将HTTP请求中的数据映射到控制器的参数或模型对象上。通过自定义模型绑定器，你可以适应应用程序特定的需求或处理特殊类型的绑定操作。以下是创建自定义模型绑定器的一般步骤：

1. 实现 IModelBinder 接口：

   • 创建一个类，并实现 IModelBinder 接口。这个接口包含一个方法 BindModelAsync，该方法用于执行绑定操作。

   public class CustomModelBinder : IModelBinder
   {
       public Task BindModelAsync(ModelBindingContext bindingContext)
       {
           // 在这里实现自定义的绑定逻辑
           // ...
   
           return Task.CompletedTask;
       }
   }

2. 注册自定义绑定器：

   • 在应用程序的启动配置中，通过 ModelBinderAttribute 或 ModelBinderProvider 注册自定义模型绑定器。

   [ModelBinder(BinderType = typeof(CustomModelBinder))]
   public class CustomModel
   {
       // 模型的属性
   }

   或者使用 ModelBinderProvider：

   public class CustomModelBinderProvider : IModelBinderProvider
   {
       public IModelBinder GetBinder(ModelBinderProviderContext context)
       {
           if (context.Metadata.ModelType == typeof(CustomModel))
           {
               return new CustomModelBinder();
           }
   
           return null;
       }
   }

3. 配置应用程序使用自定义绑定器：

   • 在 Startup.cs 文件的 ConfigureServices 方法中配置应用程序使用自定义模型绑定器。

   public void ConfigureServices(IServiceCollection services)
   {
       // 添加自定义模型绑定器提供程序
       services.AddMvc(options =>
       {
           options.ModelBinderProviders.Insert(0, new CustomModelBinderProvider());
       });
   }

4. 在控制器中使用自定义绑定器：

   • 在控制器的动作方法中使用自定义模型类型，并确保模型绑定器被应用。

   public IActionResult MyAction([ModelBinder(BinderType = typeof(CustomModelBinder))] CustomModel model)
   {
       // 在这里使用绑定后的模型
       // ...
       return View();
   }

通过自定义模型绑定器，你可以实现对特定类型的高度定制的绑定逻辑，从而更灵活地处理数据绑定的场景。这在处理非标准数据类型、解析复杂格式或执行额外的验证逻辑时非常有用。

4.2 自定义模型验证器

在ASP.NET Core MVC中，你可以通过自定义模型验证器来实现对模型中数据的自定义验证逻辑。模型验证器通常是在模型的属性上应用的验证特性，但有时你可能需要执行更复杂的验证，例如涉及多个属性的验证逻辑或依赖外部服务的验证。以下是创建自定义模型验证器的一般步骤：

1. 创建自定义验证器类：

   • 创建一个自定义的验证器类，通常继承自 ValidationAttribute 类。

   public class CustomValidationAttribute : ValidationAttribute
   {
       protected override ValidationResult IsValid(object value, ValidationContext validationContext)
       {
           // 在这里实现自定义的验证逻辑
           // ...
   
           return ValidationResult.Success; // 或者返回 ValidationResult.Error
       }
   }

2. 在模型中使用自定义验证器：

   • 在模型的属性上应用自定义验证器。

   public class CustomModel
   {
       [CustomValidation]
       public string CustomProperty { get; set; }
   }

3. 处理复杂的验证逻辑：

   • 在 IsValid 方法中，你可以访问当前验证的属性值以及整个模型的其他属性值。这使得可以实施更复杂的验证逻辑。

   public class CustomValidationAttribute : ValidationAttribute
   {
       protected override ValidationResult IsValid(object value, ValidationContext validationContext)
       {
           // 访问当前验证的属性值
           var currentValue = value;
   
           // 访问整个模型的其他属性值
           var model = (CustomModel)validationContext.ObjectInstance;
           var otherPropertyValue = model.OtherProperty;
   
           // 实施复杂的验证逻辑
           // ...
   
           return ValidationResult.Success; // 或者返回 ValidationResult.Error
       }
   }

4. 在视图中显示错误消息：

   • 在视图中使用 ValidationMessageFor 辅助方法或手动检查 ModelState 来显示验证错误消息。

   <div>
       @Html.LabelFor(model => model.CustomProperty)
       @Html.TextBoxFor(model => model.CustomProperty)
       @Html.ValidationMessageFor(model => model.CustomProperty)
   </div>

通过自定义模型验证器，你可以实现对模型中数据的高度定制的验证逻辑，从而满足特定的业务需求。这使得你能够更灵活地处理复杂的验证场景，确保应用程序接收到的数据符合业务规则和安全标准。

五、实例演练

假设有一个简单的模型类 Person：

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int Age { get; set; }
}

然后，在控制器中创建一个动作方法来处理表单提交：

public class DemoController : Controller
{
    [HttpGet]
    public IActionResult Index()
    {
        // 返回一个空的表单页面
        return View();
    }

    [HttpPost]
    public IActionResult Index(Person person)
    {
        // 处理表单提交，person 对象将通过模型绑定器自动填充
        if (ModelState.IsValid)
        {
            // 执行成功的逻辑
            return RedirectToAction("Success");
        }
        else
        {
            // 表单验证失败，返回原始页面并显示错误消息
            return View(person);
        }
    }

    public IActionResult Success()
    {
        // 成功页面
        return View();
    }
}

接下来，创建对应的视图文件。在 Views/Demo 目录下创建 Index.cshtml 和 Success.cshtml 文件：
Index.cshtml:

@model Person

<h2>Submit Form</h2>

@using (Html.BeginForm("Index", "Demo", FormMethod.Post))
{
    <div>
        <label asp-for="FirstName">First Name:</label>
        <input asp-for="FirstName" />
        <span asp-validation-for="FirstName"></span>
    </div>

    <div>
        <label asp-for="LastName">Last Name:</label>
        <input asp-for="LastName" />
        <span asp-validation-for="LastName"></span>
    </div>

    <div>
        <label asp-for="Age">Age:</label>
        <input asp-for="Age" />
        <span asp-validation-for="Age"></span>
    </div>

    <button type="submit">Submit</button>
}

Success.cshtml:

<h2>Form Submitted Successfully!</h2>
<p>Thank you for submitting the form.</p>

在这个例子中：

1. Index 动作方法包含两个版本，一个处理 GET 请求，返回一个用于提交表单的页面；另一个处理 POST 请求，接收表单数据并执行相应的逻辑。
2. Person 类是模型，其属性 FirstName、LastName 和 Age 与表单中的输入字段相匹配。
3. 表单中使用 asp-for 和 asp-validation-for 辅助方法来生成输入字段和验证错误消息。这将与模型绑定器协同工作，确保表单数据正确地绑定到 Person 对象。
4. 在 Index 的 POST 版本中，使用 ModelState.IsValid 来检查模型的验证状态。如果验证失败，会将用户重定向回原始表单页面，并显示相应的错误消息；如果验证成功，用户将被重定向到 Success 页面。

这个简单的例子涵盖了基本的模型和绑定概念，以及如何在控制器和视图中使用它们。在实际应用程序中，可以根据业务需求扩展这些概念，并使用更复杂的模型、验证器和绑定器。

六、最佳实践和注意事项

ASP.NET Core MVC是一个灵活、强大的框架，但在开发过程中，遵循一些佳实践和注意事项能够提高代码的质量、可维护性和性能。以下是一些ASP.NET Core MVC的佳实践和注意事项：

1. 遵循MVC模式：

   • 严格遵循MVC（Model-View-Controller）模式，将业务逻辑（模型）、用户界面（视图）和请求处理（控制器）分离。这样可以使代码更加模块化、可测试和可维护。

2. 使用依赖注入：

   • 使用ASP.NET Core的内置依赖注入容器，将服务注入到控制器、视图和其他组件中。依赖注入提高了代码的可测试性和可维护性，并促使良好的解耦。

3. 使用特性路由：

   • 使用特性路由（Attribute Routing）来定义路由，而不是传统的基于约定的路由。特性路由使得路由配置更加直观、灵活，并且能够更好地描述控制器和动作的关系。

4. 处理异常：

   • 实现全局异常处理，捕获未处理的异常，并提供友好的错误页面。这有助于提高应用程序的稳定性和用户体验。

5. 有效使用ViewModels：

   • 使用ViewModels来传递数据给视图，而不是直接将实体模型传递给视图。这有助于防止过多的数据暴露给前端，同时也能更好地适应视图的需求。

6. 安全性和防范攻击：

   • 始终对用户输入进行验证和编码，以防范跨站脚本（XSS）攻击、SQL注入等安全问题。使用内置的特性（例如 [ValidateAntiForgeryToken]）来增加安全性。

7. 启用HTTPS：

   • 将应用程序配置为使用HTTPS，以确保数据在传输过程中的安全性。这可以通过在 Startup.cs 中启用HTTPS：

   public void ConfigureServices(IServiceCollection services)
   {
       services.AddHttpsRedirection(options =>
       {
           options.HttpsPort = 443;
       });
   }

8. 缓存和性能优化：

   • 使用适当的缓存机制来提高性能。ASP.NET Core提供了缓存中间件，可以用于在应用程序中实现缓存。

9. 定期更新依赖项：

   • 定期更新应用程序的NuGet包和依赖项，以确保使用最新的稳定版本。这有助于修复潜在的漏洞和保持应用程序的健康状态。

10. 单元测试：

    • 编写并运行单元测试来验证控制器、服务和其他组件的行为。这有助于快速发现和修复问题，并确保代码的可靠性。

11. 使用Middleware：

    • 使用中间件来处理应用程序中的各种功能，如身份验证、授权、日志记录等。这有助于将应用程序的功能模块化、可复用，并提高可维护性。

这些是一些通用的ASP.NET Core MVC的佳实践和注意事项。根据具体项目的需求和规模，可能还需要进一步考虑其他方面的最佳实践，例如分布式缓存、日志记录策略等。在开发过程中，保持对官方文档和社区最佳实践的关注也是非常重要的。

七、总结

ASP.NET Core MVC是一个强大而灵活的Web应用程序框架，它采用MVC模式，通过模型、视图和控制器的分离促进了代码的模块化和可维护性。在实践中，我们学到了创建模型、数据绑定、服务器端和客户端验证、自定义模型绑定器和验证器等基础概念。通过建立良好的MVC结构，有效使用依赖注入、特性路由和ViewModels，我们能够构建健壮、安全、可维护的应用程序。同时，采用HTTPS、异常处理、缓存和性能优化等实践可提高应用程序的安全性和性能。总体而言，ASP.NET Core MVC提供了一系列的最佳实践和注意事项，以帮助开发者构建现代、可靠的Web应用。