Entity Framework Core开发采用Repository与DbContext优势和劣势，及开发的方便与快速

本文链接：https://blog.csdn.net/zzlyx99/article/details/143674002

一、使用仓储模式（Repository Pattern）与直接使用 `DbContext` 各有其优势和劣势

在 Entity Framework Core (EF Core) 开发中，使用仓储模式（Repository Pattern）与直接使用 DbContext 各有其优势和劣势。以下是两者的比较：

（一）使用仓储模式（Repository Pattern）

优势：

抽象和封装：仓储模式为数据访问提供了一个抽象层，这有助于将数据访问逻辑与业务逻辑分离，从而提高代码的可维护性和可测试性。
解耦合：通过使用仓储模式，可以更容易地在不同的数据存储技术之间切换，因为业务逻辑不依赖于特定的数据访问实现。
复用性：仓储可以封装常用的数据访问逻辑，使得这些逻辑可以在不同的业务逻辑中复用。
简化单元测试：使用仓储模式可以更容易地为业务逻辑编写单元测试，因为可以通过模拟仓储接口来隔离依赖。

劣势：

复杂性增加：引入仓储模式会增加代码的复杂性，需要更多的类和接口来实现这一模式。
性能开销：在某些情况下，仓储模式可能会引入额外的性能开销，尤其是在处理复杂查询时。

（二）直接使用 DbContext

优势：

简洁性：直接使用 DbContext 可以减少代码的复杂性，因为不需要定义额外的仓储接口和类。
性能：在某些情况下，直接使用 DbContext 可能会比使用仓储模式有更好的性能，因为它减少了中间层的调用。

劣势：

耦合度高：直接使用 DbContext 可能会导致业务逻辑与数据访问逻辑高度耦合，这可能会使得代码难以维护和测试。
缺乏抽象：没有使用仓储模式，就不容易实现数据访问逻辑的抽象和封装，这可能会使得在不同的数据存储技术之间切换变得困难。

在实际应用中，是否使用仓储模式或直接使用 DbContext 取决于具体的项目需求、团队习惯以及性能考量。对于复杂的应用程序，使用仓储模式可能更有助于维护代码的清晰度和可测试性。对于简单的应用程序或快速开发，直接使用 DbContext 可能更为方便和高效

二、repository与DbContext在开发对数据库操作

在 Entity Framework Core (EF Core) 开发中，使用仓储模式（Repository Pattern）与直接使用 DbContext 进行数据库操作在语法和实现上存在一些差异。以下是两者的主要区别：

（一）直接使用 DbContext

当直接使用 DbContext 时，你会在业务逻辑中直接调用 DbContext 的方法来执行数据库操作。例如，查询、插入、更新和删除操作可以直接在控制器或服务层中实现：

csharp

public class OrderService
{
    private readonly AppDbContext _dbContext;

    public OrderService(AppDbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public async Task<Order> GetOrderAsync(int id)
    {
        return await _dbContext.Orders.FindAsync(id);
    }

    public async Task InsertOrderAsync(Order order)
    {
        await _dbContext.Orders.AddAsync(order);
        await _dbContext.SaveChangesAsync();
    }

    // 其他数据库操作方法...
}

（二）使用仓储模式

使用仓储模式时，你会创建一个或多个接口来定义数据库操作，然后在实现这些接口的类中封装 DbContext 的操作。这种方式将数据访问逻辑从业务逻辑中分离出来：

csharp复制

public interface IOrderRepository
{
    Task<Order> GetAsync(int id);
    Task<List<Order>> GetListAsync();
    Task<Order> InsertAsync(Order order);
    Task<Order> UpdateAsync(Order order);
    Task DeleteAsync(Order order);
}

public class OrderRepository : IOrderRepository
{
    private readonly AppDbContext _dbContext;

    public OrderRepository(AppDbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public async Task<Order> GetAsync(int id)
    {
        return await _dbContext.Orders.AsNoTracking().FirstAsync(o => o.Id == id);
    }

    public async Task<List<Order>> GetListAsync()
    {
        return await _dbContext.Orders.AsNoTracking().ToListAsync();
    }

    public async Task<Order> InsertAsync(Order order)
    {
        await _dbContext.Orders.AddAsync(order);
        await _dbContext.SaveChangesAsync();
        return order;
    }

    public async Task<Order> UpdateAsync(Order order)
    {
        _dbContext.Update(order);
        await _dbContext.SaveChangesAsync();
        return order;
    }

    public async Task DeleteAsync(Order order)
    {
        _dbContext.Orders.Remove(order);
        await _dbContext.SaveChangesAsync();
    }
}

在控制器中使用仓储接口，而不是直接使用 DbContext：

csharp

[ApiController]
[Route("[controller]")]
public class OrderController : ControllerBase
{
    private readonly IOrderRepository _orderRepository;

    public OrderController(IOrderRepository orderRepository)
    {
        _orderRepository = orderRepository;
    }

    [HttpGet("{id}")]
    public async Task<Order> GetAsync(int id)
    {
        return await _orderRepository.GetAsync(id);
    }

    [HttpGet]
    public async Task<List<Order>> GetListAsync()
    {
        return await _orderRepository.GetListAsync();
    }

    [HttpPost]
    public async Task<int> CreateAsync(string name)
    {
        var order = new Order()
        {
            Name = name,
            CreateDate = DateTime.UtcNow,
        };
        order = await _orderRepository.InsertAsync(order);
        return order.Id;
    }

    [HttpPut("{id}")]
    public async Task<int> UpdateAsync(int id, string name)
    {
        var order = await _orderRepository.GetAsync(id);
        order.Name = name;
        order = await _orderRepository.UpdateAsync(order);
        return order.Id;
    }

    [HttpDelete("{id}")]
    public async Task DeleteAsync(int id)
    {
        var order = await _orderRepository.GetAsync(id);
        await _orderRepository.DeleteAsync(order);
    }
}

（三）性能比较

直接使用 DbContext 可能会在某些情况下提供更好的性能，因为它减少了中间层的调用。然而，使用仓储模式可以提供更好的抽象和封装，有助于代码的可维护性和可测试性，尽管可能会引入一些性能开销。

（四）代码维护

使用仓储模式可以提供更好的代码维护性，因为它将数据访问逻辑与业务逻辑分离，使得代码更易于理解和修改。而直接使用 DbContext 可能会导致业务逻辑与数据访问逻辑高度耦合，使得代码难以维护和测试。

三、repository与DbContext，如何写复杂的SQL脚本

在 Entity Framework Core (EF Core) 中，使用仓储模式（Repository Pattern）与直接使用 DbContext 都可以执行复杂的 SQL 脚本。不过，每种方法在处理复杂 SQL 脚本时都有其特定的实践方式。以下是一些示例：

（一）直接使用 DbContext

当直接使用 DbContext 时，你可以使用 FromSqlRaw 或 FromSqlInterpolated 方法来执行原始 SQL 查询，或者使用 ExecuteSqlRaw 或 ExecuteSqlInterpolated 方法来执行 SQL 命令。

csharp

public class DeviceService
{
    private readonly AppDbContext _context;

    public DeviceService(AppDbContext context)
    {
        _context = context;
    }

    public async Task<IEnumerable<Device>> GetDevicesWithCustomSqlAsync()
    {
        // 使用 FromSqlRaw 执行原始 SQL 查询
        var devices = await _context.Devices
            .FromSqlRaw("SELECT * FROM Devices WHERE IsActive = 1")
            .ToListAsync();

        return devices;
    }

    public async Task<int> UpdateDeviceStatusAsync(int id, bool isActive)
    {
        // 使用 ExecuteSqlRaw 执行 SQL 命令
        var affectedRows = await _context.Database
            .ExecuteSqlRaw("UPDATE Devices SET IsActive = {0} WHERE Id = {1}", isActive, id)
            .ConfigureAwait(false);

        return affectedRows;
    }
}

（二）使用仓储模式

在使用仓储模式时，你可以在仓储接口中定义自定义 SQL 方法，然后在仓储实现类中提供这些方法的逻辑。

csharp

public interface IDeviceRepository
{
    Task<IEnumerable<Device>> GetDevicesWithCustomSqlAsync();
    Task<int> UpdateDeviceStatusAsync(int id, bool isActive);
}

public class DeviceRepository : IDeviceRepository
{
    private readonly AppDbContext _context;

    public DeviceRepository(AppDbContext context)
    {
        _context = context;
    }

    public async Task<IEnumerable<Device>> GetDevicesWithCustomSqlAsync()
    {
        var devices = await _context.Devices
            .FromSqlRaw("SELECT * FROM Devices WHERE IsActive = 1")
            .ToListAsync();
        return devices;
    }

    public async Task<int> UpdateDeviceStatusAsync(int id, bool isActive)
    {
        var affectedRows = await _context.Database
            .ExecuteSqlRaw("UPDATE Devices SET IsActive = {0} WHERE Id = {1}", isActive, id)
            .ConfigureAwait(false);
        return affectedRows;
    }
}

（三）编写复杂的 SQL 脚本

对于复杂的 SQL 脚本，你可以直接在 FromSqlRaw 或 ExecuteSqlRaw 方法中编写 SQL 语句。如果脚本非常复杂，你可能需要将其保存在存储过程中，并从代码中调用这些存储过程。

sql

-- 存储过程示例
CREATE PROCEDURE UpdateDeviceStatus
    @Id INT,
    @IsActive BIT
AS
BEGIN
    UPDATE Devices
    SET IsActive = @IsActive
    WHERE Id = @Id
END

在 EF Core 中调用存储过程：

csharp复制

public async Task<int> UpdateDeviceStatusAsync(int id, bool isActive)
{
    var affectedRows = await _context.Database
        .ExecuteSqlRaw("EXEC UpdateDeviceStatus {0}, {1}", id, isActive)
        .ConfigureAwait(false);
    return affectedRows;
}

无论使用哪种方法，都要确保 SQL 脚本正确，并且要注意防止 SQL 注入攻击。对于复杂的查询，建议使用参数化查询或存储过程来提高安全性