IReliableConcurrentQueue<T>.EnqueueAsync Methode

Definition

Namespace:

Microsoft.ServiceFabric.Data.Collections

Assembly:

Microsoft.ServiceFabric.Data.Interfaces.dll

Paket:

Microsoft.ServiceFabric.Data.Interfaces v6.1.1583

Stellen Sie die Warteschlange eines Werts in die Warteschlange ein.

public System.Threading.Tasks.Task EnqueueAsync (Microsoft.ServiceFabric.Data.ITransaction tx, T value, System.Threading.CancellationToken cancellationToken = default, TimeSpan? timeout = default);

abstract member EnqueueAsync : Microsoft.ServiceFabric.Data.ITransaction * 'T * System.Threading.CancellationToken * Nullable<TimeSpan> -> System.Threading.Tasks.Task

Public Function EnqueueAsync (tx As ITransaction, value As T, Optional cancellationToken As CancellationToken = Nothing, Optional timeout As Nullable(Of TimeSpan) = Nothing) As Task

Parameter

tx

ITransaction

Transaktion, der dieser Vorgang zugeordnet werden soll.

value

T

Der Wert, der am Ende der Warteschlange hinzugefügt werden soll. Der Wert kann für Verweistypen NULL sein.

cancellationToken

CancellationToken

Das Token zum Überwachen von Abbruchanforderungen. Der Standardwert ist None.

timeout

Nullable<TimeSpan>

Die Zeit, die gewartet werden muss, bis der Vorgang abgeschlossen ist, bevor eine TimeoutException ausgelöst wird. Der Standardwert ist NULL. Wenn NULL übergeben wird, wird ein Standardtimeout verwendet.

Gibt zurück

Task

Aufgabe, die den asynchronen Queue-Vorgang darstellt.

Ausnahmen

FabricNotPrimaryException

Das Replikat befindet sich nicht mehr in .

FabricNotReadableException

Das Replikat ist derzeit nicht lesbar.

FabricObjectClosedException

Die IReliableConcurrentQueue<T> wurde von der Runtime geschlossen.

FabricTransientException

Beim Replikat ist ein vorübergehender Fehler aufgetreten. Wiederholen des Vorgangs für eine neue Transaktion

FabricException

Für das Replikat ist ein nicht wiederholbarer Fehler aufgetreten, der nicht die oben definierten Typen ist. Bereinigen und erneutes Ausführen der Ausnahme

TimeoutException

Der Vorgang konnte nicht innerhalb des angegebenen Timeouts abgeschlossen werden. Die Transaktion sollte abgebrochen und eine neue Transaktion erstellt werden, um es erneut zu versuchen.

ArgumentNullException

tx ist NULL.

OperationCanceledException

Der Vorgang wurde über cancellationTokenabgebrochen.

TransactionFaultedException

Die Transaktion wurde intern vom System fehlerhaft gemacht. Wiederholen des Vorgangs für eine neue Transaktion

InvalidOperationException

Wird ausgelöst, wenn ein Methodenaufruf für den aktuellen Zustand des Objekts ungültig ist. Beispiel: Die verwendete Transaktion ist bereits beendet: vom Benutzer zugesagt oder abgebrochen. Wenn diese Ausnahme ausgelöst wird, ist es sehr wahrscheinlich, dass im Dienstcode der Verwendung von Transaktionen ein Fehler vorliegt.

Beispiele

In diesem Beispiel wird gezeigt, wie sie verwenden EnqueueAsync(ITransaction, T, CancellationToken, Nullable<TimeSpan>) , um einen Wert mit Wiederholung in Quequeque zu stellen.

protected override async Task RunAsync(CancellationToken cancellationToken)
{
    var concurrentQueue = await this.StateManager.GetOrAddAsync<IReliableConcurrentQueue<long>>(new Uri("fabric:/concurrentQueue"));

    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);
        }
        catch (FabricTransientException e)
        {
            // Retry until the queue is writable or a different exception is thrown.
            Console.WriteLine("Queue is currently not writable, retrying the transaction: " + e);
        }

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

Hinweise

Ein TryDequeueAsync(ITransaction, CancellationToken, Nullable<TimeSpan>) Vorgang kann keinen Wert zurückgeben, für den er EnqueueAsync(ITransaction, T, CancellationToken, Nullable<TimeSpan>) noch nicht committet wurde. Dies schließt die Transaktion ein, in der der Wert in die Warteschlange gestellt wurde; IReliableConcurrentQueue<T> daher wird Read-Your-Writes nicht unterstützt.