IReliableConcurrentQueue<T>.EnqueueAsync Método

Definição

Namespace:

Microsoft.ServiceFabric.Data.Collections

Assembly:

Microsoft.ServiceFabric.Data.Interfaces.dll

Pacote:

Microsoft.ServiceFabric.Data.Interfaces v6.1.1583

Preparar a enfileiramento de um valor para a fila.

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

Parâmetros

tx

ITransaction

Transação à qual associar essa operação.

value

T

O valor a ser adicionado ao final da fila. O valor pode ser nulo para tipos de referência.

cancellationToken

CancellationToken

O token a se monitorar para solicitações de cancelamento. O padrão é None.

timeout

Nullable<TimeSpan>

A quantidade de tempo para aguardar a conclusão da operação antes de lançar um TimeoutException. O padrão é nulo. Se nulo for passado, um tempo limite padrão será usado.

Retornos

Task

Tarefa que representa a operação de enfileiramento assíncrona.

Exceções

FabricNotPrimaryException

O réplica não está mais em .

FabricNotReadableException

No momento, o réplica não é legível.

FabricObjectClosedException

O IReliableConcurrentQueue<T> foi fechado pelo runtime.

FabricTransientException

O réplica viu uma falha transitória. Repetir a operação em uma nova transação

FabricException

O réplica viu uma falha não retriável diferente dos tipos definidos acima. Limpar e relançar a exceção

TimeoutException

A operação não pôde ser concluída dentro do tempo limite especificado. A transação deve ser anulada e uma nova transação deve ser criada para tentar novamente.

ArgumentNullException

tx é nulo.

OperationCanceledException

A operação foi cancelada por meio de cancellationToken.

TransactionFaultedException

A transação foi falha interna do sistema. Repetir a operação em uma nova transação

InvalidOperationException

Gerado quando uma chamada de método é inválida para o estado atual do objeto. Por exemplo, a transação usada já foi encerrada: confirmada ou anulada pelo usuário. Se essa exceção for gerada, é altamente provável que haja um bug no código de serviço do uso de transações.

Exemplos

Este exemplo mostra como usar EnqueueAsync(ITransaction, T, CancellationToken, Nullable<TimeSpan>) para enfileirar um valor com repetição.

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

Comentários

Uma TryDequeueAsync(ITransaction, CancellationToken, Nullable<TimeSpan>) operação não pode retornar nenhum valor para o qual EnqueueAsync(ITransaction, T, CancellationToken, Nullable<TimeSpan>) ainda não foi confirmada. Isso inclui a transação na qual o valor foi enfileirado; Como consequência, IReliableConcurrentQueue<T> não dá suporte a Leitura-Suas-Gravações.