ITransaction Interface

Definição

Namespace:

Microsoft.ServiceFabric.Data

Assembly:

Microsoft.ServiceFabric.Data.Interfaces.dll

Pacote:

Microsoft.ServiceFabric.Data.Interfaces v6.1.1583

Uma sequência de operações executadas como uma única unidade lógica de trabalho.

public interface ITransaction : IDisposable

type ITransaction = interface
    interface IDisposable

Public Interface ITransaction
Implements IDisposable

Implementações

IDisposable

Comentários

Uma transação deve exibir as propriedades ACID a seguir. Confira: https://technet.microsoft.com/en-us/library/ms190612)

• Atomicidade – uma transação deve ser uma unidade atômica de trabalho; todas as modificações de dados são executadas ou nenhuma delas é executada.
• Consistência – quando concluída, uma transação deve deixar todos os dados em um estado consistente. Todas as estruturas de dados internos devem estar corretas ao final da transação.
• Isolamento – as modificações feitas por transações simultâneas devem ser isoladas das modificações feitas por quaisquer outras transações simultâneas. O nível de isolamento usado para uma operação em um ITransaction é determinado pela execução IReliableState da operação.
• Durabilidade – depois que uma transação for concluída, seus efeitos estarão permanentemente em vigor no sistema. As modificações persistem até mesmo no caso de uma queda do sistema.

Não há garantia de que qualquer membro de instância desse tipo seja thread-safe. Isso torna as transações a unidade de simultaneidade: os usuários podem ter várias transações em andamento a qualquer momento, mas para uma determinada transação, cada API deve ser chamada uma de cada vez. Todas as IReliableCollection{T} APIs que aceitam uma transação e retornam uma Tarefa devem ser aguardadas uma de cada vez.

Veja a seguir um exemplo de uso correto.

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

Veja a seguir um exemplo de uso incorreto que tem um comportamento indefinido.

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

Propriedades

CommitSequenceNumber	Número de sequência para a operação de confirmação.
TransactionId	Obtém um valor que identifica a transação.

Métodos

Abort()	Anula (reverte) a transação.
CommitAsync()	Confirme a transação.
GetVisibilitySequenceNumberAsync()	Obtém o número de sequência de visibilidade.