Cómo encontrar el estado de la transacción

Question

Estoy usando 'TransactionScope', y necesito hacer algo de DML dentro del C# Code, que he tenido éxito.

tengo que descubrir que Cuál es el estado de la transacción, que disponga de ella completado con éxito o no?

Porque, en función del estado de la transacción, si la transacción está completa, entonces debo realizar un redireccionamiento a otra página, de lo contrario, si la transacción no se completa con éxito, entonces necesito mostrar el error en la página.

quiero redireccionar después de lo siguiente: -
scope.Complete();
scope.Dispose();

Por favor, ayúdenme en este sentido.

Answer 1

Si visit the MSDN page para TransactionScope, se encontraría este ejemplo bien documentado:

try 
{ 
    // Create the TransactionScope to execute the commands, guaranteeing 
    // that both commands can commit or roll back as a single unit of work. 
    using (TransactionScope scope = new TransactionScope()) 
    { 
     using (SqlConnection connection1 = new SqlConnection(connectString1)) 
     { 
      // Opening the connection automatically enlists it in the 
      // TransactionScope as a lightweight transaction. 
      connection1.Open(); 

      // Create the SqlCommand object and execute the first command. 
      SqlCommand command1 = new SqlCommand(commandText1, connection1); 
      returnValue = command1.ExecuteNonQuery(); 
      writer.WriteLine("Rows to be affected by command1: {0}", returnValue); 

      // If you get here, this means that command1 succeeded. By nesting 
      // the using block for connection2 inside that of connection1, you 
      // conserve server and network resources as connection2 is opened 
      // only when there is a chance that the transaction can commit. 
      using (SqlConnection connection2 = new SqlConnection(connectString2)) 
      { 
       // The transaction is escalated to a full distributed 
       // transaction when connection2 is opened. 
       connection2.Open(); 

       // Execute the second command in the second database. 
       returnValue = 0; 
       SqlCommand command2 = new SqlCommand(commandText2, connection2); 
       returnValue = command2.ExecuteNonQuery(); 
       writer.WriteLine("Rows to be affected by command2: {0}", returnValue); 
      } 
     } 

     // The Complete method commits the transaction. If an exception has been thrown, 
     // Complete is not called and the transaction is rolled back. 
     scope.Complete(); 

    } 

} 
catch (TransactionAbortedException ex) 
{ 
    writer.WriteLine("TransactionAbortedException Message: {0}", ex.Message); 
} 
catch (ApplicationException ex) 
{ 
    writer.WriteLine("ApplicationException Message: {0}", ex.Message); 
} 

El comentario que contenga el mayor valor es la siguiente:

El método completo confirma la transacción. Si se ha lanzado una excepción, no se llama a Complete ni se retrotrae la transacción.

Por lo tanto, si no se producen excepciones, puede continuar. Ponga su redirección después de scope.Complete(). Si se lanza una excepción, la transacción falló y se ha revertido automáticamente. Se podía vuelva a verificar la situación de la operación (como otros han publicado) después de la llamada a Complete() y antes de reorientar, a través de Transaction.Current.TransactionInformation.Status:

if (Transaction.Current.TransactionInformation.Status == TransactionStatus.Committed) 
{ 
    // do redirect 
} 

Answer 2

Uso Transaction.Current.TransactionInformation.Status

Transaction.Current Property

Transaction.TransactionInformation Property

Answer 3

¿Qué tal:

TransactionStatus status = Transaction.Current.TransactionInformation.Status; 

Answer 4

El mejor método que he encontrado para la captura de esta manera más eficiente/correctamente es tan sigue:

Dentro de la declaración que usa transactionscope, y antes de la llamada a scope/Complete().

//Register for the transaction completed event for the current transaction 
Transaction.Current.TransactionCompleted += new TransactionCompletedEventHandler(Current_TransactionCompleted); 

A continuación, crear la función de controlador de eventos de la siguiente manera:

/// <summary> 
/// Handles the TransactionCompleted event of the Current control. 
/// </summary> 
/// <param name="sender">The source of the event.</param> 
/// <param name="e">The <see cref="System.Transactions.TransactionEventArgs"/> instance containing the event data.</param> 
static void Current_TransactionCompleted(object sender, TransactionEventArgs e) 
{ 
    if (e.Transaction.TransactionInformation.Status == TransactionStatus.Committed) 
    { 
     /// Yay it's committed code goes here! 
    } 
} 

Para citar MSDN

"Usted puede inscribirse en este caso en lugar de utilizar un alistamiento volátil para obtener información sobre los resultados de las operaciones.El parámetro pasado al delegado TransactionCompletedEventHandler es una instancia de transacción. A continuación, puede consultar la propiedad TransactionInformation de la instancia específica para obtener una instancia de TransactionInformation, cuya propiedad de estado contiene el estado de una transacción con el valor Comprometido o Cancelado. "