.NET EF Core（Entity Framework Core）是微软开发的一款开源的对象关系映射（ORM）框架，用于在.NET 应用程序中与数据库进行交互。以下是一些.NET EF Core 的基础知识：
1. 什么是 EF Core
EF Core 是.NET 平台下的一个数据访问技术，它允许开发者使用.NET 对象来表示数据库中的数据，并通过对象的操作来实现对数据库的增删改查等操作，无需编写大量的 SQL 语句。
2. 核心概念
- DbContext：是 EF Core 中的核心类，它表示与数据库的会话，用于管理实体对象的生命周期、跟踪对象的变化以及与数据库进行交互。例如，通过
DbContext可以查询数据库中的数据、将新对象插入到数据库、更新或删除现有对象等。 - 实体类：是用于表示数据库表中数据的.NET 类。每个实体类的实例对应数据库表中的一行数据，实体类的属性对应表中的列。例如，可以创建一个
User实体类来表示数据库中的User表，其中User类的Id属性对应User表中的Id列。 - DbSet：是
DbContext中的属性，用于表示数据库中的表。它提供了对实体类集合的操作，例如查询、添加、删除实体等。例如，在DbContext中定义DbSet<User>，就可以通过它来操作User实体对应的数据库表。
3. 安装与配置
- 安装：可以通过 NuGet 包管理器安装 EF Core 相关的包。例如，要使用 SQL Server 数据库，需要安装
Microsoft.EntityFrameworkCore.SqlServer包。 - 配置：在
Startup.cs文件的ConfigureServices方法中，需要配置DbContext。例如，对于 SQL Server 数据库，可以使用以下代码配置：
csharp
services.AddDbContext<ApplicationDbContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
这里ApplicationDbContext是自定义的DbContext类，DefaultConnection是在配置文件中定义的数据库连接字符串。
4. 数据迁移
EF Core 的数据迁移功能允许开发者在不丢失数据的情况下对数据库架构进行更改。例如，当实体类的属性发生变化时，可以通过数据迁移来更新数据库表的结构。可以使用命令行工具dotnet ef migrations add <MigrationName>来添加一个新的迁移，然后使用dotnet ef database update来将迁移应用到数据库。
5. 查询数据
可以使用DbSet的Query方法来查询数据。例如，要查询所有的User实体，可以使用以下代码：
csharp
using (var context = new ApplicationDbContext())
{
var users = context.Users.ToList();
}
还可以使用 LINQ 语句对查询进行过滤、排序等操作。例如，查询年龄大于 18 岁的用户：
csharp
using (var context = new ApplicationDbContext())
{
var users = context.Users.Where(u => u.Age > 18).ToList();
}
6. 插入、更新和删除数据
- 插入数据：创建一个实体类的实例，然后使用
DbSet的Add方法将其添加到DbContext中，最后调用SaveChanges方法将数据保存到数据库。例如：
csharp
using (var context = new ApplicationDbContext())
{
var user = new User { Name = "John Doe", Age = 25 };
context.Users.Add(user);
context.SaveChanges();
}
- 更新数据：先从数据库中获取要更新的实体对象，然后修改其属性值，最后调用
SaveChanges方法保存更改。例如：
csharp
using (var context = new ApplicationDbContext())
{
var user = context.Users.FirstOrDefault(u => u.Id == 1);
if (user!= null)
{
user.Name = "Jane Doe";
context.SaveChanges();
}
}
- 删除数据：从数据库中获取要删除的实体对象，然后使用
DbSet的Remove方法将其从DbContext中移除，最后调用SaveChanges方法。例如：
csharp
using (var context = new ApplicationDbContext())
{
var user = context.Users.FirstOrDefault(u => u.Id == 1);
if (user!= null)
{
context.Users.Remove(user);
context.SaveChanges();
}
}
7. 关系映射
EF Core 支持实体之间的关系映射，如一对一、一对多、多对多关系。例如，一个User可以有多个Order，这是一对多关系。可以通过在实体类中定义导航属性来表示这种关系。例如，在User类中定义ICollection<Order>类型的属性来表示用户的订单集合，在Order类中定义User类型的属性来表示订单所属的用户。
8.基础操作类
9.通用EF的Service类和IService
using IService;
using System;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;
namespace IService
{
public interface IBaseService
{
#region--伪代码
//public void Add();
//public void Delete();
//public void Update();
//public void Query();
#endregion
#region Query
/// <summary>
/// 主键查询
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="id"></param>
/// <returns></returns>
public T Find<T>(int id) where T : class;
/// <summary>
/// 不应该暴露给上端使用者，尽量少用
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
//[Obsolete("尽量避免使用，using 带表达式目录树的代替")]
public IQueryable<T> Set<T>() where T : class;
/// <summary>
/// 这才是合理的做法，上端给条件，这里查询
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="funcWhere"></param>
/// <returns></returns>
public IQueryable<T> Query<T>(Expression<Func<T, bool>> funcWhere) where T : class;
/// <summary>
/// 分页查询
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="S"></typeparam>
/// <param name="funcWhere"></param>
/// <param name="pageSize"></param>
/// <param name="pageIndex"></param>
/// <param name="funcOrderby"></param>
/// <param name="isAsc"></param>
/// <returns></returns>
public PagingData<T> QueryPage<T, S>(Expression<Func<T, bool>> funcWhere, int pageSize, int pageIndex, Expression<Func<T, S>> funcOrderby, bool isAsc = true) where T : class;
#endregion
#region Insert
/// <summary>
/// 即使保存 不需要再Commit
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="t"></param>
/// <returns></returns>
public T Insert<T>(T t) where T : class;
/// <summary>
/// 新增集合
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="tList"></param>
/// <returns></returns>
public IEnumerable<T> Insert<T>(IEnumerable<T> tList) where T : class;
#endregion
#region Update
/// <summary>
/// 是没有实现查询，直接更新的,需要Attach和State
///
/// 如果是已经在context，只能再封装一个(在具体的service)
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="t"></param>
public void Update<T>(T t) where T : class;
/// <summary>
/// 修改一个集合
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="tList"></param>
public void Update<T>(IEnumerable<T> tList) where T : class;
#endregion
#region Delete
/// <summary>
/// 先附加 再删除
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="t"></param>
public void Delete<T>(T t) where T : class;
/// <summary>
/// 还可以增加非即时commit版本的，
/// 做成protected
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="Id"></param>
public void Delete<T>(int Id) where T : class;
public void Delete<T>(IEnumerable<T> tList) where T : class;
#endregion
#region Other
/// <summary>
/// 执行Sql语句，返回IQueryable
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="sql"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public IQueryable<T> ExcuteQuery<T>(string sql, SqlParameter[] parameters) where T : class;
/// <summary>
/// 执行Sql语句，返回实体对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="sql"></param>
/// <param name="parameters"></param>
public void Excute<T>(string sql, SqlParameter[] parameters) where T : class;
#endregion
List<T> FindEntitiesByProperty<T, TProperty>(System.Linq.Expressions.Expression<System.Func<T, TProperty>> propertySelector, TProperty value) where T : class;
}
}
----------------------------------------------------------------------------------
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Storage;
using System;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;
using IService;
namespace Service
{
public abstract class BaseService : IBaseService
{
#region--伪代码
//public void Add()
//{
// throw new NotImplementedException();
//}
//public void Delete()
//{
// throw new NotImplementedException();
//}
//public void Query()
//{
// throw new NotImplementedException();
//}
//public void Update()
//{
// throw new NotImplementedException();
//}
#endregion
protected DbContext Context { get; set; }
/// <summary>
/// 构造函数注入
/// </summary>
/// <param name="context"></param>
public BaseService(DbContext context)
{
Context = context;
}
#region Query
/// <summary>
/// 主键查询
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="id"></param>
/// <returns></returns>
public T Find<T>(int id) where T : class
{
return this.Context.Set<T>().Find(id);
}
/// <summary>
/// 不应该暴露给上端使用者，尽量少用
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
//[Obsolete("尽量避免使用，using 带表达式目录树的代替")]
public IQueryable<T> Set<T>() where T : class
{
return this.Context.Set<T>();
}
/// <summary>
/// 这才是合理的做法，上端给条件，这里查询
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="funcWhere"></param>
/// <returns></returns>
public IQueryable<T> Query<T>(Expression<Func<T, bool>> funcWhere) where T : class
{
return this.Context.Set<T>().Where<T>(funcWhere);
}
/// <summary>
/// 分页查询
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="S"></typeparam>
/// <param name="funcWhere"></param>
/// <param name="pageSize"></param>
/// <param name="pageIndex"></param>
/// <param name="funcOrderby"></param>
/// <param name="isAsc"></param>
/// <returns></returns>
public PagingData<T> QueryPage<T, S>(Expression<Func<T, bool>> funcWhere, int pageSize, int pageIndex, Expression<Func<T, S>> funcOrderby, bool isAsc = true) where T : class
{
var list = Set<T>();
if (funcWhere != null)
{
list = list.Where<T>(funcWhere);
}
if (isAsc)
{
list = list.OrderBy(funcOrderby);
}
else
{
list = list.OrderByDescending(funcOrderby);
}
PagingData<T> result = new PagingData<T>()
{
DataList = list.Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList(),
PageIndex = pageIndex,
PageSize = pageSize,
RecordCount = list.Count()
};
return result;
}
#endregion
#region Insert
/// <summary>
/// 即使保存 不需要再Commit
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="t"></param>
/// <returns></returns>
public T Insert<T>(T t) where T : class
{
this.Context.Set<T>().Add(t);
this.Commit();//写在这里 就不需要单独commit 不写就需要
return t;
}
public IEnumerable<T> Insert<T>(IEnumerable<T> tList) where T : class
{
this.Context.Set<T>().AddRange(tList);
this.Commit();//一个链接 多个sql
return tList;
}
#endregion
#region Update
/// <summary>
/// 是没有实现查询，直接更新的,需要Attach和State
///
/// 如果是已经在context，只能再封装一个(在具体的service)
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="t"></param>
public void Update<T>(T t) where T : class
{
if (t == null) throw new Exception("t is null");
this.Context.Set<T>().Attach(t);//将数据附加到上下文，支持实体修改和新实体，重置为UnChanged
this.Context.Entry<T>(t).State = EntityState.Modified;
this.Commit();//保存 然后重置为UnChanged
}
public void Update<T>(IEnumerable<T> tList) where T : class
{
foreach (var t in tList)
{
this.Context.Set<T>().Attach(t);
this.Context.Entry<T>(t).State = EntityState.Modified;
}
this.Commit();
}
#endregion
#region Delete
/// <summary>
/// 先附加 再删除
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="t"></param>
public void Delete<T>(T t) where T : class
{
if (t == null) throw new Exception("t is null");
this.Context.Set<T>().Attach(t);
this.Context.Set<T>().Remove(t);
this.Commit();
}
/// <summary>
/// 还可以增加非即时commit版本的，
/// 做成protected
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="Id"></param>
public void Delete<T>(int Id) where T : class
{
T t = this.Find<T>(Id);//也可以附加
if (t == null) throw new Exception("t is null");
this.Context.Set<T>().Remove(t);
this.Commit();
}
public void Delete<T>(IEnumerable<T> tList) where T : class
{
foreach (var t in tList)
{
this.Context.Set<T>().Attach(t);
}
this.Context.Set<T>().RemoveRange(tList);
this.Commit();
}
#endregion
#region Other
public void Commit()
{
Context.SaveChanges(); //EFCore中对于增删改 ,必须要执行这句话才能生效
}
/// <summary>
/// 执行Sql语句，返回IQueryable
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="sql"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public IQueryable<T> ExcuteQuery<T>(string sql, SqlParameter[] parameters) where T : class
{
return this.Context.Set<T>().FromSqlRaw(sql, parameters);
}
/// <summary>
/// 执行Sql语句，返回实体对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="sql"></param>
/// <param name="parameters"></param>
public void Excute<T>(string sql, SqlParameter[] parameters) where T : class
{
IDbContextTransaction trans = null;
try
{
trans = Context.Database.BeginTransaction();
this.Context.Database.ExecuteSqlRaw(sql, parameters);
trans.Commit();
}
catch (Exception)
{
if (trans != null)
trans.Rollback();
throw;
}
}
/// <summary>
/// 释放回收
/// </summary>
public virtual void Dispose()
{
if (Context != null)
{
Context.Dispose();
}
}
#endregion
public List<T> FindEntitiesByProperty<T, TProperty>(Expression<Func<T, TProperty>> propertySelector, TProperty value) where T : class
{
var propertyValueEqualExpression = Expression.Equal(propertySelector.Body, Expression.Constant(value));
var lambda = Expression.Lambda<Func<T, bool>>(propertyValueEqualExpression, propertySelector.Parameters);
return Context.Set<T>().Where(lambda).ToList();
}
}
}
10.创建表的案例
using DbModels;
using static System.Runtime.InteropServices.JavaScript.JSType;
namespace Initial_EFDB
{
internal class Program
{
static void Main(string[] args)
{
string connectionString = "Data Source=WIN-20240630YNV\\SQLEXPRESS;" +
"Initial Catalog= EFCoreTestDB;Persist Security Info=True;User ID=sa;" +
"Password=lyh2016;Encrypt=True;Trust Server Certificate=True";
Console.WriteLine("Hello, World!");
using (AgiletyDbContext context = new AgiletyDbContext(connectionString))
{
//根据数据库连接字符串的配置删除数据库，如果不存在就不操作
context.Database.EnsureDeleted();
//根据数据库连接字符串的配置创建数据库，如果存在就不创建
context.Database.EnsureCreated();
var adduser = new DbModels.Models.UserEntity()
{
Address = "武汉市",
Email = "18672554858@163.com",
Imageurl = "",
LastLoginTime = DateTime.Now,
Mobile = "18672554858",
Name = "Ricahrd",
Password = "123456",
QQ = "8542313245",
Phone = "15845858858",
Sex = 1,
UserType = 1,
WeChat = ""
};
context.UserEntities.Add(adduser);
context.SaveChanges();
查询
//UserEntity user = context.UserEntities.OrderByDescending(c => c.UserId).FirstOrDefault();
//user.Name = "Richard 老师";
//context.SaveChanges();
//context.Remove(user);
//context.SaveChanges();
}
}
}
}
11.数据操作案例UserService和IUserService
using ModelDto;
namespace IService
{
public interface IUserService: IBaseService
{
/// <summary>
/// 登录功能
/// </summary>
/// <param name="userName"></param>
/// <param name="password"></param>
/// <returns></returns>
public UserDto? Login(string userName, string password);
public void ShowUserAndCompany();
public void SetUserAndCompany();
}
}
-----------------------------------------------------------------------
using AutoMapper;
using Microsoft.EntityFrameworkCore;
using DbModels.Models;
using IService;
using ModelDto;
using Service;
namespace Zhaoxi.AgiletyFramework.BusinessServices
{
public class UserService : BaseService, IUserService
{
private readonly IMapper _IMapper;
public UserService(DbContext context, IMapper iMapper) : base(context)
{
_IMapper = iMapper;
}
/// <summary>
/// 登录功能
/// </summary>
/// <param name="userName"></param>
/// <param name="password"></param>
/// <returns></returns>
public UserDto? Login(string userName, string password)
{
string pwd = password;// MD5Encrypt.Encrypt(password);
List<UserEntity> userList = Context
.Set<UserEntity>()
.Where(c => c.Name.Equals(userName) && c.Password.Equals(pwd))
.ToList();
if (userList == null || userList.Count <= 0)
{
return null;
}
UserEntity user = userList.First();
UserDto userDto = _IMapper.Map<UserEntity, UserDto>(user);
List<int> roleIdList = Context
.Set<UserRoleMapEntity>()
.Where(c => c.UserId == user.UserId)
.Select(r => r.RoleId).ToList();
userDto.RoleIdList = roleIdList;//设置登录用户角色
//登录用户的菜单id
List<Guid> userMenuIds = Context.Set<RoleMenuMapEntity>()
.Where(c => roleIdList.Contains(c.Id))
.Select(c => c.MenuId)
.ToList();
return userDto;
}
/// <summary>
/// Autofac支持额aop扩展，如果通过类的方式来支持Aop，只有定义成Virtual方法，才能够进入到aop内部去；
/// </summary>
public virtual void SetUserAndCompany()
{
}
public void ShowUserAndCompany()
{
}
}
}12.控制器的应用案例
using AutoMapper;
using DbModels.Models;
using EFTest.Comm;
using IService;
using Microsoft.AspNetCore.Mvc;
using ModelDto;
using Service;
namespace EFTest.Controllers
{
/// <summary>
/// Api控制器，用户相关的API
/// </summary>
[Route("api/[controller]/[action]")] // 修改路由前缀，包含控制器名称和方法名称
[ApiController]
public class UserController : ControllerBase
{
private readonly IUserService _IUserService;
private readonly IMapper _IMapper; //AutoMapper映射使用
/// <summary>
/// 构造函数
/// </summary>
/// <param name="iUserService"></param>
/// <param name="iMapper"></param>
public UserController( IUserService iUserService, IMapper iMapper)
{
_IUserService = iUserService;
_IMapper = iMapper;
}
/// <summary>
/// 获取用户的分页列表
/// </summary>
/// <param name="pageindex"></param>
/// <param name="pageSize"></param>
/// <param name="searchaString"></param>
/// <returns></returns>
[HttpGet]
[Route("{pageindex:int}/{pageSize:int}")]
[Route("{pageindex:int}/{pageSize:int}/{searchaString}")]
public async Task<JsonResult> GetUserPageAsync(int pageindex, int pageSize, string? searchaString = null)
{
PagingData<UserEntity> paging = _IUserService
.QueryPage<UserEntity, DateTime>(!string.IsNullOrWhiteSpace(searchaString) ? c => c.Name.Contains(searchaString) : a => true, pageSize, pageindex, c => c.CreateTime, false);
PagingData<UserDto> pagingResult = _IMapper.Map<PagingData<UserEntity>, PagingData<UserDto>>(paging);
JsonResult result = new JsonResult(new ApiDataResult<PagingData<UserDto>>()
{
Data = pagingResult,
Success = true,
Message = "用户分页列表"
});
return await Task.FromResult(result);
}
/// <summary>
/// 新增用户
/// </summary>
/// <param name="userDto"></param>
/// <returns></returns>
[HttpPost]
public async Task<JsonResult> AddUserAsync([FromBody] AddUserDto userDto)
{
UserEntity adduser = _IMapper.Map<AddUserDto, UserEntity>(userDto);
UserEntity user = _IUserService.Insert(adduser);
var result = new JsonResult(new ApiDataResult<UserEntity>() { Data = adduser, Success = true, Message = "添加用户" });
if (user.UserId <= 0)
{
result = new JsonResult(new ApiDataResult<UserEntity>() { Data = adduser, Success = false, Message = "添加用户失败" });
}
return await Task.FromResult(result);
}
/// <summary>
/// 根据名称查询用户列表
/// </summary>
/// <param name="name">要查询的用户名</param>
/// <returns>符合条件的用户列表</returns>
[HttpGet]
public IActionResult SelectByName(string name)
{
if (string.IsNullOrEmpty(name))
{
return BadRequest("用户名不能为空");
}
var userList = _IUserService.FindEntitiesByProperty<UserEntity, string>(u => u.Name, name);
return Ok(userList);
}
/// <summary>
/// 基于 name 对 User 模型进行数据更新
/// <param name="updatedUser">更新后的用户数据</param>
/// <returns>返回更新结果信息</returns>
[HttpPost]
public async Task<IActionResult> UpdateUserByName(UserEntity updatedUser)
{
try
{
// 根据 name 查询用户列表
var usersToUpdate = _IUserService.FindEntitiesByProperty<UserEntity, string>(u => u.Name ,updatedUser.Name);
if (usersToUpdate == null || usersToUpdate.Count == 0)
{
return NotFound($"没有找到名为 {updatedUser.Name} 的用户");
}
// 更新每个找到的用户
foreach (var user in usersToUpdate)
{
// 这里简单地将更新后的属性值赋给原用户对象，你可以根据实际需求进行更复杂的属性更新逻辑
//user.UserId = updatedUser.UserId;
user.Sex = updatedUser.Sex;
user.Address = updatedUser.Address;
user.Name= updatedUser.Name;
_IUserService.Update(user);
}
return Ok($"成功更新了名为 {updatedUser.Name} 的用户数据");
}
catch (Exception ex)
{
return StatusCode(500, $"更新用户数据时发生错误: {ex.Message}");
}
}
/// <summary>
/// 基于 name 对 User 模型进行数据删除
/// </summary>
/// <param name="name">要删除的用户的 name</param>
/// <returns>返回删除结果信息</returns>
[HttpDelete("{name}")]
public async Task<IActionResult> DeleteUserByName(string name)
{
try
{
// 根据 name 查询用户列表
var usersToDelete = _IUserService.FindEntitiesByProperty<UserEntity, string>(u => u.Name, name);
if (usersToDelete == null || usersToDelete.Count == 0)
{
return NotFound($"没有找到名为 {name} 的用户");
}
// 删除每个找到的用户
_IUserService.Delete<UserEntity>(usersToDelete);
return Ok($"成功删除了名为 {name} 的用户数据");
}
catch (Exception ex)
{
return StatusCode(500, $"删除用户数据时发生错误: {ex.Message}");
}
}
/// <summary>
/// 查询 user 表所有数据
/// </summary>
/// <returns>返回 user 表的所有数据</returns>
[HttpGet]
public async Task<IActionResult> GetAllUsers()
{
try
{
// 调用 IBaseService 的 Query 方法查询所有 User 数据
var users = _IUserService.Query<UserEntity>(u => true).ToList();
return Ok(users);
}
catch (Exception ex)
{
return StatusCode(500, $"查询用户数据时发生错误: {ex.Message}");
}
}
}
}
扫一扫
1487
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
