ITransaction Schnittstelle

Referenz

Definition

Namespace:: Microsoft.ServiceFabric.Data

Assembly:: Microsoft.ServiceFabric.Data.Interfaces.dll

Paket:: Microsoft.ServiceFabric.Data.Interfaces v6.1.1583

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Eine Sequenz von Vorgängen, die als einzelne logische Arbeitseinheit ausgeführt werden.

public interface ITransaction : IDisposable

type ITransaction = interface
    interface IDisposable

Public Interface ITransaction
Implements IDisposable

Implementiert: IDisposable

Hinweise

Eine Transaktion muss die folgenden ACID-Eigenschaften aufweisen. (Siehe https://technet.microsoft.com/en-us/library/ms190612).)

Atomarität: Eine Transaktion muss eine atomare Arbeitseinheit sein; entweder werden alle Datenänderungen ausgeführt, oder keine davon wird ausgeführt.
Konsistenz: Nach Abschluss muss eine Transaktion alle Daten in einem konsistenten Zustand belassen. Alle internen Datenstrukturen müssen am Ende der Transaktion korrekt sein.
Isolation: Änderungen, die von gleichzeitigen Transaktionen vorgenommen werden, müssen von den Änderungen isoliert werden, die von anderen gleichzeitigen Transaktionen vorgenommen werden. Die isolationsstufe, die für einen Vorgang innerhalb eines verwendet wird, ITransaction wird durch die -Funktion bestimmt, die IReliableState den Vorgang ausführt.
Dauerhaftigkeit: Nachdem eine Transaktion abgeschlossen wurde, sind ihre Auswirkungen dauerhaft im System vorhanden. Die Änderungen bleiben auch bei einem Systemfehler persistent.

Alle instance Member dieses Typs sind nicht garantiert threadsicher. Dadurch werden Transaktionen zur Einheit der Parallelität: Benutzer können zu einem bestimmten Zeitpunkt mehrere Transaktionen ausführen, aber für eine bestimmte Transaktion muss jede API einzeln aufgerufen werden. Alle IReliableCollection{T} APIs, die eine Transaktion akzeptieren und einen Task zurückgeben, müssen einzeln erwartet werden.

Im Folgenden finden Sie ein Beispiel für eine korrekte Verwendung.


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

Im Folgenden finden Sie ein Beispiel für eine falsche Verwendung mit undefiniertem Verhalten.

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

Eigenschaften

CommitSequenceNumber	Sequenznummer für den Commitvorgang.
TransactionId	Ruft einen Wert ab, der die Transaktion identifiziert.

Methoden

Abort()	Abbrechen (Rollback) der Transaktion.
CommitAsync()	Führen Sie einen Commit für die Transaktion aus.
GetVisibilitySequenceNumberAsync()	Ruft die Sichtbarkeitssequenznummer ab.

Gilt für:

Freigeben über