当DBContext被抽象时，如何使用GraphDiff

本文关键字：何使用 GraphDiff DBContext 抽象 | 更新日期: 2023-09-27 18:30:43

我刚刚了解了GraphDiff，以及它应该如何处理断开连接的实体和存储在数据库中的实体之间的所有差异。

问题是我不知道如何使用 GraphDiff，我尝试了文档，但我不太了解它。

我正在使用抽象的DBContext，通过接口并使用DbSet，以便我可以对它们执行单元测试：

public interface IDbRepositories
{
    IDbSet<Client> ClientsDB { get;}
    AppIdentityDbContext DB { get; }
    IDbSet<Contacts> ContactsDB { get; }
    IDbSet<ExposureResult> ExposureDB { get; }
    IDbSet<OrderMods> OrderModsDB { get; }
    IDbSet<ProductDetails> ProductDetailsDB { get; }
    IDbSet<OrderProcess> OrderProcessDB { get; }
    IDbSet<Order> OrderDB { get; }
    void SaveChanges();
}

这是实现接口的实际类：

public class DbRepositories : IDbRepositories
{
    private AppIdentityDbContext db = new AppIdentityDbContext();
    //Get DB Context. This is done this way, so a Mock can be injected when testing
    public IDbSet<Client> ClientsDB
    {
        get { return db.Clients; }
    }
    public AppIdentityDbContext DB
    {
        get { return db; }
    }
    public IDbSet<Contacts> ContactsDB
    {
        get { return db.Contacts; }
    }
    public IDbSet<ExposureResult> ExposureDB
    {
        get { return db.ExposureTBL; }
    }
    public IDbSet<OrderMods> OrderModsDB
    {
        get { return db.OrderMods; }
    }
    public IDbSet<ProductDetails> ProductDetailsDB
    {
        get { return db.ProductDetailsTBL; }
    }
    public IDbSet<OrderProcess> OrderProcessDB
    {
        get { return db.OrderProcesses; }
    }
    public IDbSet<Order> OrderDB
    {
        get { return db.OrderTBL; }
    }
    public void SaveChanges()
    {
        this.db.SaveChanges();
    }
}

现在，问题部分在这里：

public bool SaveOrderChanges(OrderProcess[] Order, int OrderID, int uid)
{
    //2nd Step:
    var ComparableObject = dbs.OrderProcessDB.Where(x => x.OrderID == OrderID).ToList();
    var Objections = dbs.OrderDB.Where(x => x.OrderID == OrderID).FirstOrDefault();
    dbs.DB.UpdateGraph(dbs.OrderDB, m => m.OwnedCollection());
    dbs.SaveChanges();
    return true;
 }

我想告诉 Order 参数和我从 OrderProcessDB 中提取的参数之间的区别。这些是一对多的关系。

我不知道如何在这种情况中使用GraphDiff。有什么想法吗？

当DBContext被抽象时，如何使用GraphDiff

您可以在接口中公开基本的 DbContext 对象，但这会违反封装的基本原则。挑战在于UpdateGraph方法是具体DbContext类的静态扩展。这是我的解决方案：

首先是界面：

public interface IMyDbContext
{
    ...
    TEntity UpdateGraph<TEntity>(TEntity entity, Expression<Func<IUpdateConfiguration<TEntity>, object>> mapping = null) where TEntity : class, new();
}

然后是实际的 DbContext：

public class MyDbContext : DbContext, IMyDbContext
{
    ...
    public TEntity UpdateGraph<TEntity>(TEntity entity, Expression<Func<IUpdateConfiguration<TEntity>, object>> mapping = null) where TEntity : class, new()
    {
        return ((DbContext)this).UpdateGraph(entity, mapping);
    }
}

最后是存储库内部的用法示例：

public class MyRepository : IMyRepository
{
    private readonly IMyDbContext _myDbContext;
    public MyRepository (IMyDbContext myDbContext)
    {
        _myDbContext = myDbContext;
    }
    public async Task<SomeEntity> UpdateSomeEntity(SomeEntity updatedSomeEntity)
    {
        _myDbContext.UpdateGraph(updatedSomeEntity, map => map.OwnedCollection(p => p.SomeChildCollection));
        await _myDbContext.SaveChangesAsync();
        return updatedSomeEntity;
    }
}

我意识到这很旧，但我刚刚发现了 GraphDiff，希望可以帮助其他人查看。

以下是您使用 GraphDiff 的方式：

 db.UpdateGraph(orderToUpdate, map => map
                    .AssociatedCollection(t => t.Products)
                    .OwnedCollection(t => t.PaymentMethods));

这表示更新订单对象，并且订单拥有付款方式（意味着它实际上可以删除这些实体），并与产品实体相关联（意味着它将从引用表中删除它们）。

相关文章：