试图理解为什么在这种情况下会发生 EF Core InvalidOperationException

Question

I'm learning EF Core and I've hit an issue I can't quite understand why it happens:

Right now I have a view PAYMENTSView with a datagrid bound to a List<PAYMETHOD> ACTIVEPAYMETHODs property located on PAYMENTSViewModel .

When I instantiate a new PAYMENTSView I also set a SALE CURRENT_SALE property on its viewmodel. The user then selects a PAYMETHOD , SelectedPayMethod . Then it instantiates a new PAYMENT with PAYMENT.PAYMETHOD = SelectedPayMethod , and adds this new PAYMENT to CURRENT_SALE.PAYMENTs .

Then it calls context.Update(CURRENT_SALE) and context.SaveChanges() ;

I've seen, at least here in SO, people saying that I shouldn't instantiate one DbContext for each access to the database (in this case one when filling PAYMENTSView and one when calling Update and SaveChanges ), while others say I should stick to one context during the whole transaction (ie one new DbContext for each new SALE ). Right now, I'm using multiple DbContext, so I should have any conflicts.

Now, to the issue: I can successfully instantiate one SALE , fill it, update and save it, alright. But when I try calling Update on another SALE that uses the same PAYMETHOD , I get this error:

The instance of entity type 'PAYMETHOD' cannot be tracked because another instance of this type with the same key is already being tracked.

Now, I understand this happens because PAYMETHOD is already being tracked due to being used by the first SALE . I can bypass this issue by, rather than setting PAYMENT.PAYMETHOD setting PAYMENT.PAYMETHOD_ID . But I still want to understand why this happens. Since I've already called Update and SaveChanges , as well as instantiating new instances of both SALE and PAYMENT , shouldn't it be a different instance of PAYMETHOD , and hence, should have different tracking?

My relevant models are as follows:

public class SALE
{
    public int ID {get;set;}
    public string PROPERTY1 {get;set;}
    public DateTime PROPERTY2 {get;set;}
    public List<PAYMENT> PAYMENTs {get;set;}
}

public class PAYMENT
{
    public int ID {get;set;}
    public string PROPERTY3 {get;set;}
    public int PROPERTY4 {get;set;}
    #region FK
    public SALE SALE_PAYMENT {get;set;}
    public int SALE_PAYMENT_ID {get;set;}
    public PAYMETHOD PAYMETHOD_PAYMENT {get;set;}
    public int PAYMETHOD_PAYMENT_ID {get;set;}
    #endregion
}

public PAYMETHOD
{
    public int ID {get;set}
    public string PROPERTY5 {get;set}
    public bool PROPERTY6 {get;set;}
    public List<PAYMENT> PAYMENTs {get;set;}
} 

Further information to reproduce it:

    ...
    <DataGrid IsTabStop="False" Grid.RowSpan="6" Grid.Column="0" BorderThickness="2" Margin="10" AutoGenerateColumns="False" ItemsSource="{Binding ACTIVEPAYMETHODs}" IsReadOnly="True"/>
    ...
    <TextBox Text="{Binding PAYMETHODCODE,StringFormat=C2, UpdateSourceTrigger=PropertyChanged}" KeyDown="txb_KeyDown"/>
    ...

public partial class PAYMENTSView : Window
{
    private void txb_ValorPagto_KeyDown(object sender, KeyEventArgs e)
    {
        if (e.Key == Key.Enter)
            ((FECHAMENTOCUPOMViewModel)DataContext).ProcessPaymentMethod() == true    
    }
}

public class FECHAMENTOCUPOMViewModel
{
    public SALE CURRENT_SALE {get;set;}
    internal PAYMETHOD SelectedPayMethod {get;set;}
    public int PAYMETHODCODE
    {
        set
        {
            SelectedPayMethod = ACTIVEPAYMETHODs.Select(x=>x).Where(x=>x.ID == value).FirstOrDefault();
        }
    }
    
    public PAYMENTSViewModel
    {
        ACTIVEPAYMETHODs = new List<PAYMETHOD>(_context
                    .PAYMETHODs
                    .Select(x => x)
                    .Where(x =>
                        x.STATUS == Status.Active)
                    .ToArray()
                    );
    }
    public void ProcessaMetodoAtual()
    {
        PAYMENT payment = new PAYMENT();
        payment.PAYMETHOD_PAYMENT = SelectedPayMethod;
        CURRENT_SALE.PAYMENTs.Add(payment);
        SelectedPayMethod = null;
        SaveToDatabase();
    }
    
    public void SaveToDatabase()
    {
        DbContext _context = new DbContextFactory().CreateDbContext();
        _context.Update(CURRENT_SALE);
        try
        {
        _context.SaveChanges();
        }
        catch (Exception ex)
        {
        
        }
    }
}

EDIT: Here's the actual relevant code if anyone wants to give it a look (after @ArwynFr changes): https://github.com/AKANexus/EFCoreQuestion/tree/master/AmbiStore

EDIT2: I forgot a very important piece of information: CURRENT_SALE is a new entity that hasn't been saved to the database yet.

Answer 1

Why it happens

Since I've already called Update and SaveChanges, as well as instantiating new instances of both SALE and PAYMENT, shouldn't it be a different instance of PAYMETHOD, and hence, should have different tracking?

It is a different instance of PAYMETHOD .

You have two entity instances, let's call them PAYMETHOD__1 and PAYMETHOD__2 . Each instance is tracked by a different context, let's call them context__1 and context__2 . However, the entities refer to the same database row, which means PAYMETHOD__1.Id == PAYMETHOD__2.Id .

This is a problem, because context__1 is able to alter the entry in the database without context__2 knowing. In that situation, context__2 will consider PAYMETHOD__2 to be clean, although the entity state is actually outdated and does not reflect changes made by context__1 in the database. This can easily lead your application to alter your data in an inconsistent state.

A DbContext acts as an in-memory collection of entities, and it will keep track of changes you do on the entities in order to persist these changes to the database whenever you call SaveChanges() . You should always use a single instance of the context to handle, as long as you are operating in a coherent business transaction context. EF core detects you are doing something wrong with your contexts and throws an exception, rather than letting your application breaking your database.

What you are doing wrong and how to fix it

The first thing to note is that your code does a lot of mixing between models and viewmodels, and does not follow the principles of MVVM. The most notably wrong thing you are doing is setting the current sale to your viewmodel from the view, and the having your viewmodel instantiate a new DbContext.

If your application is already manipulating entities, especially a SALE object when the FECHAMENTOCUPOMViewModel is instanciated, then you already have a DbContext and that context instance has to be provided to the viewmodel so it can manipulate entities in a coherent context. You also either need to provide the SALE object, or it's Id. Since you set CURRENT_SALE , you already have the sale object so let's implement that:

public class FECHAMENTOCUPOMViewModel
{
    private readonly DbContext context;
    private readonly SALE model;

    public FECHAMENTOCUPOMViewModel(DbContext context, SALE model)
    {
        this.context = context ?? throw new ArgumentNullException(nameof(context));
        this.model = model ?? throw new ArgumentNullException(nameof(model));
    }
}

Now we need to obtain the list of pay methods the user will choose among. Ideally, you should rather encapsulate your PAYMETHOD objects (models) into a PayMethodViewModel.

public class FECHAMENTOCUPOMViewModel
{
    public IEnumerable<PAYMETHOD> ACTIVEPAYMETHODs => context.PAYMETHODs
        .Where(method => method.STATUS == Status.Active)
        .ToArray();
}

Then let's handle the pay method selection by the user. Once again, this should rather be a viewmodel than an entity.

public class FECHAMENTOCUPOMViewModel
{
    private PAYMETHOD selectedPayMethod;
    public int PAYMETHODCODE
    {
        set
        {
            selectedPayMethod = ACTIVEPAYMETHODs
                .FirstOrDefault(method => method.Id == value);
        }
    }
}

Finally, lets add the payment:

public class FECHAMENTOCUPOMViewModel
{
    public void ProcessaMetodoAtual()
    {
        PAYMENT payment = context.PAYMENTs.Add(new PAYMENT()
        {
            PAYMETHOD_PAYMENT = selectedPayMethod,
            SALE_PAYMENT = model // create the payment -> sale relationship
        }) as PAYMENT;
        model.PAYMENTs.Add(payment); // do not forget to add the inverse relationship
        context.SaveChanges(); // executes INSERT statement
    }
}