TransactionScope en .NET

Qu’est-ce que c’est ?

TransactionScope est une classe du namespace System.Transactions qui permet de définir un bloc de code transactionnel de manière déclarative. Toutes les opérations effectuées à l’intérieur du bloc (requêtes SQL, appels à plusieurs bases de données, etc.) sont soit toutes validées (commit), soit toutes annulées (rollback) en cas d’erreur.

C’est l’approche recommandée quand on veut garantir la cohérence des données sans gérer manuellement les objets SqlTransaction de chaque connexion.

Fonctionnement de base

using (var scope = new TransactionScope())
{
    using (var connection = new SqlConnection(connectionString))
    {
        connection.Open();
        // Exécution de requêtes SQL...
    }

    // Éventuellement une deuxième connexion, une autre base, etc.

    scope.Complete(); // Valide la transaction
}

Points clés

• Si scope.Complete() n’est pas appelé avant la fin du using, la transaction est automatiquement annulée (rollback).
• TransactionScope s’appuie sur le gestionnaire de transactions ambiant (Transaction.Current). Toute ressource compatible (ADO.NET, Entity Framework, MSMQ…) qui s’exécute dans ce contexte rejoint automatiquement la transaction en cours, sans code supplémentaire.
• Si plusieurs connexions à des bases différentes sont ouvertes dans le même scope, .NET peut escalader automatiquement vers une transaction distribuée gérée par le DTC (Distributed Transaction Coordinator).

Les options de configuration

var options = new TransactionOptions
{
    IsolationLevel = IsolationLevel.ReadCommitted,
    Timeout = TimeSpan.FromSeconds(30)
};

using (var scope = new TransactionScope(TransactionScopeOption.Required, options))
{
    // ...
    scope.Complete();
}

TransactionScopeOption

IsolationLevel

Définit le niveau d’isolation vis-à-vis des autres transactions concurrentes.
Le choix impacte directement les performances et les risques de verrous (locks).

Version asynchrone (important !)

Avec async/await, il faut impérativement utiliser le constructeur avec TransactionScopeAsyncFlowOption.Enabled, sinon le contexte transactionnel ne “traverse” pas les changements de thread liés à l’asynchronisme :

using (var scope = new TransactionScope(
    TransactionScopeOption.Required,
    new TransactionOptions { IsolationLevel = IsolationLevel.ReadCommitted },
    TransactionScopeAsyncFlowOption.Enabled))
{
    await connection.OpenAsync();
    // ...
    scope.Complete();
}

⚠️ Oublier ce paramètre est une erreur très fréquente et peut provoquer des TransactionAbortedException ou des comportements incohérents.

Points d’attention

• Durée du scope : plus une transaction reste ouverte longtemps, plus elle bloque de ressources (verrous en base). Il faut garder le bloc le plus court possible.
• Escalade DTC : ouvrir deux connexions distinctes (même vers la même base de données selon les cas) peut déclencher une escalade vers le DTC, plus coûteuse et nécessitant que le service MSDTC soit activé sur le serveur.
• Exceptions : toute exception non interceptée dans le scope empêche l’appel à Complete(), ce qui déclenche un rollback automatique — c’est le comportement souhaité dans la majorité des cas.
• Imbrication : des TransactionScope peuvent être imbriqués ; le comportement dépend de TransactionScopeOption choisi pour le scope enfant.

Exemple complet avec gestion d’erreur

public void TransfererFonds(int compteSourceId, int compteDestId, decimal montant)
{
    using (var scope = new TransactionScope(
        TransactionScopeOption.Required,
        new TransactionOptions { IsolationLevel = IsolationLevel.ReadCommitted },
        TransactionScopeAsyncFlowOption.Enabled))
    {
        using (var connection = new SqlConnection(connectionString))
        {
            connection.Open();

            DebiterCompte(connection, compteSourceId, montant);
            CrediterCompte(connection, compteDestId, montant);
        }

        scope.Complete();
    }
    // Si une exception survient avant Complete(), tout est annulé automatiquement.
}

En résumé