IReliableConcurrentQueue<T>.TryDequeueAsync Méthode

public System.Threading.Tasks.Task<Microsoft.ServiceFabric.Data.ConditionalValue<T>> TryDequeueAsync (Microsoft.ServiceFabric.Data.ITransaction tx, System.Threading.CancellationToken cancellationToken = default, TimeSpan? timeout = default);

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

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

Paramètres

Retours

Tâche qui représente l’opération de mise en file d’attente asynchrone. Le résultat de la tâche est une Valeur conditionnelle de type T. Si une valeur a été mise en file d’attente dans le délai donné, retourne une valeur conditionnelle avec HasValue comme false, sinon elle retourne une valeur conditionnelle avec HasValue comme true et la valeur comme élément en file d’attente de type T

Exceptions

Exemples

Cet exemple montre comment mettre la file d’attente et journaliser à l’infini avec une nouvelle tentative, jusqu’à ce que le jeton d’annulation soit annulé.

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

    // Assumption: values are being enqueued by another source (e.g. the communication listener).
    while (true)
    {
        cancellationToken.ThrowIfCancellationRequested();

        try
        {
            using (var tx = this.StateManager.CreateTransaction())
            {
                var dequeueOutput = await concurrentQueue.TryDequeueAsync(tx, cancellationToken, TimeSpan.FromMilliseconds(100));
                await tx.CommitAsync();

                if (dequeueOutput.HasValue)
                {
                    Console.WriteLine("Dequeue # " + dequeueOutput);
                }
                else
                {
                    Console.WriteLine("Could not dequeue in the given time");
                }
            }
        }
        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 dequeue 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 dequeue 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 DequeueAsync, 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

Alors que TryDequeueAsync(ITransaction, CancellationToken, Nullable<TimeSpan>) ne peuvent retourner que des valeurs pour lesquelles la valeur correspondante EnqueueAsync(ITransaction, T, CancellationToken, Nullable<TimeSpan>) a été validée, TryDequeueAsync(ITransaction, CancellationToken, Nullable<TimeSpan>) les opérations ne sont pas isolées les unes des autres. Une fois qu’une transaction a mis une valeur en file d’attente, d’autres transactions ne peuvent pas la mettre en file d’attente, mais ne sont pas empêchées de faire la file d’attente d’autres valeurs.

Lorsqu’une ou plusieurs transactions incluant une ou plusieurs TryDequeueAsync(ITransaction, CancellationToken, Nullable<TimeSpan>) opérations sont abandonnées, les valeurs de file d’attente sont ajoutées en tête de la file d’attente dans un ordre arbitraire. Cela garantit que ces valeurs seront bientôt supprimées à nouveau, ce qui améliore l’équité de la structure des données, mais sans appliquer un ordre strict (ce qui nécessiterait de réduire la concurrence autorisée, comme dans IReliableQueue<T>).

S’applique à