From f5ac67670117b1abdc22ff8b23a0379bcc7abed1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BC=A0=E5=A9=89=E5=A9=B7?=
 <14091842+dreaming-of-becoming-a-fupo@user.noreply.gitee.com>
Date: Mon, 25 Nov 2024 01:53:05 +0800
Subject: [PATCH] =?UTF-8?q?11.20=E4=BD=9C=E4=B8=9A=E7=AC=94=E8=AE=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...60\346\215\256\347\273\221\345\256\232.md" |  66 +++
 ...40\351\200\222\345\217\202\346\225\260.md" |  87 ++++
 .../20241120-MVC\347\273\203\344\271\240.md"  | 418 ++++++++++++++++++
 3 files changed, 571 insertions(+)
 create mode 100644 "\345\274\240\345\251\211\345\251\267/20241118-MVC\346\241\206\346\236\266\345\222\214\346\225\260\346\215\256\347\273\221\345\256\232.md"
 create mode 100644 "\345\274\240\345\251\211\345\251\267/20241120-MVC\346\200\216\344\271\210\344\274\240id \346\200\216\344\271\210\344\274\240\351\200\222\345\217\202\346\225\260.md"
 create mode 100644 "\345\274\240\345\251\211\345\251\267/20241120-MVC\347\273\203\344\271\240.md"

diff --git "a/\345\274\240\345\251\211\345\251\267/20241118-MVC\346\241\206\346\236\266\345\222\214\346\225\260\346\215\256\347\273\221\345\256\232.md" "b/\345\274\240\345\251\211\345\251\267/20241118-MVC\346\241\206\346\236\266\345\222\214\346\225\260\346\215\256\347\273\221\345\256\232.md"
new file mode 100644
index 0000000..0e77ece
--- /dev/null
+++ "b/\345\274\240\345\251\211\345\251\267/20241118-MVC\346\241\206\346\236\266\345\222\214\346\225\260\346\215\256\347\273\221\345\256\232.md"
@@ -0,0 +1,66 @@
+# 一、Models
+## 1.1 Models的定义和作用
+- 在ASP.NET Core MVC中，Model是应用程序中用于表示数据结构和业务逻辑的一种抽象。Models充当了MVC（Model-View-Controller）模式中的“M”（Model）部分，负责管理应用程序的数据、状态和业务规则。以下是Models的定义和作用：
+
+- 定义：
+1. 数据结构： Models定义了应用程序中的数据结构，包括实体、对象和数据字段。
+2.业务逻辑： Models包含与数据相关的业务规则，例如验证规则、计算逻辑和数据转换。
+3. 作用：
+    1. 数据表示： Models是数据在应用程序中的逻辑表示。它们定义了数据的组织方式，使其更易于理解和处理。
+    2. 业务规则： Models中包含的业务逻辑规则确保数据的有效性、完整性和一致性。
+    3. 状态管理： Models可以跟踪应用程序中的状态变化，使得能够更好地管理数据的生命周期。
+    4. 数据验证： Models中定义的验证规则用于验证用户输入，确保输入的数据符合应用程序的期望。
+    5. 模型绑定： Models通过模型绑定将用户提交的数据映射到控制器中，实现了用户请求和应用程序数据的解耦。
+- 通过定义和使用Models，开发人员能够更清晰地组织和管理应用程序的数据，提高代码的可维护性和可测试性。 Models的作用不仅仅是存储数据，还包括在应用程序中对数据进行操作和管理的一系列任务。
+
+
+# 二、数据绑定基础
+## 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应用程序。
+
+
+# 三、输入验证
+## 3.1 数据验证的重要性
+- 数据验证在软件开发中非常重要，尤其在Web应用程序中更是至关重要。以下是数据验证的一些重要性：
+
+1. 确保数据的有效性：
+    - 数据验证有助于确保应用程序接收到的数据是有效和合法的。有效的数据符合应用程序的预期格式、范围和规则。
+2. 防止恶意攻击：
+    - 数据验证可以有效地防止恶意用户提交恶意数据，例如SQL注入、跨站脚本（XSS）攻击等。通过验证输入数据，可以减轻安全风险。
+3. 提高数据完整性：
+    - 数据验证确保数据的完整性，防止无效或缺失的数据进入数据库。这有助于保持数据的一致性，提高数据质量。
+4. 减少错误和异常：
+    - 通过在用户输入之前进行数据验证，可以减少由于错误输入而引起的异常。这有助于提高应用程序的稳定性和可靠性。
+5. 改善用户体验：
+    - 合适的数据验证提高了用户界面的友好性。通过在前端进行验证，用户能够更早地得知输入错误，而不是等到提交表单后才得知。
+6. 降低后期成本：
+    - 在开发阶段实施强大的数据验证可以降低维护和修复错误的成本。在开发过程中，及时解决和规避数据验证问题可以减少在生产环境中发生的错误。
+7. 支持业务规则和逻辑：
+    - 数据验证是实施业务规则和逻辑的关键步骤。通过验证数据，确保数据符合业务规则，有助于保持业务逻辑的一致性。
+8. 遵循法规和标准：
+    - 数据验证是遵循法规和行业标准的一部分。特定行业可能有数据保护和隐私方面的法规要求，数据验证有助于满足这些法规。
+    - 数据验证是构建健壮、安全和高质量应用程序的关键组成部分。通过在应用程序的各个层次进行细致的数据验证，可以提高系统的可维护性和稳定性，同时保护用户数据的安全性。
\ No newline at end of file
diff --git "a/\345\274\240\345\251\211\345\251\267/20241120-MVC\346\200\216\344\271\210\344\274\240id \346\200\216\344\271\210\344\274\240\351\200\222\345\217\202\346\225\260.md" "b/\345\274\240\345\251\211\345\251\267/20241120-MVC\346\200\216\344\271\210\344\274\240id \346\200\216\344\271\210\344\274\240\351\200\222\345\217\202\346\225\260.md"
new file mode 100644
index 0000000..9737ad8
--- /dev/null
+++ "b/\345\274\240\345\251\211\345\251\267/20241120-MVC\346\200\216\344\271\210\344\274\240id \346\200\216\344\271\210\344\274\240\351\200\222\345\217\202\346\225\260.md"	
@@ -0,0 +1,87 @@
+## 在ASP.NET MVC中，传递参数和ID可以通过多种方式实现
+
+1. **通过路由参数传递**：
+   你可以在控制器的Action方法中直接定义参数，框架会自动从URL路由中获取相应的值。
+   ```csharp
+   public ActionResult Details(int id)
+   {
+       // id 参数将从 URL 如 /Home/Details/123 中获取
+   }
+   ```
+   参考：[ASP.NET MVC5中View-Controller间数据的传递]
+
+2. **通过表单提交传递参数**：
+   当使用表单提交数据时，可以通过表单字段的`name`属性与Action方法的参数名匹配来传递参数。
+   ```csharp
+   [HttpPost]
+   public ActionResult Save(string username, int age)
+   {
+       // 这里的参数将从表单中获取
+   }
+   ```
+   参考：[ASP.NET MVC页面传值方式总结]
+
+3. **通过模型对象传递参数**：
+   你可以创建一个模型类，并在Action方法中使用该模型作为参数，MVC会自动将表单数据绑定到模型对象上。
+   ```csharp
+   public class UserInfoViewModel
+   {
+       public string Username { get; set; }
+       public int Age { get; set; }
+   }
+   
+   [HttpPost]
+   public ActionResult Save(UserInfoViewModel model)
+   {
+       // 使用model对象
+   }
+   ```
+   参考：[ASP.NET MVC页面传值方式总结]
+
+4. **通过FormCollection传递参数**：
+   当需要手动解析表单数据时，可以使用`FormCollection`。
+   ```csharp
+   [HttpPost]
+   public ActionResult Save(FormCollection fc)
+   {
+       string username = fc["username"];
+       int age = Convert.ToInt32(fc["age"]);
+       // 手动从FormCollection中获取参数
+   }
+   ```
+   参考：[ASP.NET MVC页面传值方式总结]
+
+5. **通过Query String传递参数**：
+   通过URL的查询字符串传递参数，然后在Action方法中通过`Request.QueryString`获取。
+   ```csharp
+   public ActionResult Search(string query)
+   {
+       // 从URL如 /Home/Search?query=example 中获取query参数
+   }
+   ```
+   参考：[ASP.NET MVC中几种常用传参方式以及在后台中获取客户端请求参数值]
+
+6. **通过TempData传递参数**：
+   `TempData`可以在同一个控制器的不同Action之间传递数据，通常用于重定向时传递信息。
+   ```csharp
+   TempData["message"] = "User created successfully";
+   return RedirectToAction("Index");
+   ```
+   然后在下一个Action中：
+   ```csharp
+   string message = TempData["message"];
+   ```
+   参考：[ASP.NET MVC5中View-Controller间数据的传递]
+
+7. **通过重定向传递参数**：
+   使用`RedirectToAction`时，可以直接传递参数到另一个Action。
+   ```csharp
+   return RedirectToAction("Details", new { id = 123 });
+   ```
+   在目标Action中接收：
+   ```csharp
+   public ActionResult Details(int id)
+   {
+       // 使用id参数
+   }
+   ```
\ No newline at end of file
diff --git "a/\345\274\240\345\251\211\345\251\267/20241120-MVC\347\273\203\344\271\240.md" "b/\345\274\240\345\251\211\345\251\267/20241120-MVC\347\273\203\344\271\240.md"
new file mode 100644
index 0000000..d014024
--- /dev/null
+++ "b/\345\274\240\345\251\211\345\251\267/20241120-MVC\347\273\203\344\271\240.md"
@@ -0,0 +1,418 @@
+## 1.创建一个控制台项目，没有任何选项，体会项目名称和什么有关系
+```
+dotnet new console -n MyConsoleApp
+```
+## 2.创建一个控制项目，项目名称Blog
+```
+dotnet new console -n Blog
+```
+## 3.创建一个控制台项目，输出到Blog目录
+```
+mkdir Blog && cd Blog
+dotnet new console
+```
+## 4.创建一个MVC项目，指定项目名称
+```
+dotnet new mvc -n MyMvcApp
+```
+## 5.创建一个MVC项目，指定输出目录
+```
+mkdir MyMvcApp 
+ cd MyMvcApp
+dotnet new mvc
+```
+## 6.创建一个带解决方案，其下有一个MVC项目，3个类库项目的“综合项目”
+```
+dotnet new sln -n MySolution
+dotnet new mvc -n MyMvcApp
+dotnet sln add MyMvcApp/MyMvcApp.csproj
+dotnet new classlib -n MyClassLib1
+dotnet new classlib -n MyClassLib2
+dotnet new classlib -n MyClassLib3
+dotnet sln add MyClassLib1/MyClassLib1.csproj
+dotnet sln add MyClassLib2/MyClassLib2.csproj
+dotnet sln add MyClassLib3/MyClassLib3.csproj
+```
+## 7..创建一个项目，在默认控制器（Home）下，新增一个Action方法，名为Ok，同时为其创建对应视图以显示这个视图
+```
+dotnet new mvc -n MyMvcApp
+cd MyMvcApp
+dotnet add package Microsoft.VisualStudio.Web.CodeGeneration.Design
+dotnet aspnet-codegenerator controller -name HomeController -actions Ok
+```
+
+## 8. 创建一个项目，创建一个新的控制器，名为Blogs，新的控制器拥有一个名为Index的Action，该方法返回一个视图，视图显示“神级预判”
+
+1. **创建 ASP.NET Core MVC 项目**：
+   - 打开 VSCode。
+   - 打开终端（Terminal -> New Terminal）。
+   - 输入以下命令创建一个新的 ASP.NET Core MVC 项目：
+     ```
+     dotnet new mvc -n MyBlogsProject
+     ```
+   - 进入项目目录：
+     ```
+     cd MyBlogsProject
+     ```
+
+2. **创建 Blogs 控制器**：
+   - 在项目目录中，使用命令行创建一个新的控制器：
+     ```
+     dotnet new controller -n Blogs
+     ```
+   - 这将在 `Controllers` 文件夹下创建一个名为 `BlogsController.cs` 的新控制器文件。
+
+3. **编辑 Blogs 控制器**：
+   - 打开 `BlogsController.cs` 文件。
+   - 添加一个新的 `Index` Action 方法，该方法返回一个视图显示“神级预判”：
+     ```csharp
+     using Microsoft.AspNetCore.Mvc;
+
+     namespace MyBlogsProject.Controllers
+     {
+         public class BlogsController : Controller
+         {
+             public IActionResult Index()
+             {
+                 return View();
+             }
+         }
+     }
+     ```
+
+4. **创建视图**：
+   - 在 `Views` 文件夹下创建一个新的文件夹 `Blogs`。
+   - 在 `Views/Blogs` 文件夹下创建一个新的视图文件 `Index.cshtml`。
+   - 编辑 `Index.cshtml` 文件，添加以下内容：
+     ```html
+     @{
+         ViewData["Title"] = "神级预判";
+     }
+
+     <h2>@ViewData["Title"]</h2>
+     ```
+
+5. **配置路由**：
+   - 确保 `Startup.cs` 中的路由配置正确。ASP.NET Core MVC 默认使用属性路由，所以不需要额外配置。
+
+6. **运行项目**：
+   - 在终端中运行以下命令启动项目：
+     ```
+     dotnet run
+     ```
+   - 打开浏览器，访问 `http://localhost:5000/blogs`，你将看到显示“神级预判”的页面。
+
+
+
+## 9. 给第8题的新控制，添加一个新的Action，名为Music，不接受任何参数，并返回对应的视图，视图显示“顶级打野”
+
+ 继续在8.的 ASP.NET Core MVC 项目中进行操作，我们将添加一个新的 `Music` Action 方法到 `Blogs` 控制器，并创建相应的视图。以下是详细步骤：
+
+ - . 创建 `Blogs` 控制器和 `Index` Action
+
+如果你已经完成了步骤 1 至 7，那么 `Blogs` 控制器和 `Index` Action 应该已经创建好了。如果没有，请参考之前的步骤。
+
+-  添加 `Music` Action
+
+1. **编辑 `BlogsController.cs`**：
+   - 打开 `Controllers/BlogsController.cs` 文件。
+   - 在 `Blogs` 控制器中添加一个新的 `Music` Action 方法，该方法返回一个视图显示“顶级打野”：
+     ```csharp
+     using Microsoft.AspNetCore.Mvc;
+
+     namespace MyBlogsProject.Controllers
+     {
+         public class BlogsController : Controller
+         {
+             public IActionResult Index()
+             {
+                 return View();
+             }
+
+             public IActionResult Music()
+             {
+                 return View();
+             }
+         }
+     }
+     ```
+
+2. **创建 `Music` 视图**：
+   - 在 `Views/Blogs` 文件夹下创建一个新的视图文件 `Music.cshtml`。
+   - 编辑 `Music.cshtml` 文件，添加以下内容：
+     ```html
+     @{
+         ViewData["Title"] = "顶级打野";
+     }
+
+     <h2>@ViewData["Title"]</h2>
+     ```
+
+3. **配置路由**：
+   - 确保 `Startup.cs` 中的路由配置正确。ASP.NET Core MVC 默认使用属性路由，所以不需要额外配置。
+
+4. **运行项目**：
+   - 在终端中运行以下命令启动项目：
+     ```
+     dotnet run
+     ```
+   - 打开浏览器，访问 `http://localhost:5000/blogs/music`，你将看到显示“顶级打野”的页面。
+
+以上步骤将在你的 ASP.NET Core MVC 项目中添加一个新的 `Music` Action 方法到 `Blogs` 控制器，并创建相应的视图显示“顶级打野”。这样，你就完成了两个 Action 方法的添加，分别显示不同的信息。
+
+
+## 10.给第8题的新控制器，新增一个Action，名为List，不接受任何参数，并返回对应视图，视图显示一个经典CRUD界面
+
+要创建一个 ASP.NET Core MVC 项目，并在其中添加一个名为 `Blogs` 的控制器，以及 `Index` 和 `List` 两个 Action 方法，其中 `Index` 显示“神级预判”，`List` 显示一个经典 CRUD（创建、读取、更新、删除）界面的视图，可以按照以下步骤操作：
+
+### 步骤 1: 创建 ASP.NET Core MVC 项目
+
+1. 打开 Visual Studio Code。
+2. 打开集成终端（Terminal -> New Terminal）。
+3. 输入以下命令创建一个新的 ASP.NET Core MVC 项目：
+   ```bash
+   dotnet new mvc -n MyBlogsProject
+   ```
+4. 进入项目目录：
+   ```bash
+   cd MyBlogsProject
+   ```
+
+### 步骤 2: 创建 Blogs 控制器
+
+1. 在项目目录中，使用命令行创建一个新的控制器：
+   ```bash
+   dotnet new controller -n Blogs
+   ```
+2. 这将在 `Controllers` 文件夹下创建一个名为 `BlogsController.cs` 的新控制器文件。
+
+### 步骤 3: 编辑 Blogs 控制器
+
+1. 打开 `Controllers/BlogsController.cs` 文件。
+2. 添加 `Index` 和 `List` Action 方法：
+   ```csharp
+   using Microsoft.AspNetCore.Mvc;
+
+   namespace MyBlogsProject.Controllers
+   {
+       public class BlogsController : Controller
+       {
+           public IActionResult Index()
+           {
+               return View();
+           }
+
+           public IActionResult List()
+           {
+               return View();
+           }
+       }
+   }
+   ```
+
+### 步骤 4: 创建 Index 视图
+
+1. 在 `Views` 文件夹下创建一个新的文件夹 `Blogs`（如果还没有的话）。
+2. 在 `Views/Blogs` 文件夹下创建一个新的视图文件 `Index.cshtml`。
+3. 编辑 `Index.cshtml` 文件，添加以下内容：
+   ```html
+   @{
+       ViewData["Title"] = "神级预判";
+   }
+
+   <h2>@ViewData["Title"]</h2>
+   ```
+
+### 步骤 5: 创建 List 视图
+
+1. 在 `Views/Blogs` 文件夹下创建一个新的视图文件 `List.cshtml`。
+2. 编辑 `List.cshtml` 文件，添加以下内容以模拟一个简单的 CRUD 界面：
+   ```html
+   @{
+       ViewData["Title"] = "CRUD 界面";
+   }
+
+   <h2>@ViewData["Title"]</h2>
+   <p>这里是 CRUD 操作的列表视图。</p>
+   <!-- 这里可以添加表格、表单等元素来实现 CRUD 功能 -->
+   ```
+
+### 步骤 6: 配置路由
+
+1. 打开 `Startup.cs` 文件。
+2. 确保 `Configure` 方法中的路由配置正确。ASP.NET Core MVC 默认使用属性路由，所以不需要额外配置。
+
+### 步骤 7: 运行项目
+
+1. 在终端中运行以下命令启动项目：
+   ```bash
+   dotnet run
+   ```
+2. 打开浏览器，访问 `http://localhost:5000/blogs/index` 查看 `Index` 视图，显示“神级预判”。
+3. 访问 `http://localhost:5000/blogs/list` 查看 `List` 视图，显示一个简单的 CRUD 界面。
+
+以上步骤将创建一个 ASP.NET Core MVC 项目，其中包含一个 `Blogs` 控制器，以及两个 Action 方法 `Index` 和 `List`，分别返回显示不同信息的视图。`List` 视图目前只是一个静态页面，实际的 CRUD 功能需要进一步开发，包括数据库操作和表单处理等。
+
+
+## 11.新增一个控制器，名为Products，该控制器具有一个名为Edit的Action，这个Action接受一个int类型的参数id，显示这个id
+
+
+
+要创建一个新的名为 `Products` 的控制器，并添加一个名为 `Edit` 的 Action 方法，该方法接受一个 `int` 类型的参数 `id` 并显示这个 `id`，可以按照以下步骤操作：
+
+### 步骤 1: 创建 Products 控制器
+
+1. 打开 Visual Studio Code。
+2. 打开集成终端（Terminal -> New Terminal）。
+3. 确保你已经在 `MyBlogsProject` 项目目录中。
+4. 使用命令行创建一个新的控制器：
+   ```bash
+   dotnet new controller -n Products
+   ```
+5. 这将在 `Controllers` 文件夹下创建一个名为 `ProductsController.cs` 的新控制器文件。
+
+### 步骤 2: 编辑 Products 控制器
+
+1. 打开 `Controllers/ProductsController.cs` 文件。
+2. 添加 `Edit` Action 方法，该方法接受一个 `int` 类型的参数 `id`：
+   ```csharp
+   using Microsoft.AspNetCore.Mvc;
+
+   namespace MyBlogsProject.Controllers
+   {
+       public class ProductsController : Controller
+       {
+           public IActionResult Edit(int id)
+           {
+               // 将 id 传递给视图
+               ViewData["ProductId"] = id;
+               return View();
+           }
+       }
+   }
+   ```
+
+### 步骤 3: 创建 Edit 视图
+
+1. 在 `Views` 文件夹下创建一个新的文件夹 `Products`（如果还没有的话）。
+2. 在 `Views/Products` 文件夹下创建一个新的视图文件 `Edit.cshtml`。
+3. 编辑 `Edit.cshtml` 文件，添加以下内容以显示传递的 `id`：
+   ```html
+   @{
+       ViewData["Title"] = "Edit Product";
+   }
+
+   <h2>@ViewData["Title"]</h2>
+   <p>Product ID: @ViewData["ProductId"]</p>
+   ```
+
+### 步骤 4: 配置路由
+
+1. 打开 `Startup.cs` 文件。
+2. 确保 `Configure` 方法中的路由配置正确。ASP.NET Core MVC 默认使用属性路由，所以不需要额外配置。
+
+### 步骤 5: 运行项目
+
+1. 在终端中运行以下命令启动项目：
+   ```bash
+   dotnet run
+   ```
+2. 打开浏览器，访问 `http://localhost:5000/products/edit/1`（将 `1` 替换为任何整数）查看 `Edit` 视图，显示传递的 `id`。
+
+以上步骤将创建一个 ASP.NET Core MVC 项目中的 `Products` 控制器，以及一个 `Edit` Action 方法，该方法接受一个 `int` 类型的参数 `id` 并显示这个 `id`。在 `Edit` 视图中，`id` 被存储在 `ViewData` 中，并在视图中显示。
+
+
+## 12. 在11题的新控制器中，新增一个名为Create的Action，该Action接受一个类型为Students（有姓名、年龄、体长属性）的参数，并展示该参数的姓名属性
+
+为了完成这个任务，我们需要先定义一个 `Students` 类型，然后在 `Products` 控制器中添加 `Edit` 和 `Create` 两个 Action 方法。以下是详细步骤：
+
+### 步骤 1: 定义 Students 类型
+
+1. 在项目中创建一个新的 C# 类文件，命名为 `Student.cs`。
+2. 定义 `Student` 类，包含姓名、年龄和体长属性：
+   ```csharp
+   namespace MyBlogsProject.Models
+   {
+       public class Student
+       {
+           public string Name { get; set; }
+           public int Age { get; set; }
+           public double Height { get; set; }
+       }
+   }
+   ```
+
+### 步骤 2: 创建 Products 控制器
+
+如果还没有创建 `Products` 控制器，请按照以下命令创建：
+
+```bash
+dotnet new controller -n Products
+```
+
+### 步骤 3: 编辑 Products 控制器
+
+1. 打开 `Controllers/ProductsController.cs` 文件。
+2. 添加 `Edit` 和 `Create` Action 方法：
+   ```csharp
+   using Microsoft.AspNetCore.Mvc;
+   using MyBlogsProject.Models; // 确保添加了这个命名空间
+
+   namespace MyBlogsProject.Controllers
+   {
+       public class ProductsController : Controller
+       {
+           public IActionResult Edit(int id)
+           {
+               ViewData["ProductId"] = id;
+               return View();
+           }
+
+           public IActionResult Create(Student student)
+           {
+               // 将 student 的姓名传递给视图
+               ViewData["StudentName"] = student.Name;
+               return View();
+           }
+       }
+   }
+   ```
+
+### 步骤 4: 创建 Edit 视图
+
+1. 在 `Views/Products` 文件夹下创建一个新的视图文件 `Edit.cshtml`。
+2. 编辑 `Edit.cshtml` 文件，添加以下内容以显示传递的 `id`：
+   ```html
+   @{
+       ViewData["Title"] = "Edit Product";
+   }
+
+   <h2>@ViewData["Title"]</h2>
+   <p>Product ID: @ViewData["ProductId"]</p>
+   ```
+
+### 步骤 5: 创建 Create 视图
+
+1. 在 `Views/Products` 文件夹下创建一个新的视图文件 `Create.cshtml`。
+2. 编辑 `Create.cshtml` 文件，添加以下内容以显示 `Student` 的姓名属性：
+   ```html
+   @{
+       ViewData["Title"] = "Create Product";
+   }
+
+   <h2>@ViewData["Title"]</h2>
+   <p>Student Name: @ViewData["StudentName"]</p>
+   ```
+
+### 步骤 6: 配置路由
+
+确保 `Startup.cs` 中的路由配置正确。ASP.NET Core MVC 默认使用属性路由，所以不需要额外配置。
+
+### 步骤 7: 运行项目
+
+1. 在终端中运行以下命令启动项目：
+   ```bash
+   dotnet run
+   ```
+2. 打开浏览器，访问 `http://localhost:5000/products/edit/1`（将 `1` 替换为任何整数）查看 `Edit` 视图，显示传递的 `id`。
+3. 访问 `http://localhost:5000/products/create` 并传递一个 `Student` 对象作为参数，例如，通过 POST 请求或直接在 URL 中传递一个 JSON 对象（这通常需要一个表单或 AJAX 请求）。
\ No newline at end of file
-- 
Gitee