Question

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

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

我使用抽象的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

我意识到这已经过时了，但我刚刚发现了GraphDiff，希望能帮助其他人看。

这是你使用GraphDiff的方式：

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

这表示更新Order对象，并且Order拥有PaymentMethods（意味着它实际上可以删除这些实体），并且与Products实体相关联（意味着它将从引用表中删除它们）。

Answer 2

您可以在界面中公开基础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;
    }
}

在抽象DBContext时如何使用GraphDiff？

2 个答案: