From ad6985ac09a5717b30c9c9c18e048b1d6474a991 Mon Sep 17 00:00:00 2001
From: xiao <xiao>
Date: Tue, 21 May 2024 11:34:21 +0800
Subject: [PATCH 1/2] tj

---
 .../20240516 rest\347\256\200\344\273\213.md" |  0
 .../20240520 .netcore cli.md"                 | 69 +++++++++++++++++++
 ...72\346\234\254\350\277\220\350\241\214.md" | 33 +++++++++
 3 files changed, 102 insertions(+)
 rename "\350\202\226\346\226\207\346\205\247/20240516 rest\347\256\200\344\273\213" => "\350\202\226\346\226\207\346\205\247/20240516 rest\347\256\200\344\273\213.md" (100%)
 create mode 100644 "\350\202\226\346\226\207\346\205\247/20240520 .netcore cli.md"
 create mode 100644 "\350\202\226\346\226\207\346\205\247/20240521 \345\237\272\346\234\254\350\277\220\350\241\214.md"

diff --git "a/\350\202\226\346\226\207\346\205\247/20240516 rest\347\256\200\344\273\213" "b/\350\202\226\346\226\207\346\205\247/20240516 rest\347\256\200\344\273\213.md"
similarity index 100%
rename from "\350\202\226\346\226\207\346\205\247/20240516 rest\347\256\200\344\273\213"
rename to "\350\202\226\346\226\207\346\205\247/20240516 rest\347\256\200\344\273\213.md"
diff --git "a/\350\202\226\346\226\207\346\205\247/20240520 .netcore cli.md" "b/\350\202\226\346\226\207\346\205\247/20240520 .netcore cli.md"
new file mode 100644
index 0000000..6b83c97
--- /dev/null
+++ "b/\350\202\226\346\226\207\346\205\247/20240520 .netcore cli.md"	
@@ -0,0 +1,69 @@
+### 命令
+```c#
+1. 基本命令
+new
+restore
+build
+publish
+run
+test
+vstest
+pack
+migrate
+clean
+sln
+help
+store
+2. 项目修改命令
+add package
+add reference
+remove package
+remove reference
+list reference
+3. 高级命令
+nuget delete
+nuget locals
+nuget push
+msbuild
+dotnet install script
+4. 工具管理命令
+tool install
+tool list
+tool update
+tool restore 自 .NET Core SDK 3.0 起可用。
+tool run 自 .NET Core SDK 3.0 起可用。
+tool uninstall
+工具是控制台应用程序，它们从 NuGet 包中安装并从命令提示符处进行调用。 你可自行编写工具，也可安装由第三方编写的工具。 工具也称为全局工具、工具路径工具和本地工具。 有关详细信息，请参阅 .NET 工具概述。
+
+5. 命令结构
+CLI 命令结构包含驱动程序（“dotnet”）和命令，还可能包含命令参数和选项。 在大部分 CLI 操作中可看到此模式，例如创建新控制台应用并从命令行运行该应用，因为从名为 my_app 的目录中执行时，显示以下命令：
+
+.NET CLI
+
+6. 复制
+dotnet new console
+dotnet build --output ./build_output
+dotnet ./build_output/my_app.dll
+驱动程序
+驱动程序名为 dotnet，并具有两项职责，即运行依赖于框架的应用或执行命令。
+
+若要运行依赖于框架的应用，请在驱动程序后指定应用，例如，dotnet /path/to/my_app.dll。 从应用的 DLL 驻留的文件夹执行命令时，只需执行 dotnet my_app.dll 即可。 如果要使用特定版本的 .NET 运行时，请使用 --fx-version <VERSION> 选项（请参阅 dotnet 命令参考）。
+
+为驱动程序提供命令时，dotnet.exe 启动 CLI 命令执行过程。 例如：
+
+.NET CLI
+
+7. 复制
+dotnet build
+首先，驱动程序确定要使用的 SDK 版本。 如果没有 global.json 文件，则使用可用的最新版本 SDK。 这有可能是预览版或稳定版，具体取决于计算机上的最新版本。 确定 SDK 版本后，它便会执行命令。
+
+8. 命令
+由命令执行操作。 例如，dotnet build 生成代码。 dotnet publish 发布代码。 使用 dotnet {command} 约定将命令作为控制台应用程序实现。
+
+9. 自变量
+在命令行上传递的参数是被调用的命令的参数。 例如，执行 dotnet publish my_app.csproj 时，my_app.csproj 参数指示要发布的项目，并被传递到 publish 命令。
+
+10. 选项
+在命令行上传递的选项是被调用的命令的选项。 例如，执行 dotnet pu
+
+```
\ No newline at end of file
diff --git "a/\350\202\226\346\226\207\346\205\247/20240521 \345\237\272\346\234\254\350\277\220\350\241\214.md" "b/\350\202\226\346\226\207\346\205\247/20240521 \345\237\272\346\234\254\350\277\220\350\241\214.md"
new file mode 100644
index 0000000..c041490
--- /dev/null
+++ "b/\350\202\226\346\226\207\346\205\247/20240521 \345\237\272\346\234\254\350\277\220\350\241\214.md"	
@@ -0,0 +1,33 @@
+## 一、解决方案和项目之间的联系
+
+1. 编译或者打包解决方案的时候，会同时编译或打包其下所有的项目
+2. 如果运行解决方案的话，则会按照编排的（指定的启动项目），分别调用指定项目
+
+## 今日作业
+
+```C#
+var builder = WebApplication.CreateBuilder(args);
+
+var app = builder.Build();
+
+app.MapGet("/",async ctx => {
+    
+    await ctx.Response.WriteAsync("8888");
+});
+
+
+app.MapGet("/leaf",async ctx => {
+
+    await ctx.Response.WriteAsync("9999");
+});
+
+app.Run();
+
+
+```
+
+1. 在最简单的形式下，转换为在单独的文件中写路径-抽离
+
+
+
+2. 在最简形式下，转换为原来传统的控制器的模式-转换
-- 
Gitee


From 53eed084dd5275dfcea3d69aba19e5f57c783f8f Mon Sep 17 00:00:00 2001
From: xiao <xiao>
Date: Sun, 26 May 2024 23:06:11 +0800
Subject: [PATCH 2/2] tj

---
 ...35\350\265\226\346\263\250\345\205\245.md" | 134 ++++++++++++++++++
 ...347\232\204api\345\206\231\346\263\225.md" |  67 +++++++++
 2 files changed, 201 insertions(+)
 create mode 100644 "\350\202\226\346\226\207\346\205\247/20240523 \344\276\235\350\265\226\346\263\250\345\205\245.md"
 create mode 100644 "\350\202\226\346\226\207\346\205\247/20240524 \347\256\200\345\215\225\347\232\204api\345\206\231\346\263\225.md"

diff --git "a/\350\202\226\346\226\207\346\205\247/20240523 \344\276\235\350\265\226\346\263\250\345\205\245.md" "b/\350\202\226\346\226\207\346\205\247/20240523 \344\276\235\350\265\226\346\263\250\345\205\245.md"
new file mode 100644
index 0000000..f1198ff
--- /dev/null
+++ "b/\350\202\226\346\226\207\346\205\247/20240523 \344\276\235\350\265\226\346\263\250\345\205\245.md"	
@@ -0,0 +1,134 @@
+### 依赖注入
+```js
+1.简介
+组件与组件之间存在依赖关系，但是但一方不存在时，另一方就不能正常工作，这个时候就需要采用控制反转。
+控制反转是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度，其中最常见的方式叫做依赖注入，也可以说依赖注入和控制反转是一回事
+依赖注入的方式主要有三种：
+构造函数注入
+属性注入：通过在需要注入的类中声明属性
+方法注入：将依赖项通过方法参数传递的方式进行依赖注入
+2.举例说明
+ // MyDependency.cs
+ public class MyDependency
+ {
+    public void WriteMessage(string message)
+    {
+        Console.WriteLine($"调用的数据为{message}");
+    }
+ }
+ 
+ // IndexModel.cs
+ public class IndexModel 
+ {
+    // 假设在当前类中需要引用MyDependency类的实例
+    private readonly MyDependency _dependency;
+    public IndexModel(){
+        // 创建一个MyDependency实例
+        // MyDependency是一个依赖项，为IndexModel提供数据
+        _dependency = new MyDependency();
+    }
+    public void DoSomething()
+    {
+        _dependency.WriteMessage("超级侦探");
+    }
+ }
+ 
+ //Program.cs
+  public static void Main(string[] args)
+   {
+        // 调用 CreateWebHostBuilder 方法来创建一个 IWebHostBuilder 实例
+       var app = CreateWebHostBuilder(args).Build();
+       // 在这里实例化 IndexModel 并调用方法进行测试
+       var indexModel = new IndexModel();
+       indexModel.DoSomething();
+       // 运行应用程序
+       app.Run();  //控制台输出：调用的数据为超级侦探
+   }
+从上面可知：
+
+想要替换 MyDependency的结果，必须修改 IndexModel 类
+很难进行单元测试
+如果 MyDependency 具有依赖项，则必须由 IndexModel 类对其进行配置 依赖关系注入通过以下方式解决这些问题：
+使用接口或基类将依赖关系实现抽象化
+在服务容器中注册依赖关系。 ASP.NET Core 提供了一个内置的服务容器 IServiceProvider。 服务通常已在应用的 Program.cs 文件中注册
+将服务注入到使用它的类的构造函数中。 框架负责创建依赖关系的实例，并在不再需要时将其释放
+ // 下面是构造函数注入
+ // MyDependency.cs
+ // IMyDependency 接口
+ public interface IMyDependency
+ {
+    // 定义了一个方法 WriteMessage(string message)用于写入消息
+    void WriteMessage(string message);
+ }
+ // MyDependency 类实现了 IMyDependency 接口
+ // 提供了 WriteMessage 方法的具体实现
+ public class MyDependency : IMyDependency
+ {
+    public void WriteMessage(string message)
+    {
+        Console.WriteLine($"调用的数据为{message}");
+    }
+ }
+ 
+ // IndexModel.cs
+ public class IndexModel 
+ {
+   // 构造_idependency属性，并在构造函数中注入（属性注入）
+    private readonly IMyDependency _idependency;
+    // 使用构造函数注入的方式来将 IMyDependency 的具体实现注入到 IndexModel 中
+    public IndexModel(IMyDependency dependency){
+        // 控制反转，不需要直接new实例化
+        _idependency = dependency;
+    }
+    public void DoSomething()
+    {
+        _idependency.WriteMessage("超级侦探");
+    }
+ }
+ 
+ // Startup.cs
+ // 启动类，包含应用程序的配置信息
+ public class Startup
+ {
+    public void Configure(IApplicationBuilder app)
+    {
+        // ......
+    }
+    public void ConfigureServices(IServiceCollection services)
+    {
+        // 将 MyDependency 类注册为单例服务
+        // 注册 将IMyDependency实现类MyDependency实例化一个，放入容器
+        services.AddSingleton<IMyDependency, MyDependency>();
+        // 将 IndexModel 类注册为作用域服务
+        services.AddScoped<IndexModel>();
+    }
+ }
+ 
+ // program.cs
+  public static void Main(string[] args)
+ {
+    var app = CreateWebHostBuilder(args).Build();
+    // 在 using 语句中创建作用域，以便在作用域内获取服务
+    using (var scope = app.Services.CreateScope())
+    {
+        // 获取服务提供者 services
+        var services = scope.ServiceProvider;
+        // 从服务提供者中获取 IndexModel 的实例
+        var indexModel = services.GetService<IndexModel>();
+        indexModel.DoSomething();  //控制台输出 调用的数据为超级侦探
+    }
+    app.Run();  
+ }
+3.依赖注入容器
+专门的类用来负责管理创建所需要的类，并创建它所有可能要用到的依赖，这个类就是依赖注入容器，也可以称之为控制反转容器（IoC容器）
+可以把依赖注入容器看作一个用于创建对象的工厂，它负责向外提供被请求要创建的对象，当创建这个对象时，如果它又依赖了其他对象或者服务，那么容器会负责在其内部查找需要的依赖，并创建这些依赖，直至所有依赖项都创建完成后，最终返回被请求的对象
+容器也负责管理所创建对象的生命周期
+二、ASP.NET Core中的依赖注入
+ASP.NET Core框架内部集成了自身的依赖注入容器
+所有被放入依赖注入容器的类型或组件称为服务，添加服务就使用Startup类的ConfigureServices方法
+服务的生命周期有以下三种：
+Singleton：容器会创建并共享服务的单例，且一直存在于应用程序的整个生命周期里
+TRansient：每次请求，总会创建新实例
+Scope：在每次请求时会创建服务的新实例，并在这个请求内一直共享这个实例
+
+```
\ No newline at end of file
diff --git "a/\350\202\226\346\226\207\346\205\247/20240524 \347\256\200\345\215\225\347\232\204api\345\206\231\346\263\225.md" "b/\350\202\226\346\226\207\346\205\247/20240524 \347\256\200\345\215\225\347\232\204api\345\206\231\346\263\225.md"
new file mode 100644
index 0000000..87d7b66
--- /dev/null
+++ "b/\350\202\226\346\226\207\346\205\247/20240524 \347\256\200\345\215\225\347\232\204api\345\206\231\346\263\225.md"	
@@ -0,0 +1,67 @@
+### 入口程序
+```js
+ using Microsoft.AspNetCore;
+ // 1. 命名空间声明
+ namespace Api
+ {
+     // 2. 类声明
+     // Program类是应用程序的入口点，应用程序通常从Main方法开始执行
+     public class Program
+     {
+         public static void Main(string[] args)
+         {
+             CreateWebHostBuilder(args).Build().Run();
+             // CreateWebHostBuilder(args)方法被调用来创建一个IWebHostBuilder对象
+             // Build()方法被调用在IWebHostBuilder对象上，生成一个IWebHost对象
+             // Run()方法启动Web主机，使应用程序开始监听Web请求
+         }
+         public static IWebHostBuilder CreateWebHostBuilder(string[] args)
+         {
+             return WebHost.CreateDefaultBuilder(args).UseStartup<Startup>();
+             // CreateWebHostBuilder方法用于配置和创建一个Web主机生成器
+             // UseStartup<Startup>()方法指定Startup类作为应用程序的启动类
+         }
+     }
+ }
+启动类
+ // Startup类是ASP.NET Core应用程序启动时调用的类，用于配置应用程序服务和HTTP请求管道
+ public class Startup
+ {
+     // 用于添加和注册中间件
+     public void Configure(IApplicationBuilder app)
+     {
+         app.UseRouting(); //添加路由中间件
+         // 配置终结点路由
+         app.UseEndpoints(endpoints => {
+             endpoints.MapControllers(); 
+             // 添加控制器终结点到请求管道中，这使得控制器能够处理HTTP请求
+         }); 
+     }
+     // 注册准备依赖注入的服务
+     // ConfigureServices方法用于配置依赖注入容器，添加应用程序所需的服务
+     public void ConfigureServices(IServiceCollection services)
+     {
+         services.AddControllers(); //添加MVC控制器相关的服务到依赖注入容器中
+     }
+ }
+控制器
+ namespace Api.Controllers;
+ 
+ [Route("[controller]")] //定义控制器的路由前缀，即/blogs
+ // BlogsController类继承自ControllerBase，它是一个用于构建API的基类（不包含视图支持）
+ public class BlogsController : ControllerBase
+ {
+     // 处理对/blogs的GET请求
+     public IActionResult Index(){
+         return Ok("999"); //返回一个包含字符串"999"的200 OK响应
+     }
+     
+     [Route("{id}")] //定义Single方法的路由模板
+     // 处理对/blogs/{id}的GET请求,接受一个整型参数id
+     public IActionResult Single(int id)
+     {
+         return Ok(id); //返回一个包含id值的200 OK响应
+     }
+ }
+
+ ```
\ No newline at end of file
-- 
Gitee