Annulla le modifiche nelle entità del framework di entità

questa potrebbe essere una domanda banale ma: poiché il framework di entità ADO.NET tiene automaticamente traccia delle modifiche (nelle entità generate) e quindi mantiene i valori originali, come posso ripristinare le modifiche apportate agli oggetti entità?

Ho un modulo che consente all'utente di modificare un insieme di entità "Cliente" in una visualizzazione a griglia.

Ora ho due pulsanti "Accetta" e "Ripristina": se si fa clic su "Accetta", chiamo Context.SaveChanges()e gli oggetti modificati vengono riscritti nel database. Se si fa clic su "Ripristina", desidero che tutti gli oggetti ottengano i valori delle proprietà originali. Quale sarebbe il codice per questo?

Grazie

Non vi è alcuna operazione di ripristino o annullamento delle modifiche in EF. Ogni entità ha ObjectStateEntryin ObjectStateManager. La voce di stato contiene i valori originali ed effettivi, quindi puoi utilizzare i valori originali per sovrascrivere i valori correnti, ma devi farlo manualmente per ciascuna entità. Non ripristinerà le modifiche nelle proprietà / relazioni di navigazione.

Il modo comune per "annullare le modifiche" è disporre il contesto e ricaricare le entità. Se vuoi evitare di ricaricare, devi creare cloni di entità e modificare quei cloni nel nuovo contesto dell'oggetto. Se l'utente annulla le modifiche, avrai ancora le entità originali.

Query ChangeTracker di DbContext per elementi sporchi. Imposta lo stato degli elementi eliminati su invariato e gli elementi aggiunti su scollegati. Per gli elementi modificati, utilizzare i valori originali e impostare i valori correnti della voce. Infine imposta lo stato della voce modificata su invariato:

public void RollBack()
{
    var context = DataContextFactory.GetDataContext();
    var changedEntries = context.ChangeTracker.Entries()
        .Where(x => x.State != EntityState.Unchanged).ToList();

    foreach (var entry in changedEntries)
    {
        switch(entry.State)
        {
            case EntityState.Modified:
                entry.CurrentValues.SetValues(entry.OriginalValues);
                entry.State = EntityState.Unchanged;
                break;
            case EntityState.Added:
                entry.State = EntityState.Detached;
                break;
            case EntityState.Deleted:
                entry.State = EntityState.Unchanged;
                break;
        }
    }
 }

dbContext.Entry(entity).Reload();

Accroding a MSDN :

Ricarica l'entità dal database sovrascrivendo eventuali valori di proprietà con valori dal database. L'entità sarà nello stato Non modificato dopo aver chiamato questo metodo.

Si noti che il ripristino tramite la richiesta al database presenta alcuni inconvenienti:

• traffico di rete
• Sovraccarico DB
• l'aumento del tempo di risposta dell'applicazione

Questo ha funzionato per me:

dataContext.customer.Context.Refresh(RefreshMode.StoreWins, item);

Dove si itemtrova l'entità cliente da ripristinare.

Modo semplice senza tenere traccia delle modifiche. Dovrebbe essere più veloce che guardare tutte le entità.

public void Rollback()
{
    dataContext.Dispose();
    dataContext= new MyEntities(yourConnection);
}

// Undo the changes of all entries. 
foreach (DbEntityEntry entry in context.ChangeTracker.Entries()) 
{ 
    switch (entry.State) 
    { 
        // Under the covers, changing the state of an entity from  
        // Modified to Unchanged first sets the values of all  
        // properties to the original values that were read from  
        // the database when it was queried, and then marks the  
        // entity as Unchanged. This will also reject changes to  
        // FK relationships since the original value of the FK  
        // will be restored. 
        case EntityState.Modified: 
            entry.State = EntityState.Unchanged; 
            break; 
        case EntityState.Added: 
            entry.State = EntityState.Detached; 
            break; 
        // If the EntityState is the Deleted, reload the date from the database.   
        case EntityState.Deleted: 
            entry.Reload(); 
            break; 
        default: break; 
    } 
} 

Ha funzionato per me. Tuttavia è necessario ricaricare i dati dal contesto per portare i vecchi dati. Fonte qui

"Questo ha funzionato per me:

dataContext.customer.Context.Refresh(RefreshMode.StoreWins, item);

Dov'è iteml'entità cliente da ripristinare. "

Ho effettuato test con ObjectContext.Refresh in SQL Azure e "RefreshMode.StoreWins" avvia una query sul database per ciascuna entità e causa una perdita di prestazioni. Basato sulla documentazione di Microsoft ():

ClientWins: le modifiche alle proprietà apportate agli oggetti nel contesto dell'oggetto non vengono sostituite con i valori dell'origine dati. Alla successiva chiamata a SaveChanges, queste modifiche vengono inviate all'origine dati.

StoreWins: le modifiche alle proprietà apportate agli oggetti nel contesto dell'oggetto vengono sostituite con i valori dell'origine dati.

ClientWins non è nemmeno una buona ideia, perché sparando .SaveChanges commetterà modifiche "scartate" all'origine dati.

Non so ancora qual è il modo migliore, perché l'eliminazione del contesto e la creazione di uno nuovo è causata da un'eccezione con il messaggio: "Il provider sottostante non è riuscito all'apertura" quando provo a eseguire una query su un nuovo contesto creato.

Saluti,

Henrique Clausing

Per quanto mi riguarda, il metodo migliore per farlo è impostare EntityState.Unchangedsu ogni entità su cui si desidera annullare le modifiche. Ciò garantisce che le modifiche vengano ripristinate su FK e abbia una sintassi un po 'più chiara.

Ho scoperto che funziona bene nel mio contesto:

Context.ObjectStateManager.ChangeObjectState(customer, EntityState.Unchanged);

Questo è un esempio di ciò di cui parla Mrnka. Il metodo seguente sovrascrive i valori correnti di un'entità con i valori originali e non richiama il database. A tale scopo, viene utilizzata la proprietà OriginalValues ​​di DbEntityEntry e la riflessione per impostare i valori in modo generico. (Funziona a partire da EntityFramework 5.0)

/// <summary>
/// Undoes any pending updates 
/// </summary>
public void UndoUpdates( DbContext dbContext )
{
    //Get list of entities that are marked as modified
    List<DbEntityEntry> modifiedEntityList = 
        dbContext.ChangeTracker.Entries().Where(x => x.State == EntityState.Modified).ToList();

    foreach(  DbEntityEntry entity in modifiedEntityList ) 
    {
        DbPropertyValues propertyValues = entity.OriginalValues;
        foreach (String propertyName in propertyValues.PropertyNames)
        {                    
            //Replace current values with original values
            PropertyInfo property = entity.Entity.GetType().GetProperty(propertyName);
            property.SetValue(entity.Entity, propertyValues[propertyName]); 
        }
    }
}

Stiamo usando EF 4, con il contesto dell'oggetto legacy. Nessuna delle soluzioni di cui sopra ha risposto direttamente a questo per me, anche se ha risposto a lungo termine spingendomi nella giusta direzione.

Non possiamo semplicemente eliminare e ricostruire il contesto perché alcuni degli oggetti che abbiamo in giro in memoria (accidenti a quel caricamento pigro !!) sono ancora attaccati al contesto ma hanno figli che devono ancora essere caricati. Per questi casi è necessario riportare tutto ai valori originali senza martellare il database e senza interrompere la connessione esistente.

Di seguito è la nostra soluzione a questo stesso problema:

    public static void UndoAllChanges(OurEntities ctx)
    {
        foreach (ObjectStateEntry entry in
            ctx.ObjectStateManager.GetObjectStateEntries(~EntityState.Detached))
        {
            if (entry.State != EntityState.Unchanged)
            {
                ctx.Refresh(RefreshMode.StoreWins, entry.Entity);
            }
        }
    }

Spero che questo aiuti gli altri.

Alcune buone idee sopra, ho scelto di implementare ICloneable e quindi un semplice metodo di estensione.

Trovato qui: come faccio a clonare un elenco generico in C #?

Da utilizzare come:

ReceiptHandler.ApplyDiscountToAllItemsOnReciept(LocalProductsOnReciept.Clone(), selectedDisc);

In questo modo sono stato in grado di clonare il mio elenco di entità di prodotto, applicare uno sconto a ogni articolo e non devo preoccuparmi di annullare eventuali modifiche sull'entità originale. Non c'è bisogno di parlare con DBContext e chiedere un aggiornamento o lavorare con ChangeTracker. Si potrebbe dire che non sto facendo pieno uso di EF6, ma questa è un'implementazione molto bella e semplice ed evita un colpo di DB. Non posso dire se questo abbia o meno un calo delle prestazioni.