diff --git "a/\345\272\267\345\273\272\346\242\205/20241122--Linux\343\200\201MVC\347\273\203\344\271\240\343\200\201\344\270\223\351\241\271\347\273\203\344\271\240-\346\216\247\345\210\266\345\231\250\344\274\240\345\217\202.md" "b/\345\272\267\345\273\272\346\242\205/20241122--Linux\343\200\201MVC\347\273\203\344\271\240\343\200\201\344\270\223\351\241\271\347\273\203\344\271\240-\346\216\247\345\210\266\345\231\250\344\274\240\345\217\202.md"
index b24062ace5ac85c3f2d5f71ba7775835506d5d16..16da1503883685a09bf80af3d349849d02792e38 100644
--- "a/\345\272\267\345\273\272\346\242\205/20241122--Linux\343\200\201MVC\347\273\203\344\271\240\343\200\201\344\270\223\351\241\271\347\273\203\344\271\240-\346\216\247\345\210\266\345\231\250\344\274\240\345\217\202.md"
+++ "b/\345\272\267\345\273\272\346\242\205/20241122--Linux\343\200\201MVC\347\273\203\344\271\240\343\200\201\344\270\223\351\241\271\347\273\203\344\271\240-\346\216\247\345\210\266\345\231\250\344\274\240\345\217\202.md"
@@ -1,5 +1,18 @@
 ## Linux练习
 
+### 第一个网站：kjm.kz0702.cn
+### 第二个网站：aaa.kz0702.cn
+### 第三个网站：bbb.kz0702.cn
+### 第四个网站：ccc.kz0702.cn
+### 第五个网站：ddd.kz0702.cn
+### 第六个网站：eee.kz0702.cn
+### 第七个网站：fff.kz0702.cn
+### 第八个网站：ggg.kz0702.cn
+### 第九个网站：hhh.kz0702.cn
+### 第十个网站：iii.kz0702.cn
+
+
+
 ## MVC练习
 1. 创建一个控制台项目，没有任何选项，体会项目名称和什么有关系
 ```cs
@@ -210,23 +223,425 @@ public class BlogController:Controller
 {
     public IActionResult Index(int id)
     {
-        return View();
+        return Content(id.Tostring());
     }
 }
 ```
 
 2. 简单参数传递 在一个叫Blog控制器中，定义一个叫Index_2的Action，并且传递一个string类型的值，id为变量名
+```cs
+public class BlogController:Controller
+{
+    public IActionResult Index_2(string id)
+    {
+        return Content(id.ToString())
+    }
+}
+```
 
 3. 简单参数传递 在一个叫Blog控制器中，定义一个叫Index_3的Action，并且传递一个string类型的值，name为变量名
-
+```cs
+public class BlogController:Controller
+{
+    public IActionResult Index_3(string name)
+    {
+        return Content(name.ToString());
+    }
+}
+```
 4. 复杂参数传递 在一个叫Blog的控制器中，定义一个名为Create的Action，并且传递一个BlogCreateDto类型的值，blogCreateDto为变量名
 
-    * PS BlogCreateDto类型具有Title、Author、Content自动属性
+    > * PS BlogCreateDto类型具有Title、Author、Content自动属性
+
+```cs
+
+public class BlogController:Controller
+{
+    [HttpGet]
+    public IActionResult Create()
+    {
+        return View();
+    }
+
+    [HttpPost]
+    public IActionResult Create(BlogCreateDto blogCreateDto)
+    {
+        return Content(
+            $"标题：{blogCreateDto.Title},作者：{blogCreateDto.Author}，内容：{blogCreateDto.Content}"
+        );
+    }
+}
+
+```
 
 5. 复杂参数传递 在一个叫Blog的控制器中，定义一个名为Create_1的Action，并且传递一个Products类型的值，productCreateDto为变量名
 
-    * PS Products类型具有Name、Price、Stock自动属性
+    > * PS Products类型具有Name、Price、Stock自动属性
+```cs
+public class BlogController:Controller
+{
+    [HttpGet]
+    public IActionResult Create_1()
+    {
+        return View();
+    }
+
+    [HttpPost]
+    public IActionResult Create_1(Products productCreateDto)
+    {
+        return Content(
+    > * PS Products类型具有Name、Price、Stock自动属性
+            $"名称：{productCreateDto.}，价格：{productCreateDto.Price}，库存：{productCreateDto.Stock}"
+        );
+    }
+}
+```
+
 
 6. 复杂参数传递 在一个叫Blog的控制器中，定义一个名为Create_2的Action，并且传递一个Students类型的值，studentCreateDto为变量名
 
-    * PS Students类型具有StudentName、Sex、Age自动属性
\ No newline at end of file
+    > * PS Students类型具有StudentName、Sex、Age自动属性
+```cs
+public class BlogController:Controller
+{
+    [HttpGet]
+    public IActionResult Create_2()
+    {
+        return View();
+    }
+    [HttpPost]
+    public IActionResult Create_2(Students studentCreateDto){
+        string StuSex;
+        if (studentCreateDto.Sex == true){
+            StuSex = "男";
+        }
+        else if (studentCreateDto.Sex == false){
+            StuSex = "女";
+        }
+        else{
+            StuSex = "null";
+        }
+        return Content($"姓名：{studentCreateDto.StudentName}，性别：{studentCreateDto.Sex}，年龄：{studentCreateDto.Age}");
+    }
+}
+```
+
+
+## 专项练习-基础能力
+1. 生成一个随机整数，范围[0,100]，注意是否包含
+```cs 
+public IActionResult GetRandom1()
+{
+    Random random = new Random();
+    return Content(random.Next(0,101).ToString());
+}
+```
+
+2. 生成一个随机整数，范围(0,100]，注意是否包含
+```cs
+public IActionResult GetRandom2()
+{
+    Random random = new Random();
+    return Content(random.Next(1,101).ToString());
+}
+```
+
+3. 生成10个随机整数，范围[5,80],注意是否包含
+```cs
+public IActionResult GetRandom3()
+{
+    Random random = new Random();
+    string text = "";
+
+    for (int i = 0;i < 10;i++)
+    {
+        text = text + random.Next(5,81)
+        if(i < 9)
+        {
+            text += "";
+        }
+    }
+    return Content(text);
+}
+```
+
+4. 定义一个字符串，字符串中有100个中文字符，需要从中随机取1个字符串
+```cs
+public IActionResult GetRandom4()
+{
+    string ChineseString = "天地人和日月星水火风土雷电云雨雪雾露霜草木花鸟鱼虫马牛羊鸡犬猪龙凤麒麟龟鹤鹿象狮虎豹狼猿熊蝶蛾蚊蝇蚁燕鹊鸽鸳鸯春夏秋冬梅兰竹菊松荷莲桂江河湖海溪涧瀑布山川丘陵原野草原沙漠森林岩石岛屿云雾雪霜雷电风雨日月星辰龙凤麒麟狮虎豹狼猿猴熊鹿马牛羊猪";
+    Random random = new Random();
+    int index = random.Next(ChineseString.Length);
+    return Content(ChineseString[index].Tostring());
+}
+
+
+```
+
+5. 定义一个字符串，字符串中有100个中文字符，需要从中随机取5-50个字符，组成新的字符
+```cs
+public IActionResult GetRandom5()
+{
+string ChineseString = "天地人和日月星水火风土雷电云雨雪雾露霜草木花鸟鱼虫马牛羊鸡犬猪龙凤麒麟龟鹤鹿象狮虎豹狼猿熊蝶蛾蚊蝇蚁燕鹊鸽鸳鸯春夏秋冬梅兰竹菊松荷莲桂江河湖海溪涧瀑布山川丘陵原野草原沙漠森林岩石岛屿云雾雪霜雷电风雨日月星辰龙凤麒麟狮虎豹狼猿猴熊鹿马牛羊猪";
+Random random = new Random();
+int RandomNumber = random.Next(5,51);
+string text = "";
+for (int i = 0;i < RandomNumber;i++)
+{
+    int index = random.Next(ChineseString.Length)
+    text += ChineseString[index].Tostring();
+    if (i < RandomNumber - 1)
+           {
+               text += " ";
+           }
+       }
+       return Content(text);
+}
+```
+
+6. 定义2个字符串，第一个字符串中放百家姓，第二个字符串中放中文字符，要求从第一个字符串随机取得一个姓，再从第二个字符串中随机获得1到2个字符组成新字符串，和第一个字符串取得的姓组成一个姓名
+```cs
+public IActionResult Random6(){
+    string LastNames = "赵钱孙李周吴郑王冯陈褚卫蒋沈韩杨朱秦尤许何吕施张孔曹严华金魏陶姜戚谢邹孟高林何马陶冯程严唐";
+    string Chinesewords = "天地人和日月星水火风土雷电云雨雪雾露霜草木花鸟鱼虫马牛羊鸡犬猪龙凤麒麟龟鹤鹿象狮虎豹狼猿熊蝶蛾蚊蝇蚁燕鹊鸽鸳鸯春夏秋冬梅兰竹菊松荷莲桂江河湖海溪涧瀑布山川丘陵原野草原沙漠森林岩石岛屿云雾雪霜雷电风雨日月星辰龙凤麒麟狮虎豹狼猿猴熊鹿马牛羊猪";
+
+    Random random = new Random();
+
+    int LastNameRandom = random.Next(LastNames.Length);
+    string LastNameText = LastNames[LastNameRandom].ToString();
+
+    string FirstNameText = "";
+
+    // 1-2个字符
+    int FirstNameRandomNumber = random.Next(1, 3);
+       for (int i = 0; i < FirstNameRandomNumber; i++)
+       {
+           int FirstNameRandom2 = random.Next(chineseChars.Length);
+           string FirstNameChar = chineseChars[FirstNameRandom2].ToString();
+   
+           FirstNameText += FirstNameChar;
+       }
+       return Content(LastNameText + FirstNameText);
+}
+```
+
+7. 利用以上方法，随机生成100个BlogCreateDto类型（有Title、Author、Content属性）的对象，其中的内容都是随机生成且长度不定，并将其渲染到视图
+```cs
+public IActionResult GetRandom7()
+{
+    string LastNames = "赵钱孙李周吴郑王冯陈褚卫蒋沈韩杨朱秦尤许何吕施张孔曹严华金魏陶姜戚谢邹孟高林何马陶冯程严唐";
+    string Chinesewords = "天地人和日月星水火风土雷电云雨雪雾露霜草木花鸟鱼虫马牛羊鸡犬猪龙凤麒麟龟鹤鹿象狮虎豹狼猿熊蝶蛾蚊蝇蚁燕鹊鸽鸳鸯春夏秋冬梅兰竹菊松荷莲桂江河湖海溪涧瀑布山川丘陵原野草原沙漠森林岩石岛屿云雾雪霜雷电风雨日月星辰龙凤麒麟狮虎豹狼猿猴熊鹿马牛羊猪";
+
+    Random random = new Random();
+   
+       // 定义一个列表用于存储100个随机生成的 BlogCreateDto
+       var blogList = new List<BlogCreateDto>();
+   
+       // 生成100个 BlogCreateDto 对象
+       for (int i = 0; i < 100; i++)
+       {
+           // 随机生成标题 Title
+           int titleLength = random.Next(5, 11);
+           string title = "";
+   
+           for (int t = 0; t < titleLength; t++)
+           {
+               int index = random.Next(Chinesewords.Length);
+               title += Chinesewords[index];
+           }
+   
+           // 随机生成作者 Author
+   
+           int LastNameRandom = random.Next(LastNames.Length);
+           string LastNameText = LastNames[LastNameRandom].ToString();
+   
+           string FirstNameText = "";
+           int FirstNameRandomNumber = random.Next(1, 3);
+           for (int j = 0; j < FirstNameRandomNumber; j++)
+           {
+               int FirstNameRandom2 = random.Next(Chinesewords.Length);
+               string FirstNameChar = Chinesewords[FirstNameRandom2].ToString();
+   
+               FirstNameText += FirstNameChar;
+           }
+           string author = LastNameText + FirstNameText;
+   
+           // 随机生成内容 Content
+           int randomContentLength = random.Next(20, 50);
+           string content = "";
+           for (int k = 0; k < randomContentLength; k++)
+           {
+               int contentIndex = random.Next(Chinesewords.Length);
+               content += Chinesewords[contentIndex].ToString();
+           }
+   
+           BlogCreateDto blog = new BlogCreateDto
+           {
+               Title = title,
+               Author = author,
+               Content = content
+           };
+   
+           blogList.Add(blog);
+       }
+   
+       return View(blogList);
+   
+}
+```
+
+
+## 专项练习-控制器返回值
+1. 渲染简单数据到页面
+在这个方法中，我们返回一个简单的字符串：
+
+   ```csharp
+   public IActionResult RenderSimpleData()
+   {
+       string message = "你好";
+       return Content(message);
+   }
+
+
+2. 渲染复杂数据到页面
+这个方法展示了如何将一个复杂的对象（如BlogCreateDto）渲染到页面。返回的内容包括该对象的各个属性。
+
+   ```csharp
+   public IActionResult RenderComplexData()
+   {
+       var blog = new BlogCreateDto
+       {
+           Title = "测试标题",
+           Author = "张三",
+           Content = "你好好好好"
+       };
+   
+       return Content($"标题: {blog.Title}, 作者: {blog.Author}, 内容: {blog.Content}");
+   }
+   ```
+3. 渲染集合数据到页面
+在这个方法中，我们通过一个 `foreach` 循环遍历集合中的每个 `BlogCreateDto` 对象，并将它们渲染成一个 HTML 格式的字符串返回到页面。
+
+   ```csharp
+   public IActionResult RenderCollectionData()
+   {
+       var blogs = new List<BlogCreateDto> {
+           new BlogCreateDto { Title = "标题1", Author = "作者1", Content = "丸子" },
+           new BlogCreateDto { Title = "标题2", Author = "作者2", Content = "老豬" },
+           new BlogCreateDto { Title = "标题3", Author = "作者3", Content = "丸子和老豬" }
+       };
+   
+       string result = "";
+   
+       foreach (var blog in blogs)
+       {
+           result += $"标题: {blog.Title}, 作者: {blog.Author}, 内容: {blog.Content} <br/>";
+       }
+   
+       return Content(result, "text/html; charset=utf-8");
+   }
+   ```
+
+## 专业项练习-视图及其模板引擎
+1. 渲染（展示）简单数据类型到视图
+
+
+- 在控制器中传递简单数据（如 `string`、`int` 等）到视图：
+
+```csharp
+public IActionResult ShowMessage()
+{
+    string message = "欢迎来到 ASP.NET Core MVC！";
+    return View(message);
+}
+```
+
+在视图中显示数据：
+
+```html
+<!-- ShowMessage.cshtml -->
+@model string
+<p>消息: @Model</p>
+```
+
+2. 渲染（展示）对象数据到视图
+
+- 在控制器中传递对象数据（如自定义类）到视图：
+
+```csharp
+public IActionResult ShowPerson()
+{
+    var person = new Person { Name = "Alice", Age = 30 };
+    return View(person);
+}
+```
+
+在视图中显示对象数据：
+
+```html
+<!-- ShowPerson.cshtml -->
+@model Person
+<p>姓名: @Model.Name</p>
+<p>年龄: @Model.Age</p>
+```
+
+3. 渲染（展示）集合数据到视图
+
+- 在控制器中传递集合数据（如 `List<>`）到视图：
+
+```csharp
+public IActionResult ShowItems()
+{
+    var items = new List<string> { "苹果", "香蕉", "橙子" };
+    return View(items);
+}
+```
+
+在视图中显示集合数据：
+
+```html
+<!-- ShowItems.cshtml -->
+@model List<string>
+<ul>
+    @foreach (var item in Model)
+    {
+        <li>@item</li>
+    }
+</ul>
+```
+
+4. 渲染（展示）包含集合数据的对象数据到视图
+
+- 在控制器中传递包含集合的对象数据到视图：
+
+```csharp
+public class Category
+{
+    public string Name { get; set; }
+    public List<string> Products { get; set; }
+}
+
+public IActionResult ShowCategory()
+{
+    var category = new Category
+    {
+        Name = "水果",
+        Products = new List<string> { "苹果", "香蕉", "橙子" }
+    };
+    return View(category);
+}
+```
+
+在视图中渲染包含集合的对象数据：
+
+```html
+<!-- ShowCategory.cshtml -->
+@model Category
+<h3>分类: @Model.Name</h3>
+<ul>
+    @foreach (var product in Model.Products)
+    {
+        <li>@product</li>
+    }
+</ul>
+```
diff --git "a/\345\272\267\345\273\272\346\242\205/20241125--MVC\346\250\241\345\274\217\347\247\215\345\270\270\350\247\201\347\232\204Action\347\232\204\350\277\224\345\233\236\345\200\274\347\261\273\345\236\213.md" "b/\345\272\267\345\273\272\346\242\205/20241125--MVC\346\250\241\345\274\217\347\247\215\345\270\270\350\247\201\347\232\204Action\347\232\204\350\277\224\345\233\236\345\200\274\347\261\273\345\236\213.md"
new file mode 100644
index 0000000000000000000000000000000000000000..330f3feccf07a8a3d2fcadbebc6aa1f3319bdc7c
--- /dev/null
+++ "b/\345\272\267\345\273\272\346\242\205/20241125--MVC\346\250\241\345\274\217\347\247\215\345\270\270\350\247\201\347\232\204Action\347\232\204\350\277\224\345\233\236\345\200\274\347\261\273\345\236\213.md"
@@ -0,0 +1,213 @@
+## Debian部署MVC（Asp.Net Core）的先决条件
+
+1. 在服务器上安装了运行环境或者调试环境（必要条件）
+    1. 如何安装SDK 包管理器
+         - 先下载个文件 wget curl
+         - 注册文件
+         - 删除那个已经注册过的文件
+         - 更新软件源 apt update
+         - 安装sdk apt install dotnet-sdk-8.0
+    2. 在Linux上安装软件或者应用常用方式如下：
+        1. 包管理器 (相对于用户来说最简单)
+        2.使用二进制文件安装 (相对于用户来说次简单)
+        3. 编译安装 (相对于用户来说最难)
+2. 将打包好的程序上传到指定目录（必要条件）
+    1. scp工具 scp-r ./* root@XXXX.XXX:/var/www/XXXX.XXX
+         - 打包 dotnet publish
+         - 测试（工作当中一般建议测试，可以视情况省略）
+         - 上传
+    2. xftp
+3. 一般建议使用nginx做反向代理（PS：如果不做反向代理，则这条可以不用）
+    1. 看一下上面的程序是否在网站当中：curl http://localhost:5000;
+    2. 为该网站配置文件（反向代理）
+        - 切换目录：cd /etc/nginx/conf.d
+        - 反向代理配置文件：
+        server{
+            listen 80;
+            server_name XXX.lcann.cn;
+            location / {
+                proxy_pass http:localhost:5000;
+            }
+        }
+        - 检查是否有语法错误：nginx -t
+        - 重新加载配置：nginx -s reload
+4. MVC模式种常见的Action的返回值类型
+
+    - 返回常见数据类型，如int、string、IList<>
+    - IActionResult,返回响应状态，如200、301、401、404、500等
+        - 视图
+        - 重定向
+    - ActionResult<>,可以同时返回状态码或者常规数据类型
+    - JsonResult、ContentResult，返回响应就是纯粹的数据
+    - POCO 可以返回一个对象，而这个对象在被返回的时候，会被序列化（相对应的是，反序列化）
+
+
+
+# ASP.NET MVC 控制器参数传递
+
+
+在ASP.NET MVC中，控制器是处理HTTP请求的核心组件。当用户请求某个URL时，控制器的某个Action方法会被调用，并返回一个响应。控制器方法可以接收来自URL、表单或者请求体的数据。根据参数的复杂度，可以将参数传递分为简单传参和复杂传参两类。
+
+## 1. 简单传参
+
+简单参数传递是指通过查询字符串或路由等方式传递的基本数据类型（如 `int`、`string` 等）。ASP.NET MVC会自动根据请求中的数据将其映射到控制器方法的参数。
+
+### 1.1 传递 `int` 类型参数
+
+通过URL传递 `int` 类型的参数时，ASP.NET MVC会将查询字符串中的数字自动绑定到控制器方法的参数中。
+
+#### 示例：传递 `int` 类型参数
+
+```csharp
+public IActionResult Index(int id)
+{
+    return Content($"传递的参数值是: {id}");
+}
+```
+
+**URL 示例**:
+ `http://localhost:5000/blog/index?id=10`
+
+查询字符串中的 `id=10` 会被绑定到方法的 `id` 参数中。
+
+PS：默认情况下使用 `{controller}/{action}/{id?}` 路由格式，所以如果参数是 `id` 的话，就可以通过路径直接传递。
+
+### 1.2 传递 `string` 类型参数
+
+类似于 `int` 类型的参数，`string` 类型的参数也可以通过查询字符串传递。ASP.NET MVC会根据查询字符串中的参数名称自动绑定。
+
+#### 示例：传递 `string` 类型参数
+
+```csharp
+public IActionResult Index_2(string name)
+{
+    return Content($"传递的字符串是: {name}");
+}
+```
+
+**URL 示例**:
+ `http://localhost:5000/blog/index_2?name=HelloWorld`
+
+查询字符串中的 `name=HelloWorld` 会被绑定到方法的 `name` 参数。
+
+### 1.3 使用自定义的参数名
+
+ASP.NET MVC支持通过查询字符串传递不同名称的参数，并将其映射到控制器方法中的变量。
+
+#### 示例：传递 `name` 参数
+
+```csharp
+public IActionResult Index_3(string name)
+{
+    return Content($"传递的名字是: {name}");
+}
+```
+
+**URL 示例**:
+ `http://localhost:5000/blog/index_3?name=张三`
+
+查询字符串中的 `name=张三` 会被绑定到方法的 `name` 参数。
+
+------
+
+## 2. 复杂传参
+
+复杂参数传递是指通过表单提交或请求体传递的自定义类型的数据。常见的传递方式包括通过POST请求提交表单数据，并将其自动绑定到控制器方法的参数对象中。
+
+### 2.1 传递 `BlogCreateDto` 类型的对象
+
+假设我们有一个自定义类型 `BlogCreateDto`，它包含一些基本的属性，如 `Title`、`Author` 和 `Content`。通过POST请求提交表单数据时，ASP.NET MVC会将表单字段绑定到该对象的属性中。
+
+#### 示例：传递 `BlogCreateDto` 类型的对象
+
+```csharp
+public class BlogCreateDto
+{
+    public string Title { get; set; }
+    public string Author { get; set; }
+    public string Content { get; set; }
+}
+
+[HttpPost]
+public IActionResult Create(BlogCreateDto blogCreateDto)
+{
+    return Content($"标题: {blogCreateDto.Title}, 作者: {blogCreateDto.Author}, 内容: {blogCreateDto.Content}");
+}
+```
+
+在此示例中，`Create` 方法接收一个 `BlogCreateDto` 类型的参数，ASP.NET MVC会根据请求中的表单字段（如 `Title`、`Author`、`Content`）自动填充该对象。
+
+### 2.2 传递 `Products` 类型的对象
+
+类似于 `BlogCreateDto` 类型的对象，可以定义一个 `Products` 类型来表示产品信息，并通过表单数据绑定到 `Products` 对象。
+
+#### 示例：传递 `Products` 类型的对象
+
+```csharp
+public class Products
+{
+    public string Name { get; set; }
+    public decimal Price { get; set; }
+    public int Stock { get; set; }
+}
+
+[HttpPost]
+public IActionResult Create_1(Products productCreateDto)
+{
+    return Content($"产品名称: {productCreateDto.Name}, 价格: {productCreateDto.Price}, 库存: {productCreateDto.Stock}");
+}
+```
+
+在这个示例中，`Create_1` 方法通过表单提交接收 `Products` 类型的对象，表单字段的名称必须与 `Products` 类中的属性名称一致，才能正确进行数据绑定。
+
+### 2.3 传递 `Students` 类型的对象
+
+`Students` 类型可以表示学生信息，包含学生的姓名、性别、年龄等。通过表单提交时，ASP.NET MVC会自动将请求数据绑定到 `Students` 对象。
+
+#### 示例：传递 `Students` 类型的对象
+
+```csharp
+public class Students
+{
+    public string Name { get; set; }
+    public bool Sex { get; set; }  // true: 男, false: 女
+    public int Age { get; set; }
+}
+
+[HttpPost]
+public IActionResult Create_2(Students studentCreateDto)
+{
+    string StuSex = studentCreateDto.Sex ? "男" : "女";
+    return Content($"学生姓名: {studentCreateDto.Name}, 性别: {StuSex}, 年龄: {studentCreateDto.Age}");
+}
+```
+
+在此示例中，`Create_2` 方法接收一个 `Students` 类型的对象。根据 `Sex` 属性的值判断学生的性别，如果是 `true` 则为“男”，否则为“女”。
+
+### 2.4 复杂对象的嵌套传递
+
+当参数中包含嵌套的对象时，ASP.NET MVC会递归地将查询字符串或表单数据绑定到嵌套对象的属性上。
+
+#### 示例：传递嵌套对象
+
+```csharp
+public class Author
+{
+    public string Name { get; set; }
+    public int Age { get; set; }
+}
+
+public class BlogCreateDto
+{
+    public string Title { get; set; }
+    public Author Author { get; set; }
+}
+
+[HttpPost]
+public IActionResult Create(BlogCreateDto blogCreateDto)
+{
+    return Content($"标题: {blogCreateDto.Title}, 作者: {blogCreateDto.Author.Name}, 年龄: {blogCreateDto.Author.Age}");
+}
+```
+
+在这个示例中，`BlogCreateDto` 中包含一个 `Author` 对象，ASP.NET MVC会将请求中嵌套的表单字段绑定到 `Author` 类的属性。
\ No newline at end of file
diff --git "a/\345\272\267\345\273\272\346\242\205/20241127--\346\270\262\346\237\223\343\200\201Razor\343\200\201\345\206\205\347\275\256ASP.NET Core\346\240\207\350\256\260\345\270\256\345\212\251\347\250\213\345\272\217.md" "b/\345\272\267\345\273\272\346\242\205/20241127--\346\270\262\346\237\223\343\200\201Razor\343\200\201\345\206\205\347\275\256ASP.NET Core\346\240\207\350\256\260\345\270\256\345\212\251\347\250\213\345\272\217.md"
new file mode 100644
index 0000000000000000000000000000000000000000..05a3102565a36432d9b7ad2d0758e19decb2f3d3
--- /dev/null
+++ "b/\345\272\267\345\273\272\346\242\205/20241127--\346\270\262\346\237\223\343\200\201Razor\343\200\201\345\206\205\347\275\256ASP.NET Core\346\240\207\350\256\260\345\270\256\345\212\251\347\250\213\345\272\217.md"	
@@ -0,0 +1,40 @@
+## 渲染
+* 简单数据在视图的渲染和展示
+* 复杂数据在视图的渲染和展示
+* 集合数据在视图的渲染和展示
+## Razor
+Razor 支持 C#，并使用@符号从 HTML 转换为 C#。 Razor 计算 C# 表达式，并将它们呈现在 HTML 输出中。
+
+当 @ 符号后跟 Razor 保留关键字时，它会转换为 Razor 特定标记.
+
+### 隐式 Razor 表达式
+以 @ 开头，后跟 C# 代码。隐式表达式不能包含空格，但 C# await 关键字除外。不能包含 C# 泛型，因为括号 (<>) 内的字符会被解释为 HTML 标记。
+
+### 显式 Razor 表达式
+由 @ 符号和平衡圆括号组成。
+
+### Razor 代码块
+代码块以 @ 开始，并括在 {} 中，例如：
+```cs
+@{
+    var quote = "The future depends on what you do today. - Mahatma Gandhi";
+}
+<p>@quote</p>
+@{
+    quote = "Hate cannot drive out hate, only love can do that. - Martin Luther King, Jr.";
+}
+<p>@quote</p>
+```
+该代码呈现以下 HTML：
+```html
+<p>The future depends on what you do today. - Mahatma Gandhi</p>
+<p>Hate cannot drive out hate, only love can do that. - Martin Luther King,Jr.";</p>
+```
+## 内置ASP.NET Core标记帮助程序--定位点
+定位点标记帮助程序可通过添加新属性来增强标准的 HTML 定位点 (<a ... >) 标记。 按照约定，属性名称将使用前缀 asp-。 asp- 属性的值决定呈现的定位点元素的 href 属性值
+
+属性：
+
+1. `asp-controller`：可分配用于生成 URL 的控制器。
+2. `asp-action` ：属性值表示生成的 href 属性中包含的控制器操作名称。
+3. `asp-all-route-data` ：支持创建键值对字典。 键是参数名称，值是参数值。
\ No newline at end of file
diff --git "a/\345\272\267\345\273\272\346\242\205/20241129--\345\256\236\347\216\260 \345\242\236 \346\223\215\344\275\234.md" "b/\345\272\267\345\273\272\346\242\205/20241129--\345\256\236\347\216\260 \345\242\236 \346\223\215\344\275\234.md"
new file mode 100644
index 0000000000000000000000000000000000000000..ba241b34d68c32ed6ba80918c83ade8db2951f97
--- /dev/null
+++ "b/\345\272\267\345\273\272\346\242\205/20241129--\345\256\236\347\216\260 \345\242\236 \346\223\215\344\275\234.md"	
@@ -0,0 +1,69 @@
+## 实现 增 操作
+### 定义一个模型Models，模拟数据库
+1. 定义一个数据库的表
+2. 静态构造函数（只执行一次，内容如果修改，则需要重新跑）
+    1. 初始化静态属性 - 直接初始化：public static List<Blog> Blog = new List<Blog>{"value1","value2"...}; - 使用静态构造函数（下面例子中的方法，推荐使用该方法 - 延迟初始化 - 使用属性初始化器
+    2. 给这个集合属性，塞进去一些内容
+    ```cs
+    public static class Db
+    {
+        public static List<Blog> Blog{get;set;}
+
+        static Db()
+        {
+            Blog = new List<Blog>();
+
+            for (int i = 0; i < 15; i++)
+            {
+                var tmp = new Blog 
+            {
+                Id = i + 1,...
+            };
+
+            Blog.Add(tmp);
+            }
+        }
+    }
+    ```
+### 创建视图，展示内容
+1. 使用<a>标签展现 增删改
+```html
+<a asp-controller="Blog" asp-action="Create">新增</a>
+```
+2. `asp-controller`：指定表单提交的 目标控制器
+3. `asp-action`：指定表单提交时应该调用的控制器中的 动作（方法）
+4. `asp-route-*`：通常与以上两个属性配合使用，便在创建表单或链接时能够自动将模型的状态或路由参数传递给控制器的特定动作。-id就是传递相应行的id号
+```html
+<a asp-controller="Blog" asp-action="Edit" asp-route-id="@item.Id">编辑</a>
+```
+### 跳转至增加页面
+1. 页面显示form表单，一定要声明Models
+```html
+<!-- 声明Models ！！！！！-->
+@model Blogs.Models.Blog;
+
+<form asp-controller="Blog" asp-action="Create" method="post">
+    <label>标题: <input asp-for="Title" /></label> <br />
+    <label>内容: <input asp-for="Content" /></label><br />
+    <label>作者: <input asp-for="Author" /></label><br />
+    <button type="submit">保存</button>
+</form>
+```
+### 使用post请求，添加到表单
+1. 获取表单中最大的ID数，，方便程序在添加中自行增加Id数：Max()方法
+2. 测试添加内容是否有被获取到：return Content(JsonSerializer.Serialize(input))
+3. 将内容添加至表单
+```cs
+[HttpPost]
+public IActionResult Create(Blog input)
+{
+    // 获取表单中最大的ID数
+    var maxId = Db.Blog.Select(t => t.Id).Max();
+    // 添加后ID也增加
+    input.Id = maxId + 1;
+    // 将添加的内容加入表单
+    Db.Blog.Add(input);
+    return RedirectToAction("Index");
+    // return Content(JsonSerializer.Serialize(input));
+}
+```
\ No newline at end of file