entity-framework - transaction - transacciones entity framework 6

¿Cómo utilizar las transacciones con el Entity Framework?

Question

Cuando tienes un código como este:

Something something = new Something();
BlahEntities b = new BlahEntities()    
b.AddToSomethingSet(something);
b.SaveChanges();

¿Cómo ejecutar esa adición dentro de una transacción?

Answer 1

El ObjectContext tiene una propiedad de conexión que puede utilizar para administrar transacciones.

using (var context = new BlahEntities())
using (var tx = context.BeginTransaction())
{
    // do db stuff here...
    tx.Commit();
}

En el caso de una excepción, la transacción se retrotraerá. Debido a que la llamada a BeginTransaction () requiere una conexión abierta, tiene sentido envolver la llamada a BeginTransaction posiblemente en un método de extensión.

public static DbTransaction BeginTransaction(this ObjectContext context)
{
    if (context.Connection.State != ConnectionState.Open)
    {
        context.Connection.Open();
    }
    return context.Connection.BeginTransaction();
}

Un escenario en el que creo que este enfoque podría ser útil en TransactionScope, es cuando tiene que acceder a dos fuentes de datos y solo necesita control transaccional sobre una de las conexiones. Creo que en ese caso, TransactionScope se promocionará a una transacción distribuida que podría no ser necesaria.

Answer 2

En todas las versiones de Entity Framework, siempre que ejecute SaveChanges () para insertar, actualizar o eliminar en la base de datos, el marco envolverá esa operación en una transacción. Esta transacción dura solo el tiempo suficiente para ejecutar la operación y luego se completa. Cuando ejecuta otra operación de este tipo, se inicia una nueva transacción. Para la versión más nueva de Entity Framework: 6.0 +

Lea más aquí: EntityFramework and Transaction

Answer 3

Puede colocar su código dentro de un ámbito de transacción

using(TransactionScope scope = new TransactionScope())
{
    // Your code
    scope.Complete(); //  To commit.
}

TransactionScope se encuentra en el espacio de nombres System.Transactions que se encuentra en el ensamblaje del mismo nombre (que puede ser necesario agregar manualmente a su proyecto).

Answer 4

Sé que para LINQ to SQL, el contexto de datos creará una transacción para SubmitChanges () si no existe una transacción ambiental existente (TransactionScope es una transacción "ambiental"). No he visto esto documentado para LINQ a Entidades, pero he visto un comportamiento que sugiere que también es cierto para Entity Framework.

Entonces, siempre que use un SubmitChanges () (L2SQL) o SaveChanges () (Linq to Entities) para todos los cambios relacionados, debería estar bien sin usar TransactionScope. Necesitas un TransactionScope cuando

1. Guardando múltiples cambios con múltiples SubmitChanges / SaveChanges para una transacción.
2. Actualización de múltiples fuentes de datos dentro de una transacción (por ejemplo, proveedor de SQL de membresía de Linq y ASP.NET).
3. Llamando a otros métodos que pueden hacer sus propias actualizaciones.

He tenido problemas con TransactionScopes anidados. Se supone que funcionan, y los casos de prueba simples funcionan, pero cuando entro en el código de producción, la transacción "interna" parece ser el mismo objeto que la transacción externa. Los síntomas incluyen errores que son "transacción confirmada, ya no puede usar esta transacción" o "este objeto de transacción ya se ha eliminado". Los errores se producen en la transacción externa después de que la transacción interna haya realizado su trabajo.

Answer 5

using System.Transactions;

using (TransactionScope scope = new TransactionScope())
{
    try
    {
        using(DataContext contextObject = new DataContext(ConnectionString))
        {
            contextObject.Connection.Open();
            // First SaveChange method.
            contextObject.SaveChanges();

            // Second SaveChange method.
            contextObject.SaveChanges();
            //--continue to nth save changes

            // If all execution successful
            scope.Complete();   
       }
    }
    catch(Exception ex)
    {
        // If any exception is caught, roll back the entire transaction and end the scope.
        scope.Dispose();
    }
    finally
    {
        // Close the opened connection
        if (contextObject.Connection.State == ConnectionState.Open)
        {
            contextObject.Connection.Close();
        }
    }
}

Encuentre el enlace a continuación para obtener una explicación detallada https://msdn.microsoft.com/en-us/data/dn456843.aspx