¿Cómo puedo rechazar todos los cambios en un Linq al DataContext de SQL?

Question

En el DataContext de Linq to SQL, puedo llamar a SubmitChanges() para enviar todos los cambios.

Lo que quiero es de alguna manera rechazar todos los cambios en el contexto de datos y deshacer todos los cambios (preferiblemente sin ir a la base de datos).

¿Esto es posible?

Answer 1

En .NET 3.0 utilice el db.GetChangeSet().Updates.Clear() para actualizar, db.GetChangeSet().Inserts.Clear() para el nuevo o db.GetChangeSet().Deletes.Clear() para los elementos eliminados.

En .net 3.5 y superior, el resultado de GetChangeSet() ahora es de solo lectura, inserte la colección en for o foreach y actualice cada tabla ChangeSet como también escribió macías en su comentario.

Answer 2

¿Por qué no descartar el contexto de datos y simplemente reemplazarlo con una nueva instancia?

Answer 3

El refresco funcionará; sin embargo, debe proporcionar las entidades que desea restablecer.

Por ejemplo

dataContext.Refresh(RefreshMode.OverwriteCurrentValues, someObject); 

Answer 4

Como dijo Haacked, tan sólo reduce el contexto de datos.

Probablemente no deba mantener el contexto de datos activo durante mucho tiempo. Están diseñados para ser utilizados de forma transaccional (es decir, un contexto de datos por unidad de trabajo atómica). Si mantiene un contexto de datos activo durante mucho tiempo, corre un mayor riesgo de generar una excepción de concurrencia al actualizar una entidad obsoleta.

Answer 5

Puede usar GetOriginalEntityState (..) para obtener los valores originales de los objetos, p. Clientes que usan los viejos valores almacenados en caché.

También puede repetir los cambios, p. actualiza y actualiza solo los objetos específicos y no las tablas completas porque la penalización de rendimiento será alta.

foreach (Customer c in MyDBContext.GetChangeSet().Updates) 
     { 
      MyDBContext.Refresh(System.Data.Linq.RefreshMode.OverwriteCurrentValues, c); 
     } 

esto revertirá los cambios utilizando datos persistentes en la base de datos.

Otra solución es volcar el contexto de datos que utiliza, utilizando Dispose().

En cualquier caso, es una buena práctica anular los métodos Insertar y Eliminar en la colección de p. Ej. Clientes que usa y agrega, p. una llamada InsertOnSubmit(). Esto resolverá su problema con inserciones y eliminaciones pendientes.

Answer 6

Llamar a Clear() en la colección Actualizaciones, Eliminaciones e Inserciones no funciona.

GetOriginalEntityState() puede ser útil, pero solo proporciona los ID para las relaciones de claves foráneas, no las entidades reales, por lo que le quedará un objeto separado.

He aquí un artículo que explica cómo descartar los cambios desde el contexto de datos: http://graemehill.ca/discard-changes-in-linq-to-sql-datacontext

EDIT: Llamar a Refresh) deshará actualizaciones (pero no eliminaciones y las inserciones.

Answer 7

Excelente redacción en here, pero aquí hay una copia y pegar del código utilizado.

Public Sub DiscardInsertsAndDeletes(ByVal data As DataContext) 
    ' Get the changes 
    Dim changes = data.GetChangeSet() 

    ' Delete the insertions 
    For Each insertion In changes.Inserts 
     data.GetTable(insertion.GetType).DeleteOnSubmit(insertion) 
    Next 

    ' Insert the deletions 
    For Each deletion In changes.Deletes 
     data.GetTable(deletion.GetType).InsertOnSubmit(deletion) 
    Next 
End Sub 

Public Sub DiscardUpdates(ByVal data As DataContext) 
    ' Get the changes 
    Dim changes = data.GetChangeSet() 

    ' Refresh the tables with updates 
    Dim updatedTables As New List(Of ITable) 
    For Each update In changes.Updates 
     Dim tbl = data.GetTable(update.GetType) 
     ' Make sure not to refresh the same table twice 
     If updatedTables.Contains(tbl) Then 
      Continue For 
     Else 
      updatedTables.Add(tbl) 
      data.Refresh(RefreshMode.OverwriteCurrentValues, tbl) 
     End If 
    Next 
End Sub 

Answer 8

public static class DataContextExtensions 
{ 
    /// <summary> 
    ///  Discard all pending changes of current DataContext. 
    ///  All un-submitted changes, including insert/delete/modify will lost. 
    /// </summary> 
    /// <param name="context"></param> 
    public static void DiscardPendingChanges(this DataContext context) 
    { 
     context.RefreshPendingChanges(RefreshMode.OverwriteCurrentValues); 
     ChangeSet changeSet = context.GetChangeSet(); 
     if (changeSet != null) 
     { 
      //Undo inserts 
      foreach (object objToInsert in changeSet.Inserts) 
      { 
       context.GetTable(objToInsert.GetType()).DeleteOnSubmit(objToInsert); 
      } 
      //Undo deletes 
      foreach (object objToDelete in changeSet.Deletes) 
      { 
       context.GetTable(objToDelete.GetType()).InsertOnSubmit(objToDelete); 
      } 
     } 
    } 

    /// <summary> 
    ///  Refreshes all pending Delete/Update entity objects of current DataContext according to the specified mode. 
    ///  Nothing will do on Pending Insert entity objects. 
    /// </summary> 
    /// <param name="context"></param> 
    /// <param name="refreshMode">A value that specifies how optimistic concurrency conflicts are handled.</param> 
    public static void RefreshPendingChanges(this DataContext context, RefreshMode refreshMode) 
    { 
     ChangeSet changeSet = context.GetChangeSet(); 
     if (changeSet != null) 
     { 
      context.Refresh(refreshMode, changeSet.Deletes); 
      context.Refresh(refreshMode, changeSet.Updates); 
     } 
    } 
} 

Consulte Linq to SQL - Discard Pending Changes

Answer 9

Mi solicitud es el estilo de Outlook con un icono para seleccionar una forma activa (ListBox). Antes de permitir que el usuario cambie su contexto, debe aceptar cambios o descartarlos.

var changes = db.GetChangeSet(); 
if ((changes.Updates.Count > 0) || (changes.Inserts.Count > 0) || (changes.Deletes.Count > 0)) 
{ 
    if (MessageBox.Show("Would you like to save changes?", "Save Changes", MessageBoxButton.YesNo) == MessageBoxResult.Yes) 
    { 
     db.SubmitChanges(); 
    } else 
    { 
     //Rollback Changes 
     foreach (object objToInsert in changes.Inserts) 
     { 
      db.GetTable(objToInsert.GetType()).DeleteOnSubmit(objToInsert); 
     } 
     foreach (object objToDelete in changes.Deletes) 
     { 
      db.GetTable(objToDelete.GetType()).InsertOnSubmit(objToDelete); 
     } 
     foreach (object objToUpdate in changes.Updates) 
     { 
      db.Refresh(RefreshMode.OverwriteCurrentValues, objToUpdate); 
     } 
     CurrentForm.SetObject(null); //Application Code to Clear active form 
     RefreshList(); //Application Code to Refresh active list 
    } 
} 

Answer 10

Así es como lo hice. Acabo de seguir el ejemplo de Teddy anterior y lo simplifiqué. Tengo una pregunta, ¿por qué molestarse con la actualización de los DELETES?

public static bool UndoPendingChanges(this NtsSuiteDataContext dbContext) 
    { 
    if (dbContext.ChangesPending()) 
    { 
     ChangeSet dbChangeSet = dbContext.GetChangeSet(); 

     dbContext.Refresh(RefreshMode.OverwriteCurrentValues, dbChangeSet.Deletes); 
     dbContext.Refresh(RefreshMode.OverwriteCurrentValues, dbChangeSet.Updates); 

     //Undo Inserts 
     foreach (object objToInsert in dbChangeSet.Inserts) 
     { 
      dbContext.GetTable(objToInsert.GetType()).DeleteOnSubmit(objToInsert); 
     } 

     //Undo deletes 
     foreach (object objToDelete in dbChangeSet.Deletes) 
     { 
      dbContext.GetTable(objToDelete.GetType()).InsertOnSubmit(objToDelete); 
     } 
    } 

    return true; 
    }