TransactionScope.Complete Método

Definición

Indica que finalizan correctamente todas las operaciones dentro del ámbito.

public void Complete ();

Excepciones

Se ha llamado ya una vez a este método.

Ejemplos

En el ejemplo siguiente se muestra cómo usar la TransactionScope clase para definir un bloque de código para participar en una transacción.

// This function takes arguments for 2 connection strings and commands to create a transaction 
// involving two SQL Servers. It returns a value > 0 if the transaction is committed, 0 if the 
// transaction is rolled back. To test this code, you can connect to two different databases 
// on the same server by altering the connection string, or to another 3rd party RDBMS by 
// altering the code in the connection2 code block.
static public int CreateTransactionScope(
    string connectString1, string connectString2,
    string commandText1, string commandText2)
{
    // Initialize the return value to zero and create a StringWriter to display results.
    int returnValue = 0;
    System.IO.StringWriter writer = new System.IO.StringWriter();

    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);
    }

    // Display messages.
    Console.WriteLine(writer.ToString());

    return returnValue;
}

Comentarios

Cuando esté satisfecho de que todas las operaciones dentro del ámbito se completan correctamente, debe llamar a este método solo una vez para informar al administrador de transacciones de que el estado de todos los recursos es coherente y se puede confirmar la transacción. Es muy recomendable colocar la llamada como la última instrucción del using bloque.

Para obtener más información sobre cómo se usa este método, vea el tema Implementación de una transacción implícita mediante ámbito de transacción .

Si no se llama a este método, se anula la transacción, porque el administrador de transacciones lo interpreta como un error del sistema o las excepciones producidas dentro del ámbito de la transacción. Sin embargo, también debe tener en cuenta que llamar a este método no garantiza una confirmación de la transacción. Es solo una manera de informar al administrador de transacciones de su estado. Después de llamar a este método, ya no puede acceder a la transacción ambiente a través de la Current propiedad y, al intentar hacerlo, se produce una excepción.

El trabajo real de confirmación entre el administrador de recursos se produce en la End Using instrucción si el TransactionScope objeto creó la transacción. Si no ha creado la transacción, se produce la confirmación cada vez que el propietario del objeto Commit llama al método CommittableTransaction. En ese momento, el Administrador de transacciones llama a los administradores de recursos e informa a ellos de confirmación o reversión, en función de si se llamó a este método en el TransactionScope objeto .

Se aplica a

Producto Versiones
.NET Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 2.0, 2.1

Consulte también