ITransaction Interfaz

Definición

Espacio de nombres:

Microsoft.ServiceFabric.Data

Ensamblado:

Microsoft.ServiceFabric.Data.Interfaces.dll

Paquete:

Microsoft.ServiceFabric.Data.Interfaces v6.1.1583

Secuencia de operaciones realizadas como una sola unidad lógica de trabajo.

public interface ITransaction : IDisposable

type ITransaction = interface
    interface IDisposable

Public Interface ITransaction
Implements IDisposable

Implementaciones

IDisposable

Comentarios

Una transacción debe presentar las siguientes propiedades ACID. (vea: https://technet.microsoft.com/en-us/library/ms190612)

• Atomicidad: una transacción debe ser una unidad atómica de trabajo; se realizan todas sus modificaciones de datos o no se realiza ninguna de ellas.
• Coherencia: cuando se completa, una transacción debe dejar todos los datos en un estado coherente. Todas las estructuras de datos internos deben ser correctas al final de la transacción.
• Aislamiento: las modificaciones realizadas por transacciones simultáneas deben aislarse de las modificaciones realizadas por otras transacciones simultáneas. El nivel de aislamiento que se usa para una operación dentro ITransaction de se determina mediante la IReliableState realización de la operación.
• Durabilidad: una vez completada una transacción, sus efectos se colocan permanentemente en el sistema. Las modificaciones persisten aún en el caso de producirse un error del sistema.

No se garantiza que cualquier miembro de instancia de este tipo sea seguro para subprocesos. Esto hace que las transacciones sean la unidad de simultaneidad: los usuarios pueden tener varias transacciones en curso en cualquier momento dado, pero para una transacción determinada, cada API debe llamarse de una en una. Todas las IReliableCollection{T} API que aceptan una transacción y devuelven una tarea deben esperarse de una en una.

A continuación se muestra un ejemplo de un uso correcto.

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

A continuación se muestra un ejemplo de uso incorrecto que tiene un comportamiento 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();
}

Propiedades

CommitSequenceNumber	Número de secuencia de la operación de confirmación.
TransactionId	Obtiene un valor que identifica la transacción.

Métodos

Abort()	Anule (revierte) la transacción.
CommitAsync()	Confirme la transacción.
GetVisibilitySequenceNumberAsync()	Obtiene el número de secuencia de visibilidad.