diff --git "a/\350\242\201\344\271\213\346\201\222/20240603-\345\242\236\345\212\240\347\274\226\350\276\221.md" "b/\350\242\201\344\271\213\346\201\222/20240603-\345\242\236\345\212\240\347\274\226\350\276\221.md"
new file mode 100644
index 0000000000000000000000000000000000000000..0274c4c247b63fefb25312b94f1646ea085003a0
--- /dev/null
+++ "b/\350\242\201\344\271\213\346\201\222/20240603-\345\242\236\345\212\240\347\274\226\350\276\221.md"
@@ -0,0 +1,188 @@
+## Web项目讲解（增加、编辑）
+- AuthorController
+```csharp
+  //获取所有
+    [HttpGet("{id?}")]
+    public IActionResult Get(Guid id)
+    {
+        //用我们注入的接口，使用其中我们定义的函数方法去实现功能
+        var list = _authorRepository.GetAllAuthors(id);
+        return Ok(list);
+    }
+    //保存
+    [HttpPost]
+    public ActionResult<Authors> Post(AuthorCreateDto AuthorCreateDto)
+    {
+        //用我们注入的接口，使用其中我们定义的函数方法去实现功能
+        var list = _authorRepository.Create(AuthorCreateDto);
+        return Ok(list);
+    }
+    //修改
+    [HttpPut("{id}")]
+    public ActionResult<Authors> Put(Guid id, AuthorEditDto authorEditDto)
+    {
+        //用我们注入的接口，使用其中我们定义的函数方法去实现功能
+        var list = _authorRepository.Edit(id, authorEditDto);
+        return Ok(list);
+    }  
+```
+- AuthorStoreDb
+```csharp
+//初始化一个AuthorStoreDb对象
+    public static AuthorStoreDb Index { get; set; } = new AuthorStoreDb();
+    //初始化一个ICollection集合类型的对象,将它new成一个list的对象(Authors是你创建的Domain中的实例化对象)
+    public ICollection<Authors> Authors { get; set; } = new List<Authors>();
+    public ICollection<Books> Books { get; set; } = new List<Books>();
+    //给内存型的数据库添加数据，List集合使用Add添加
+    public AuthorStoreDb()
+    {
+        Authors.Add(new Authors
+        {
+            Id = Guid.NewGuid(),
+            AuthorName = "aaaa",
+            Gender = 1
+        });
+        Authors.Add(new Authors
+        {
+            Id = Guid.NewGuid(),
+            AuthorName = "bbbb",
+            Gender = 0
+        });
+        Authors.Add(new Authors
+        {
+            Id = Guid.NewGuid(),
+            AuthorName = "cccc",
+            Gender = 1
+        });
+        Books.Add(new Books
+        {
+            Id = Guid.NewGuid(),
+            BookName = "aaa",
+            AuthorId = Guid.NewGuid()
+        });
+        Books.Add(new Books
+        {
+            Id = Guid.NewGuid(),
+            BookName = "bbb",
+            AuthorId = Guid.NewGuid()
+        });
+        Books.Add(new Books
+        {
+            Id = Guid.NewGuid(),
+            BookName = "cccc",
+            AuthorId = Guid.NewGuid()
+        });
+
+    }
+```
+- Startup
+```csharp
+public void ConfigureServices(IServiceCollection service)
+    {
+        //注册控制器
+        service.AddControllers();
+        // 将仓储服务注册到容器
+        service.AddScoped<IAuthorRepository, AuthorRepository>();
+    }
+```
+- IAuthorRepository
+```csharp
+using Admin8.Domain;
+using Admin8.Dto;
+
+namespace Admin8.Interface;
+
+public interface IAuthorRepository
+{
+    //定义接口中的函数，返回类型，形参
+    //定义获取的方法
+    ICollection<AuthorDto>? GetAllAuthors(Guid id);
+    //定义增加的方法
+    AuthorDto Create(AuthorCreateDto authorCreateDto);
+    //定义编辑的方法
+    AuthorDto? Edit(Guid id, AuthorEditDto authorEditDto);
+    //定义删除的方法
+    AuthorDto? Delete(Guid id);
+}
+```
+- AuthorRepository
+```csharp
+//获取全部或者指定Guid的作者（AuthorDto中我的是将Password隐藏了的，如果不用的话，考试时可以直接改为Author）
+    public ICollection<AuthorDto>? GetAllAuthors(Guid guid)
+    {
+        //判断传进来的Id是否存在，不存在的Guid默认值为00000000-0000-0000-0000-000000000000
+        if (guid.ToString() == "00000000-0000-0000-0000-000000000000")
+        {
+            //在内存型数据库中获取到所有的数据
+            var list = AuthorStoreDb.Index.Authors.ToList();
+            //创建一个List集合保存需要返回的数据（我这里返回的数据中将Password隐藏了，如果不需要隐藏，以下省略）
+            var result = new List<AuthorDto>();
+            list.ForEach(item =>
+            {
+                var temp = new AuthorDto { Id = item.Id, AuthorName = item.AuthorName, Gender = item.Gender };
+                result.Add(temp);
+            });
+            //将数据返回（我这里返回的数据中将Password隐藏了，如果不需要隐藏，以下返回改为list）
+            return result;
+        }
+        else
+        {
+            //在内存型数据库中获取到指定Guid的数据
+            var list = AuthorStoreDb.Index.Authors.FirstOrDefault(item => item.Id == guid);
+            //没有则返回空，并结束函数
+            if (list == null)
+            {
+                return null;
+            }
+            //创建一个List集合保存需要返回的数据（我这里返回的数据中将Password隐藏了，如果不需要隐藏，以下省略）
+            var result = new List<AuthorDto>();
+            var obj = new AuthorDto { Id = list.Id, AuthorName = list.AuthorName, Gender = list.Gender };
+            result.Add(obj);
+            //将数据返回（我这里返回的数据中将Password隐藏了，如果不需要隐藏，以下返回改为list）
+            return result;
+        }
+
+    }
+    //添加作者信息
+    public AuthorDto Create(AuthorCreateDto authorCreateDto)
+    {
+        //创建一个新的Authors，其中将上面传进来的authorCreateDto数据保存进去
+        var obj = new Authors
+        {
+            //Guid.NewGuid()这是让他自己创建一个新的Guid
+            Id = Guid.NewGuid(),
+            AuthorName = authorCreateDto.AuthorName,
+            Gender = authorCreateDto.Gender,
+            Password = authorCreateDto.Password
+        };
+        //将创建的数据保存进内存型数据库(List用Add添加)，AuthorStoreDb中看一下结构，逐级.下去的
+        AuthorStoreDb.Index.Authors.Add(obj);
+        var list = new AuthorDto { Id = obj.Id, AuthorName = obj.AuthorName, Gender = obj.Gender };
+        //将数据返回（我这里返回的数据中将Password隐藏了，如果不需要隐藏，以下返回改为obj）
+        return list;
+    }
+    //修改
+    public AuthorDto? Edit(Guid guid, AuthorEditDto authorEditDto)
+    {
+        //先在内存型数据库中找到是否有这个guid
+        var list = AuthorStoreDb.Index.Authors.FirstOrDefault(item => item.Id == guid);
+        if (list == null)
+        {
+            return null;
+        }
+        //不为空就不会执行上面的return，继续下面的内容
+        //给找到的去数据赋值，authorEditDto是传进来修改的内容
+        list.AuthorName = authorEditDto.AuthorName;
+        list.Gender = authorEditDto.Gender;
+        list.Password = authorEditDto.Password;
+        //创建一个AuthrDto保存需要返回的数据（我这里返回的数据中将Password隐藏了，如果不需要隐藏，以下省略）
+        var result = new AuthorDto
+        {
+            Id = guid,
+            AuthorName = list.AuthorName,
+            Gender = list.Gender
+        };
+        //将数据返回（我这里返回的数据中将Password隐藏了，如果不需要隐藏，以下返回改为list）
+        return result;
+    }
+```
\ No newline at end of file
diff --git "a/\350\242\201\344\271\213\346\201\222/20240604-\345\210\240\351\231\244.md" "b/\350\242\201\344\271\213\346\201\222/20240604-\345\210\240\351\231\244.md"
new file mode 100644
index 0000000000000000000000000000000000000000..ce469f198c754b449adc2db1d8d656579be95fd1
--- /dev/null
+++ "b/\350\242\201\344\271\213\346\201\222/20240604-\345\210\240\351\231\244.md"
@@ -0,0 +1,57 @@
+## Web项目讲解（删除）
+- AuthorController
+```csharp
+  //删除
+    [HttpDelete("{id}")]
+    public IActionResult Del(Guid id)
+    {
+        //用我们注入的接口，使用其中我们定义的函数方法去实现功能
+        var list = _authorRepository.Delete(id);
+        return Ok(list);
+    }
+```
+- IAuthorRepository
+```csharp
+using Admin8.Domain;
+using Admin8.Dto;
+
+namespace Admin8.Interface;
+
+public interface IAuthorRepository
+{
+    //定义接口中的函数，返回类型，形参
+    //定义获取的方法
+    ICollection<AuthorDto>? GetAllAuthors(Guid id);
+    //定义增加的方法
+    AuthorDto Create(AuthorCreateDto authorCreateDto);
+    //定义编辑的方法
+    AuthorDto? Edit(Guid id, AuthorEditDto authorEditDto);
+    //定义删除的方法
+    AuthorDto? Delete(Guid id);
+}
+```
+- AuthorRepository
+```csharp
+ //删除
+    public AuthorDto? Delete(Guid id)
+    {
+        //先在内存型数据库中找到是否有这个guid
+        var obj = AuthorStoreDb.Index.Authors.FirstOrDefault(item => item.Id == id);
+        if (obj == null)
+        {
+            return null;
+        }
+        //不为空就不会执行上面的return，继续下面的内容
+        //先在内存型数据库中使用Remove去删除这个obj内容（不是还用item什么的，直接把这个找到的对象放进去）
+        AuthorStoreDb.Index.Authors.Remove(obj);
+        //创建一个AuthrDto保存需要返回的数据（我这里返回的数据中将Password隐藏了，如果不需要隐藏，以下省略）
+        var result = new AuthorDto
+        {
+            Id = obj.Id,
+            AuthorName = obj.AuthorName,
+            Gender = obj.Gender
+        };
+        //将数据返回（我这里返回的数据中将Password隐藏了，如果不需要隐藏，以下返回改为要删除的对象obj）
+        return result;
+    }
+```
\ No newline at end of file
diff --git "a/\350\242\201\344\271\213\346\201\222/20240606-EF Core\344\273\213\347\273\215.md" "b/\350\242\201\344\271\213\346\201\222/20240606-EF Core\344\273\213\347\273\215.md"
new file mode 100644
index 0000000000000000000000000000000000000000..e0d8f04458e2805130273caa3e8e25f73d661c26
--- /dev/null
+++ "b/\350\242\201\344\271\213\346\201\222/20240606-EF Core\344\273\213\347\273\215.md"	
@@ -0,0 +1,55 @@
+### EF Core 简介：
+
+#### 1. 概念：
+- **EF Core（Entity Framework Core）**：是基于.NET Core的轻量级ORM框架，用于处理数据库与高级编程语言对象之间的映射关系。
+- **ORM**：对象关系映射，能够处理数据库与高级编程语言中对象之间的映射关系。
+
+#### 2. .NET对象与关系型数据库的对应关系：
+
+| .NET对象| 关系型数据库 |
+|-|-|
+| 类| 表|
+| 类的属性或字段|表中的列|
+| 集合中的元素|表中的行|
+| 对于其他类的引用| 外键|
+
+#### 3. 支持 LINQ（集成语言查询）：
+- **查询所有**：
+  ```c#
+  var result = from item in collection
+               select item;
+  ```
+- **过滤**：
+  ```c#
+  var result = from item in collection
+               where price > 10
+               select item;
+  ```
+- **排序**：
+  ```c#
+  var result = from item in collection
+               orderby item.Property ascending/descending
+               select item;
+  ```
+  （ascending：升序，默认；descending：降序）
+- **连接查询**：
+  ```c#
+  var query = from person in people
+              join address in addresses on person.AddressId equals address.Id
+              select new { person.Name, address.City };
+  ```
+
+### 在项目中添加 EF Core：
+
+#### 1. 安装包：
+```js
+dotnet add package Microsoft.EntityFrameworkCore
+```
+
+#### 2. 安装提供程序：
+```js
+// 以 SQL Server 为例
+dotnet add package Microsoft.EntityFrameworkCore.SqlServer
+```
+
+通过 EF Core，您可以轻松地进行对象与关系型数据库之间的映射，并利用 LINQ 进行灵活的数据查询和操作。安装 EF Core 包和相应的数据库提供程序后，您可以开始在项目中使用 EF Core 进行数据库操作。
\ No newline at end of file
diff --git "a/\350\242\201\344\271\213\346\201\222/20240607-EF Core\347\232\204\344\275\277\347\224\250.md" "b/\350\242\201\344\271\213\346\201\222/20240607-EF Core\347\232\204\344\275\277\347\224\250.md"
new file mode 100644
index 0000000000000000000000000000000000000000..2476e2a4ceffd4987d49e666116c436b4bc5b6a5
--- /dev/null
+++ "b/\350\242\201\344\271\213\346\201\222/20240607-EF Core\347\232\204\344\275\277\347\224\250.md"	
@@ -0,0 +1,58 @@
+## EF Core 的两种使用方法
+
+### 1. 代码优先
+- 根据先创建好的实体类来创建数据库和表。
+- EF Core会将对实体类的修改同步到数据库中，手动修改数据库可能会导致数据丢失。
+- 使用迁移（Migration）来同步代码到数据库，以增量的方式修改数据库和表结构，保持实体类和数据库一致。
+
+### 2. 数据库优先
+- 根据先创建好的数据库生成相应的代码。
+
+## EF Core 添加步骤（代码优先）
+
+### 1. 创建数据模型
+- 创建数据模型类，这些类将映射到数据库中的表。
+
+### 2. 配置数据库连接
+```json
+"ConnectionString": {
+    "Mssql": "server=.;database=BookStore;uid=sa;pwd=123456;TrustServerCertificate=true;"
+}
+```
+
+### 3. 配置数据库上下文 DbContext
+- DbContext 是重要的类，代表程序与数据库之间的会话或数据上下文，用于查询和保存数据操作。
+- 在派生类中定义 `DbSet<Entity>` 类型的公共属性，表示相应实体的集合，对它们的操作会反映到数据表。
+
+### 4. 注入服务，引入配置文件，实现连接数据库
+```csharp
+// Startup.cs
+services.AddDbContext<BookStoreDbContext>(config => 
+    config.UseSqlServer(Configuration.GetConnectionString("Mssql"))
+    // 需要安装 Microsoft.EntityFrameworkCore.SqlServer 包后才能使用 UseSqlServer
+);
+```
+
+### 5. 生成迁移与创建数据库
+```shell
+# 安装 dotnet-ef 工具
+dotnet tool install -g dotnet-ef
+
+# 生成迁移
+dotnet ef migrations add <MigrationName>
+
+# 创建数据库（同步）
+dotnet ef database update
+```
+**注意：**
+- 迁移名称最好是英文且首字母大写。
+- 使用迁移前需要安装 `Microsoft.EntityFrameworkCore.SqlServer` 包。
+- 需要全局安装 `dotnet-ef` 工具。
+- 代码中不能有错误，否则迁移会报错。
+
+### 6. 添加种子数据
+- **方法一**：为种子数据建模，使用 `HasData` 方法添加种子数据。
+- **方法二**：手动向迁移添加数据或自定义操作。
+- **方法三**：自定义初始化逻辑，在应用程序启动时执行数据种子设定。
+
+请确保在实际使用时，根据项目的具体需求和环境配置，对以上步骤进行适当的调整。
\ No newline at end of file