IReliableConcurrentQueue<T>.EnqueueAsync Método

Definición

Espacio de nombres:

Microsoft.ServiceFabric.Data.Collections

Ensamblado:

Microsoft.ServiceFabric.Data.Interfaces.dll

Paquete:

Microsoft.ServiceFabric.Data.Interfaces v6.1.1583

Almacenar provisionalmente la cola de un valor en la cola.

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

Transacción con la que asociar esta operación.

value

T

Valor que se va a agregar al final de la cola. El valor puede ser null para los tipos de referencia.

cancellationToken

CancellationToken

Token para supervisar solicitudes de cancelación. El valor predeterminado es None.

timeout

Nullable<TimeSpan>

Cantidad de tiempo que se debe esperar a que se complete la operación antes de iniciar timeoutException. El valor predeterminado es null. Si se pasa null, se usará un tiempo de espera predeterminado.

Devoluciones

Task

Tarea que representa la operación de puesta en cola asincrónica.

Excepciones

FabricNotPrimaryException

La réplica ya no está en .

FabricNotReadableException

Actualmente, la réplica no es legible.

FabricObjectClosedException

El IReliableConcurrentQueue<T> tiempo de ejecución cerró .

FabricTransientException

La réplica vio un error transitorio. Reintentar la operación en una nueva transacción

FabricException

La réplica vio un error no reintenible distinto de los tipos definidos anteriormente. Limpiar y volver a iniciar la excepción

TimeoutException

No se pudo completar la operación dentro del tiempo de espera especificado. Se debe anular la transacción y se debe crear una nueva transacción para reintentar.

ArgumentNullException

tx es null.

OperationCanceledException

La operación se canceló a través de cancellationToken.

TransactionFaultedException

El sistema ha producido un error interno en la transacción. Reintentar la operación en una nueva transacción

InvalidOperationException

Se produce cuando una llamada de método no es válida para el estado actual del objeto. Por ejemplo, la transacción usada ya ha finalizado: el usuario la ha confirmado o anulado. Si se produce esta excepción, es muy probable que haya un error en el código de servicio del uso de transacciones.

Ejemplos

En este ejemplo se muestra cómo usar EnqueueAsync(ITransaction, T, CancellationToken, Nullable<TimeSpan>) para poner en cola un valor con reintento.

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

Comentarios

Una TryDequeueAsync(ITransaction, CancellationToken, Nullable<TimeSpan>) operación no puede devolver ningún valor para el que EnqueueAsync(ITransaction, T, CancellationToken, Nullable<TimeSpan>) aún no se haya confirmado. Esto incluye la transacción en la que se puso en cola el valor; como consecuencia, IReliableConcurrentQueue<T> no admite lecturas de escritura.