IReliableConcurrentQueue<T>.TryDequeueAsync Método

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

Parâmetros

Retornos

Uma tarefa que representa a operação assíncrona de remoção de fila. O resultado da tarefa é um ConditionalValue do tipo T. Se um valor tiver sido descontinuado dentro do tempo determinado, retorne um ConditionalValue com HasValue como false, caso contrário, ele retornará um ConditionalValue com HasValue como true e o Value como o item dequeued do Tipo T

Exceções

Exemplos

Este exemplo mostra como remover a fila e registrar em log infinitamente com repetição, até que o token de cancelamento seja cancelado.

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

Comentários

Embora TryDequeueAsync(ITransaction, CancellationToken, Nullable<TimeSpan>) só possa retornar valores para os quais o correspondente EnqueueAsync(ITransaction, T, CancellationToken, Nullable<TimeSpan>) foi confirmado, TryDequeueAsync(ITransaction, CancellationToken, Nullable<TimeSpan>) as operações não são isoladas umas das outras. Depois que uma transação tiver descontinuado um valor, outras transações não poderão desempedi-la, mas não serão impedidas de remover a fila de outros valores.

Quando uma transação ou transações que incluem uma ou mais TryDequeueAsync(ITransaction, CancellationToken, Nullable<TimeSpan>) operações for anulada, os valores dequeu serão adicionados novamente ao cabeçalho da fila em uma ordem arbitrária. Isso garantirá que esses valores serão desempedidos novamente em breve, melhorando a imparcialidade da estrutura de dados, mas sem impor uma ordenação estrita (o que exigiria reduzir a simultaneidade permitida, como em IReliableQueue<T>).

Aplica-se a