diff --git "a/\345\262\263\345\274\272/20240527-\347\254\224\350\256\260-\350\267\257\347\224\261.md" "b/\345\262\263\345\274\272/20240527-\347\254\224\350\256\260-\350\267\257\347\224\261.md"
new file mode 100644
index 0000000000000000000000000000000000000000..53648f9ce7707e0d02cdfca0aee16d4734e00d98
--- /dev/null
+++ "b/\345\262\263\345\274\272/20240527-\347\254\224\350\256\260-\350\267\257\347\224\261.md"
@@ -0,0 +1,137 @@
+# 路由
+在 ASP.NET Core 中，路由是一个非常重要的机制，它可以将 URL 和控制器方法之间建立映射关系。下面是一些关于 ASP.NET Core 中路由的知识点和例子：
+
+1.  **路由的定义**
+
+routes.MapRoute( name: "default", template: "{controller=Home}/{action=Index}/{id?}");
+
+*   `name`：路由名称，用于在代码中引用。
+*   `template`：路由模板，定义了 URL 的格式。`{controller}` 和 `{action}` 是 URL 参数，它们会被映射到控制器和动作方法上。`{id?}` 表示可选参数，它的值可以为空。
+*   `defaults`：默认值，当 URL 中没有对应参数时，会使用默认值。
+
+2.  **约定式路由**
+
+在 ASP.NET Core 中，还有一种约定式路由的方式，可以简化上面的代码：
+
+    app.UseEndpoints(endpoints =>
+    {
+        endpoints.MapControllerRoute(
+            name: "default",
+            pattern: "{controller=Home}/{action=Index}/{id?}");
+    });
+    
+
+*   `app.UseEndpoints`：用于配置路由和中间件的方法。
+*   `endpoints.MapControllerRoute`：用于定义约定式路由。
+
+3.  **属性路由**
+
+在 ASP.NET Core 中，还可以使用属性路由，它可以在控制器和动作方法上添加特性，来定义路由。
+
+    [ApiController]
+    [Route("api/[controller]")]
+    public class ValuesController : ControllerBase
+    {
+        [HttpGet]
+        public ActionResult<IEnumerable<string>> Get()
+        {
+            return new string[] { "value1", "value2" };
+        }
+    
+        [HttpGet("{id}")]
+        public ActionResult<string> Get(int id)
+        {
+            return "value";
+        }
+    }
+    
+
+*   `[ApiController]`：表示这是一个 API 控制器。
+*   `[Route("api/[controller]")]`：表示这个控制器的路由前缀是 `api/values`。
+*   `[HttpGet]`：表示这个方法是 GET 请求。
+*   `[HttpGet("{id}")]`：表示这个方法的路由模板是 `api/values/{id}`。
+
+4.  **路由的优先级**
+
+当有多个路由匹配同一个 URL 时，会根据路由的优先级来选择路由。优先级的规则如下：
+
+*   精确路由 > 路由模板 > 约定式路由
+*   越精确的路由优先级越高
+
+例如，有以下路由：
+
+    routes.MapRoute(
+        name: "blog",
+        template: "blog/{*article}");
+    
+    routes.MapRoute(
+        name: "default",
+        template: "{controller=Home}/{action=Index}/{id?}");
+    
+
+当请求 URL 是 `/blog/asp-net-core-routing` 时，会匹配第一个路由 `blog/{*article}`，而不是第二个路由 `{controller=Home}/{action=Index}/{id?}`。
+
+5.  **路由数据 tokens**
+
+在路由模板中，可以使用 `{token}` 来定义路由数据 tokens，它可以在控制器和动作方法中获取路由数据。
+
+    routes.MapRoute(
+        name: "blog",
+        template: "blog/{category}/{*title}");
+    
+    [HttpGet("{category}/{*title}")]
+    public IActionResult GetBlogPost(string category, string title)
+    {
+        // 使用 category 和 title 参数
+    }
+    
+
+*   `category`：路由数据 tokens，表示路由模板中的 `{category}` 参数。
+*   `*title`：表示可以匹配多个路由数据 tokens，例如 `/blog/asp.net-core-routing/routing-in-asp.net-core`。
+
+6.  **路由约束**
+
+在路由模板中，可以使用路由约束来限制路由参数的类型。
+
+    routes.MapRoute(
+        name: "blog",
+        template: "blog/{id:int}");
+    
+    [HttpGet("{id:int}")]
+    public IActionResult GetBlogPost(int id)
+    {
+        // 使用 id 参数
+    }
+    
+
+*   `int`：表示路由参数必须是整数类型。
+
+其他常用的路由约束包括：
+
+*   `guid`：表示路由参数必须是 GUID 类型。
+*   `alpha`：表示路由参数必须是字母类型。
+*   `alphanum`：表示路由参数必须是字母和数字类型。
+*   `minlength(value)`：表示路由参数必须大于等于指定长度的字符串。
+*   `maxlength(value)`：表示路由参数必须小于等于指定长度的字符串。
+*   `length(min,max)`：表示路由参数必须在指定长度范围内的字符串。
+*   `range(min,max)`：表示路由参数必须在指定数值范围内。
+
+7.  **路由重定向**
+
+在 ASP.NET Core 中，可以使用路由重定向来重定向 URL。
+
+    routes.MapRoute(
+        name: "blog",
+        template: "blog/{*url}",
+        defaults: new { controller = "Blog", action = "Redirect" });
+    
+    [HttpGet("{*url}")]
+    public IActionResult Redirect(string url)
+    {
+        return Redirect("https://blog.microsoft.com" + url);
+    }
+    
+
+*   `template`：表示路由模板。
+*   `defaults`：表示默认值。
+*   `Redirect`：表示重定向到指定 URL。
diff --git "a/\345\262\263\345\274\272/20240528-\347\254\224\350\256\260-\350\277\207\346\273\244\345\231\250.md" "b/\345\262\263\345\274\272/20240528-\347\254\224\350\256\260-\350\277\207\346\273\244\345\231\250.md"
new file mode 100644
index 0000000000000000000000000000000000000000..01d0412f6aa52f548bb046c00bdb7e8f76ad6abd
--- /dev/null
+++ "b/\345\262\263\345\274\272/20240528-\347\254\224\350\256\260-\350\277\207\346\273\244\345\231\250.md"
@@ -0,0 +1,150 @@
+# 过滤器
+在 ASP.NET Core 中，过滤器（Filters）是一种强大的机制，用于处理在执行 Web 请求时发生的各种事件。过滤器可以在请求处理管道中的特定阶段执行代码，例如在动作方法执行前、后或者发生异常时。以下是关于 ASP.NET Core 中过滤器的一些知识点和例子：
+
+### 过滤器的类型
+
+ASP.NET Core 支持以下几种类型的过滤器：
+
+1.  **授权过滤器（Authorization Filters）**
+    
+    *   最先执行，用于确定用户是否被授权访问某个资源。
+    *   示例：
+        
+            public class CustomAuthorizationFilter : IAuthorizationFilter
+            {
+                public void OnAuthorization(AuthorizationFilterContext context)
+                {
+                    // 实现自定义授权逻辑
+                }
+            }
+            
+        
+2.  **资源过滤器（Resource Filters）**
+    
+    *   在授权过滤器之后执行，但在其他类型的过滤器之前。
+    *   可以用于缓存、短路请求处理等。
+    *   示例：
+        
+            public class CustomResourceFilter : IResourceFilter
+            {
+                public void OnResourceExecuting(ResourceExecutingContext context)
+                {
+                    // 在资源执行前执行
+                }
+            
+                public void OnResourceExecuted(ResourceExecutedContext context)
+                {
+                    // 在资源执行后执行
+                }
+            }
+            
+        
+3.  **动作过滤器（Action Filters）**
+    
+    *   在动作方法执行前后执行，可以用于修改动作方法的输入或输出。
+    *   示例：
+        
+            public class CustomActionFilter : IActionFilter
+            {
+                public void OnActionExecuting(ActionExecutingContext context)
+                {
+                    // 在动作方法执行前执行
+                }
+            
+                public void OnActionExecuted(ActionExecutedContext context)
+                {
+                    // 在动作方法执行后执行
+                }
+            }
+            
+        
+4.  **异常过滤器（Exception Filters）**
+    
+    *   用于捕获和处理在请求处理过程中发生的异常。
+    *   示例：
+        
+            public class CustomExceptionFilter : IExceptionFilter
+            {
+                public void OnException(ExceptionContext context)
+                {
+                    // 处理异常
+                }
+            }
+            
+        
+5.  **结果过滤器（Result Filters）**
+    
+    *   在动作方法的结果执行前后执行，可以用于修改动作结果的输出。
+    *   示例：
+        
+            public class CustomResultFilter : IResultFilter
+            {
+                public void OnResultExecuting(ResultExecutingContext context)
+                {
+                    // 在结果执行前执行
+                }
+            
+                public void OnResultExecuted(ResultExecutedContext context)
+                {
+                    // 在结果执行后执行
+                }
+            }
+            
+        
+6.  **终结点过滤器（Endpoint Filters）**
+    
+    *   在 ASP.NET Core 3.0 及更高版本中引入，用于在路由到终结点前后执行代码。
+    *   示例：
+        
+            public class CustomEndpointFilter : IEndpointFilter
+            {
+                public ValueTask<object> InvokeAsync(EndpointFilterInvocationContext context, EndpointFilterDelegate next)
+                {
+                    // 在终结点执行前/后执行
+                    return next(context);
+                }
+            }
+            
+        
+
+### 过滤器的应用
+
+过滤器可以通过多种方式应用到控制器或动作方法上：
+
+*   **全局应用**：在 `Startup.cs` 的 `ConfigureServices` 方法中注册为全局过滤器。
+    
+        services.AddMvc(options =>
+        {
+            options.Filters.Add<CustomActionFilter>();
+        });
+        
+    
+*   **控制器级别应用**：在控制器类上使用 `[ServiceFilter]` 或 `[TypeFilter]` 特性。
+    
+        [ServiceFilter(typeof(CustomActionFilter))]
+        public class MyController : Controller
+        {
+            // ...
+        }
+        
+    
+*   **动作方法级别应用**：在动作方法上使用 `[ServiceFilter]` 或 `[TypeFilter]` 特性。
+    
+        public class MyController : Controller
+        {
+            [TypeFilter(typeof(CustomActionFilter))]
+            public IActionResult MyAction()
+            {
+                // ...
+            }
+        }
+        
+    
+
+### 过滤器的生命周期
+
+过滤器的生命周期由依赖注入（DI）管理。如果过滤器需要依赖其他服务，可以通过构造函数注入。过滤器实例的生命周期通常与请求的生命周期相同，除非它们被注册为作用域或单例服务。
+
+### 结论
+
+过滤器是 ASP.NET Core 中一个非常灵活和强大的功能，它允许开发者在请求处理的各个阶段插入自定义逻辑。通过合理使用过滤器，可以实现诸如授权、日志记录、异常处理、缓存等功能，从而提高应用程序的健壮性和可维护性。
\ No newline at end of file
diff --git "a/\345\262\263\345\274\272/20240530-\347\254\224\350\256\260-\351\241\271\347\233\256.md" "b/\345\262\263\345\274\272/20240530-\347\254\224\350\256\260-\351\241\271\347\233\256.md"
new file mode 100644
index 0000000000000000000000000000000000000000..c5679fd3f2bcf81b3f32613c6936f92d41e07fc9
--- /dev/null
+++ "b/\345\262\263\345\274\272/20240530-\347\254\224\350\256\260-\351\241\271\347\233\256.md"
@@ -0,0 +1,37 @@
+# 项目
+## 数据库数据类型集合
+```js
+    public static BookDtoreDb Instance{get;set;}=new BookStoreDb();
+    public Icollection<实例对象1> 名1 {get;set;}=new List<实例对象1>();
+    public Icollection<实例对象2> 名2 {get;set;}=new List<实例对象2>();
+    //初始化数据
+    public BookStoreDb()
+    {
+        名1.Add(new 实例名{
+            字段1=值1,
+            字段2=值2
+        })
+    }
+```
+##  路由
+
+1.作者表
+获取作者列表 get/api/authors
+
+获取指定作者 get/api/authors/29
+
+新增作者信息 post/api/authors
+
+修改作者信息 put/api/authors/29
+
+删除作者信息 delete/api/authors/29
+2.图书表-部署于作者表底下
+获取图书列表 get/api/authors/9/books
+
+获取指定图书 get/api/authors/9/books/29
+
+新增图书信息 post/api/authors/9/books
+
+修改图书信息 put/api/authors/9/books/29
+
+删除图书信息 delete/api/authors/9/books/29
\ No newline at end of file
diff --git "a/\345\262\263\345\274\272/20240531-\347\254\224\350\256\260-\344\273\223\345\202\250\347\263\273\347\273\237.md" "b/\345\262\263\345\274\272/20240531-\347\254\224\350\256\260-\344\273\223\345\202\250\347\263\273\347\273\237.md"
new file mode 100644
index 0000000000000000000000000000000000000000..c22a5d748cea9d103f8f5640849576590fbbc9b1
--- /dev/null
+++ "b/\345\262\263\345\274\272/20240531-\347\254\224\350\256\260-\344\273\223\345\202\250\347\263\273\347\273\237.md"
@@ -0,0 +1,87 @@
+# 仓储
+在 ASP.NET Core 中，仓储（Repository）是一种设计模式，用于将数据访问逻辑与业务逻辑分离。仓储充当了应用程序和数据源之间的中介，提供了一个统一的接口来访问数据。以下是一些关于 ASP.NET Core 中仓储的知识点和例子：
+
+### 仓储的概念
+
+1.  **定义**：仓储是一个抽象层，它定义了访问数据的接口，通常用于数据库操作。
+2.  **目的**：旨在解耦数据访问层，使其与具体的实体框架或数据存储无关，便于测试和更换数据源。
+3.  **分层架构**：在分层架构中，仓储位于数据访问层（Data Access Layer, DAL）或数据层（Data Layer）。
+
+### 仓储的实现
+
+1.  **接口**：定义一个接口，其中包含所需的数据访问方法。
+    
+        public interface IRepository<TEntity> where TEntity : class
+        {
+            IEnumerable<TEntity> GetAll();
+            TEntity GetById(object id);
+            void Add(TEntity entity);
+            void Update(TEntity entity);
+            void Delete(TEntity entity);
+        }
+        
+    
+2.  **实现**：实现上述接口，通常使用 Entity Framework Core 的 DbContext 或仓储模式。
+    
+        public class ProductRepository : Repository<Product>, IProductRepository
+        {
+            public ProductRepository(ApplicationDbContext context) : base(context)
+            {
+            }
+            // 实现特定的数据访问逻辑
+        }
+        
+    
+
+### 仓储的使用
+
+1.  **服务层**：在服务层（Service Layer）中，通过仓储接口与数据源交互。
+    
+        public class ProductService
+        {
+            private readonly IProductRepository _productRepository;
+        
+            public ProductService(IProductRepository productRepository)
+            {
+                _productRepository = productRepository;
+            }
+        
+            public IEnumerable<Product> GetAllProducts()
+            {
+                return _productRepository.GetAll();
+            }
+        }
+        
+    
+2.  **控制器**：在控制器（Controller）中，调用服务层的逻辑，而不是直接与数据库交互。
+    
+        [ApiController]
+        [Route("[controller]")]
+        public class ProductController : ControllerBase
+        {
+            private readonly IProductService _productService;
+        
+            public ProductController(IProductService productService)
+            {
+                _productService = productService;
+            }
+        
+            [HttpGet]
+            public IActionResult GetAllProducts()
+            {
+                var products = _productService.GetAllProducts();
+                return Ok(products);
+            }
+        }
+        
+    
+
+### 注意事项
+
+*   **依赖注入**：通过依赖注入（DI）将仓储提供给服务层和控制器，以实现解耦。
+*   **事务处理**：在仓储中可以实现事务逻辑，确保数据的一致性。
+*   **扩展性**：仓储可以轻松地切换不同的数据源，如从数据库迁移到内存数据库等。
+
+### 结论
+
+仓储在 ASP.NET Core 应用程序中扮演着重要的角色，它有助于保持代码的整洁和分层，同时使数据访问逻辑易于管理和测试。通过使用仓储，可以实现数据源的解耦，提高应用程序的可维护性和扩展性。
\ No newline at end of file