Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

TransactionScope classe

 

Date de publication : novembre 2016

Rend un bloc de code transactionnel. Cette classe ne peut pas être héritée.

Espace de noms:   System.Transactions
Assembly:  System.Transactions (dans System.Transactions.dll)

System.Object
  System.Transactions.TransactionScope

public sealed class TransactionScope : IDisposable

NomDescription
System_CAPS_pubmethodTransactionScope()

Initialise une nouvelle instance de la classe TransactionScope.

System_CAPS_pubmethodTransactionScope(Transaction)

Initialise une nouvelle instance de la TransactionScope classe et définit la transaction spécifiée comme une transaction ambiante, afin que le travail transactionnel fait à l’intérieur de la portée utilise cette transaction.

System_CAPS_pubmethodTransactionScope(Transaction, TimeSpan)

Initialise une nouvelle instance de la TransactionScope classe avec la valeur de délai d’attente spécifié et définit la transaction spécifiée comme une transaction ambiante, afin que le travail transactionnel fait à l’intérieur de la portée utilise cette transaction.

System_CAPS_pubmethodTransactionScope(Transaction, TimeSpan, EnterpriseServicesInteropOption)

Initialise une nouvelle instance de la TransactionScope classe avec la valeur de délai d’attente spécifié et critères d’interopérabilité COM + et définit la transaction spécifiée comme une transaction ambiante, afin que le travail transactionnel fait à l’intérieur de la portée utilise cette transaction.

System_CAPS_pubmethodTransactionScope(Transaction, TimeSpan, TransactionScopeAsyncFlowOption)

[Pris en charge dans le .NET Framework 4.5.1 et versions ultérieures]

Initialise une nouvelle instance de la TransactionScope classe avec la valeur de délai d’attente spécifié et définit la transaction spécifiée comme une transaction ambiante, afin que le travail transactionnel fait à l’intérieur de la portée utilise cette transaction.

System_CAPS_pubmethodTransactionScope(Transaction, TransactionScopeAsyncFlowOption)

[Pris en charge dans le .NET Framework 4.5.1 et versions ultérieures]

Initialise une nouvelle instance de la TransactionScope classe et définit la transaction spécifiée comme une transaction ambiante, afin que le travail transactionnel fait à l’intérieur de la portée utilise cette transaction.

System_CAPS_pubmethodTransactionScope(TransactionScopeAsyncFlowOption)

[Pris en charge dans le .NET Framework 4.5.1 et versions ultérieures]

Initialise une nouvelle instance de la TransactionScope classe avec l’option de flux asynchrone spécifiée.

System_CAPS_pubmethodTransactionScope(TransactionScopeOption)

Initialise une nouvelle instance de la TransactionScope classe avec les critères spécifiés.

System_CAPS_pubmethodTransactionScope(TransactionScopeOption, TimeSpan)

Initialise une nouvelle instance de la TransactionScope classe avec les critères et la valeur de délai d’attente spécifié.

System_CAPS_pubmethodTransactionScope(TransactionScopeOption, TimeSpan, TransactionScopeAsyncFlowOption)

[Pris en charge dans le .NET Framework 4.5.1 et versions ultérieures]

Initialise une nouvelle instance de la TransactionScope classe avec la valeur de délai d’attente spécifié, configuration requise et option de flux asynchrone.

System_CAPS_pubmethodTransactionScope(TransactionScopeOption, TransactionOptions)

Initialise une nouvelle instance de la TransactionScope classe avec les critères spécifiés.

System_CAPS_pubmethodTransactionScope(TransactionScopeOption, TransactionOptions, EnterpriseServicesInteropOption)

Initialise une nouvelle instance de la TransactionScope classe avec l’étendue spécifiée et spécifications d’interopérabilité COM + et les options de transaction.

System_CAPS_pubmethodTransactionScope(TransactionScopeOption, TransactionOptions, TransactionScopeAsyncFlowOption)

[Pris en charge dans le .NET Framework 4.5.1 et versions ultérieures]

Initialise une nouvelle instance de la TransactionScope classe avec les critères spécifiés et l’option de flux asynchrone.

System_CAPS_pubmethodTransactionScope(TransactionScopeOption, TransactionScopeAsyncFlowOption)

[Pris en charge dans le .NET Framework 4.5.1 et versions ultérieures]

Initialise une nouvelle instance de la TransactionScope classe avec les critères spécifiés et l’option de flux asynchrone.

NomDescription
System_CAPS_pubmethodComplete()

Indique que toutes les opérations dans la portée sont terminées avec succès.

System_CAPS_pubmethodDispose()

Met fin à la portée de transaction.

System_CAPS_pubmethodEquals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.(Hérité de Object.)

System_CAPS_pubmethodGetHashCode()

Fait office de fonction de hachage par défaut.(Hérité de Object.)

System_CAPS_pubmethodGetType()

Obtient le Type de l'instance actuelle.(Hérité de Object.)

System_CAPS_pubmethodToString()

Retourne une chaîne qui représente l'objet actuel.(Hérité de Object.)

Le System.Transactions l’infrastructure fournit à la fois un modèle de programmation explicit basé sur la Transaction classe, ainsi que pour un modèle de programmation implicite utilisant la TransactionScope (classe), dans lequel les transactions sont gérées automatiquement par l’infrastructure.

System_CAPS_importantImportant

Il est recommandé de créer des transactions implicites à l’aide de la TransactionScope classe, afin que le contexte de transaction ambiante est géré automatiquement pour vous. Vous devez également utiliser le TransactionScope et DependentTransaction classe pour les applications qui requièrent l’utilisation de la même transaction pour plusieurs appels de fonction ou plusieurs appels de thread. Pour plus d’informations sur ce modèle, consultez la Implementing An Implicit Transaction Using Transaction Scope rubrique. Pour plus d’informations sur l’écriture d’une application transactionnelle, consultez Writing A Transactional Application.

Lors de l’instanciation d’un TransactionScope par la new instruction, le Gestionnaire de transactions détermine à quelle transaction participer. Une fois déterminée, la portée participe toujours à cette transaction. Cette décision est basée sur deux facteurs : la présence d'une transaction ambiante et la valeur du paramètre TransactionScopeOption dans le constructeur. La transaction ambiante est la transaction dans que votre code s’exécute. Vous pouvez obtenir une référence à la transaction ambiante en appelant la propriété Current statique de la classe Transaction. Pour plus d’informations sur l’utilisation de ce paramètre, consultez la section « Gestion du flux de Transaction » de la Implementing An Implicit Transaction Using Transaction Scope rubrique.

Si aucune exception ne se produit dans la portée de transaction (c'est-à-dire entre l’initialisation de la TransactionScope objet et l’appel de son Dispose (méthode)), la transaction dans laquelle la portée participe est autorisée à continuer. Si une exception se produit dans la portée de transaction, la transaction à laquelle il participe est restaurée.

Lorsque votre application termine tout le travail qu’elle souhaite exécuter dans une transaction, vous devez appeler la Complete méthode une fois seulement pour informer ce gestionnaire de transactions qu’il est acceptable de valider la transaction. Ne pas appeler cette méthode, la transaction est abandonnée.

Un appel à la Dispose méthode marque la fin de la portée de transaction. Il est possible que les exceptions qui se produisent après l'appel à cette méthode n'affectent pas la transaction.

Si vous modifiez la valeur de Current à l’intérieur d’une étendue, une exception est levée lorsque Dispose est appelé. Toutefois, à la fin de la portée, la valeur précédente est restaurée. En outre, si vous appelez Dispose sur Current à l’intérieur d’une étendue de transaction qui a créé la transaction, la transaction est abandonnée à la fin de l’étendue.

L’exemple suivant montre comment utiliser la TransactionScope classe pour définir un bloc de code de participer à une transaction.

// 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);
    }
    catch (ApplicationException ex)
    {
        writer.WriteLine("ApplicationException Message: {0}", ex.Message);
    }

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

    return returnValue;
}

.NET Framework
Disponible depuis 2.0

Ce type est thread-safe.

System.Transactions espace de noms
Implementing An Implicit Transaction Using Transaction Scope

Retour au début
Afficher: