在抽象GraphDiff时，如何使用DBContext？

Question

我刚刚了解了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。有什么想法吗？

Answer 1

您可以在接口中公开基本的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;
    }
}

Answer 2

我意识到这很古老，但我刚刚发现了GraphDiff，希望能帮助其他人寻找。

以下是如何使用GraphDiff：

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

这意味着要更新Order对象，并且订单拥有PaymentMethods (意味着它实际上可以删除这些实体)，并且与产品实体相关联(这意味着它将从引用表中删除它们)。