我需要多久保存一次上下文？

Question

In a repository, I am doing these two consecutive tasks:

// Update vendorOrder
vendorOrder.VendorOrderStatus = VendorOrderStatus.Completed;
vendorOrderRepository.UpdateVendorOrder(vendorOrder);
vendorOrderRepository.Save();
// Update order
order.OrderStatus = OrderStatus.Completed;
orderRepository.UpdateOrder(order);
orderRepository.Save();

Both vendorOrderRepository and orderRepositoryrepositorty have their own Save() method:

public void Save()
{
    context.SaveChanges();
}

• Will calling Save() inside each repository save only changes to the context there, or will it save each and every change made to context in any other repositories up to that point?

• In my example, is it redundant to call Save() twice? Will it work if I just call Save() at the very end?

(I could just try myself and see what works, but I want to have a definite answer based on how MVC works if possible, in case there are exceptions. It's probably basic understanding of MVC, but I skipped that part...)

Edit 1

vendorOrderRepository begins with:

public class VendorOrderRepository : IVendorOrderRepository, IDisposable
{
    private ApplicationDbContext context = new ApplicationDbContext();
    private IOrderRepository orderRepository;
    public VendorOrderRepository(ApplicationDbContext context)
    {
        this.context = context;
        orderRepository = new OrderRepository(context);
    }

orderRepository begins with:

public class OrderRepository : IOrderRepository, IDisposable
{
    private ApplicationDbContext context = new ApplicationDbContext();
    private IVendorOrderRepository vendorOrderRepository;
    public OrderRepository(ApplicationDbContext context)
    {
        this.context = context;
        vendorOrderRepository = new VendorOrderRepository(context);
    }

Answer 1

How often do I need to save the context?

As often as it makes sense to do so. In general, you will want to only call SaveChanges once, unless dealing with large sets in which case it will make sense to use transactions and save in batches.

Will calling Save() inside each repository save only changes to the context there, or will it save each and every change made to context in any other repositories up to that point?

"the context there" is kind of vague. Calling SaveChanges will save all changes made inside of the context. So, if both vendorOrderRepository and orderRepository share the same context, then calling it once will save every change made.

In my example, is it redundant to call Save() twice? Will it work if I just call Save() at the very end?

If they use the same context, then yes. If different, then it is not redundant.

---

In a broader sense, the way that SaveChanges works is that it will save the entities stored in the change tracker (See ChangeTracker Class ^MDN for expanded details). The change tracker (accessible through context.ChangeTracker ), among other things, holds a set of entities that it tracks. These will be the entities which are updated during SaveChanges, and technically these entities are referred to as being "attached".

You can see the list of entities attached by type by iterating context.ChangeTracker.Entries<T>() where T is your type.

Answer 2

It depends on what kind of design pattern are you using. If you are using Repository Pattern, the context is shared across all the repositories, and the same context tracks changes in all the entities. So it is OK if you call Save() 0r context.SaveChanges() once.