IReliableConcurrentQueue<T>.EnqueueAsync Méthode

Définition

Espace de noms:

Microsoft.ServiceFabric.Data.Collections

Assembly:

Microsoft.ServiceFabric.Data.Interfaces.dll

Paquet:

Microsoft.ServiceFabric.Data.Interfaces v6.1.1583

Placez la file d’attente d’une valeur dans la file d’attente.

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

Paramètres

tx

ITransaction

Transaction à laquelle associer cette opération.

value

T

Valeur à ajouter à la fin de la file d’attente. La valeur peut être null pour les types référence.

cancellationToken

CancellationToken

Jeton pour surveiller les requêtes d'annulation. Par défaut, il s’agit de None.

timeout

Nullable<TimeSpan>

Délai d’attente de la fin de l’opération avant de lever une exception TimeoutException. La valeur par défaut est null. Si null est passé, un délai d’expiration par défaut est utilisé.

Retours

Task

Tâche qui représente l’opération de mise en file d’attente asynchrone.

Exceptions

FabricNotPrimaryException

Le réplica n’est plus dans .

FabricNotReadableException

Le réplica n’est actuellement pas lisible.

FabricObjectClosedException

a IReliableConcurrentQueue<T> été fermé par le runtime.

FabricTransientException

Le réplica a vu une défaillance temporaire. Réessayez l’opération sur une nouvelle transaction

FabricException

Le réplica a vu une défaillance non retenable autre que les types définis ci-dessus. Nettoyer et relancer l’exception

TimeoutException

L’opération n’a pas pu être effectuée dans le délai d’expiration donné. La transaction doit être abandonnée et une nouvelle transaction doit être créée pour réessayer.

ArgumentNullException

tx a la valeur null.

OperationCanceledException

L’opération a été annulée via cancellationToken.

TransactionFaultedException

La transaction a été défaillante en interne par le système. Réessayez l’opération sur une nouvelle transaction

InvalidOperationException

Levée lorsqu’un appel de méthode n’est pas valide pour l’état actuel de l’objet. Par exemple, la transaction utilisée est déjà terminée : validée ou abandonnée par l’utilisateur. Si cette exception est levée, il est très probable qu’il y ait un bogue dans le code de service de l’utilisation des transactions.

Exemples

Cet exemple montre comment utiliser EnqueueAsync(ITransaction, T, CancellationToken, Nullable<TimeSpan>) pour mettre en file d’attente une valeur avec une nouvelle tentative.

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

Remarques

Une TryDequeueAsync(ITransaction, CancellationToken, Nullable<TimeSpan>) opération ne peut pas retourner une valeur pour laquelle son EnqueueAsync(ITransaction, T, CancellationToken, Nullable<TimeSpan>) n’a pas encore été validée. Cela inclut la transaction dans laquelle la valeur a été mise en file d’attente ; par conséquent, IReliableConcurrentQueue<T> ne prend pas en charge la lecture de vos écritures.