ITransaction Interface

Définition

public interface ITransaction : IDisposable

type ITransaction = interface
    interface IDisposable

Public Interface ITransaction
Implements IDisposable

Implémente

IDisposable

Remarques

Une transaction doit présenter les propriétés ACID suivantes. Consultez https://technet.microsoft.com/en-us/library/ms190612).

• Atomicité : une transaction doit être une unité de travail atomique; soit toutes ses modifications de données sont effectuées, soit aucune d’entre elles n’est effectuée.
• Cohérence : une fois terminée, une transaction doit laisser toutes les données dans un état cohérent. Toutes les structures de données internes doivent être correctes à la fin de la transaction.
• Isolation : les modifications apportées par des transactions simultanées doivent être isolées des modifications apportées par toutes les autres transactions simultanées. Le niveau d’isolation utilisé pour une opération dans un ITransaction est déterminé par l’exécution IReliableState de l’opération.
• Durabilité : une fois la transaction terminée, ses effets sont en permanence en place dans le système. Les modifications sont conservées même en cas de défaillance du système.

Tout instance membre de ce type n’est pas garanti pour être thread-safe. Cela fait des transactions l’unité de concurrence : les utilisateurs peuvent avoir plusieurs transactions en cours à un moment donné, mais pour une transaction donnée, chaque API doit être appelée une à la fois. Toutes les IReliableCollection{T} API qui acceptent une transaction et retournent une tâche doivent être attendues une par une.

Voici un exemple d’utilisation correcte.

while (true)
{
    cancellationToken.ThrowIfCancellationRequested();

    try
    {
        using (var tx = this.StateManager.CreateTransaction())
        {
            await concurrentQueue.EnqueueAsync(tx, 12L, cancellationToken);
            await tx.CommitAsync();

            return;
        }
    }
    catch (TransactionFaultedException e)
    {
        // This indicates that the transaction was internally faulted by the system. One possible cause for this is that the transaction was long running
        // and blocked a checkpoint. Increasing the "ReliableStateManagerReplicatorSettings.CheckpointThresholdInMB" will help reduce the chances of running into this exception
        Console.WriteLine("Transaction was internally faulted, retrying the transaction: " + e);
    }
    catch (FabricNotPrimaryException e)
    {
        // Gracefully exit RunAsync as the new primary should have RunAsync invoked on it and continue work.
        // If instead enqueue was being executed as part of a client request, the client would be signaled to re-resolve.
        Console.WriteLine("Replica is not primary, exiting RunAsync: " + e);
        return;
    }
    catch (FabricNotReadableException e)
    {
        // Retry until the queue is readable or a different exception is thrown.
        Console.WriteLine("Queue is not readable, retrying the transaction: " + e);
    }
    catch (FabricObjectClosedException e)
    {
        // Gracefully exit RunAsync as this is happening due to replica close.
        // If instead enqueue was being executed as part of a client request, the client would be signaled to re-resolve.
        Console.WriteLine("Replica is closing, exiting RunAsync: " + e);
        return;
    }
    catch (TimeoutException e)
    {
        Console.WriteLine("Encountered TimeoutException during EnqueueAsync, retrying the transaction: " + e);
    }

    // Delay and retry.
    await Task.Delay(TimeSpan.FromMilliseconds(100), cancellationToken);
}

Voici un exemple d’utilisation incorrecte qui a un comportement non défini.

using (var txn = this.StateManager.CreateTransaction())
{
    List<Task> taskList = new List<Task>();
    taskList.Add(concurrentQueue.DequeueAsync(txn, cancellationToken));
    taskList.Add(concurrentQueue.DequeueAsync(txn, cancellationToken));

    await Task.WhenAll(taskList);
    await txn.CommitAsync();
}

Propriétés

Méthodes

S’applique à