Comment puis-je attendre de manière asynchrone une tâche avec un temps mort et une annulation?

Gérer les opérations asynchrones Task<T>: délais d'expiration et annulation

La programmation asynchrone nécessite souvent d'attendre que un Task<T> se termine, mais avec des considérations supplémentaires comme les délais d'attente et l'annulation. Ceci est crucial pour l'expérience utilisateur (affichage des indicateurs de progression ou des messages après un certain temps) et la gestion des ressources (prévenir le blocage indéfini).

Task.ContinueWith offre une surveillance asynchrone, mais manque de fonctionnalité de délai d'expiration. Inversement, Task.Wait fournit une manipulation de délai d'expiration mais bloque le fil d'appel. Une solution plus élégante équilibre les deux besoins.

Manipulation efficace du délai d'expiration

l'extrait de code suivant démontre un moyen concis d'attendre de manière asynchrone une tâche avec un délai d'expiration:

int timeoutMilliseconds = 1000;
var task = SomeOperationAsync();
if (await Task.WhenAny(task, Task.Delay(timeoutMilliseconds)) == task)
{
    // Task completed within the timeout period
}
else
{
    // Timeout handling – e.g., display a message to the user
}

Intégration d'annulation robuste

Pour une robustesse améliorée, incorporez le support de jeton d'annulation:

int timeoutMilliseconds = 1000;
var cancellationToken = new CancellationTokenSource();
var task = SomeOperationAsync(cancellationToken.Token);
try
{
    if (await Task.WhenAny(task, Task.Delay(timeoutMilliseconds, cancellationToken.Token)) == task)
    {
        // Task completed within timeout (or was canceled)
        await task; // Re-await to handle exceptions or cancellation
    }
    else
    {
        // Timeout or cancellation handling
        cancellationToken.Cancel(); // Explicit cancellation if needed
    }
}
catch (OperationCanceledException)
{
    // Handle cancellation specifically
}

Cette approche améliorée gère gracieusement les délais et annulations, assurant une gestion des erreurs plus propre et la prévention des fuites de ressources. Le bloc try-catch aborde spécifiquement OperationCanceledException, permettant des réponses sur mesure aux demandes d'annulation. La réévaluation de la tâche après Task.WhenAny garantit que les exceptions ou les signaux d'annulation de la tâche d'origine se propagent correctement.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!