Suppression de "avertissement CS4014: Cet appel n'étant pas attendu, l'exécution de la méthode actuelle continue…"

Ce n'est pas un doublon de "Comment appeler en toute sécurité une méthode async en C # sans attendre" .

Comment supprimer gentiment l'avertissement suivant?

avertissement CS4014: Cet appel n'étant pas attendu, l'exécution de la méthode actuelle se poursuit avant la fin de l'appel. Envisagez d'appliquer l'opérateur 'await' au résultat de l'appel.

Un exemple simple:

static async Task WorkAsync()
{
    await Task.Delay(1000);
    Console.WriteLine("Done!");
}

static async Task StartWorkAsync()
{
    WorkAsync(); // I want fire-and-forget 

    // more unrelated async/await stuff here, e.g.:
    // ...
    await Task.Delay(2000); 
}

Ce que j'ai essayé et je n'ai pas aimé:

static async Task StartWorkAsync()
{
    #pragma warning disable 4014
    WorkAsync(); // I want fire-and-forget here
    #pragma warning restore 4014
    // ...
}

static async Task StartWorkAsync()
{
    var ignoreMe = WorkAsync(); // I want fire-and-forget here
    // ...
}

Mis à jour , puisque la réponse acceptée d'origine a été modifiée, j'ai changé la réponse acceptée par celle utilisant les rejets C # 7.0 , car je ne pense pas que ce ContinueWithsoit approprié ici. Chaque fois que j'ai besoin de consigner des exceptions pour des opérations d'incendie et d'oubli, j'utilise une approche plus élaborée proposée par Stephen Cleary ici .

Avec C # 7, vous pouvez désormais utiliser les rejets :

_ = WorkAsync();

Vous pouvez créer une méthode d'extension qui empêchera l'avertissement. La méthode d'extension peut être vide ou vous pouvez y ajouter la gestion des exceptions .ContinueWith().

static class TaskExtensions
{
    public static void Forget(this Task task)
    {
        task.ContinueWith(
            t => { WriteLog(t.Exception); },
            TaskContinuationOptions.OnlyOnFaulted);
    }
}

public async Task StartWorkAsync()
{
    this.WorkAsync().Forget();
}

Cependant, ASP.NET compte le nombre de tâches en cours d'exécution, il ne fonctionnera donc pas avec l' Forget()extension simple comme indiqué ci-dessus et peut échouer à la place avec l'exception:

Un module ou un gestionnaire asynchrone s'est terminé alors qu'une opération asynchrone était toujours en attente.

Avec .NET 4.5.2, il peut être résolu en utilisant HostingEnvironment.QueueBackgroundWorkItem:

public static Task HandleFault(this Task task, CancellationToken cancelToken)
{
    return task.ContinueWith(
        t => { WriteLog(t.Exception); },
        cancelToken,
        TaskContinuationOptions.OnlyOnFaulted,
        TaskScheduler.Default);
}

public async Task StartWorkAsync()
{
    System.Web.Hosting.HostingEnvironment.QueueBackgroundWorkItem(
        cancelToken => this.WorkAsync().HandleFault(cancelToken));
}

Vous pouvez décorer la méthode avec l'attribut suivant:

[System.Diagnostics.CodeAnalysis.SuppressMessage("Await.Warning", "CS4014:Await.Warning")]
static async Task StartWorkAsync()
{
    WorkAsync();
    // ...
}

En gros, vous dites au compilateur que vous savez ce que vous faites et qu'il n'a pas besoin de s'inquiéter d'une éventuelle erreur.

La partie importante de ce code est le deuxième paramètre. La partie "CS4014:" supprime l'avertissement. Vous pouvez écrire tout ce que vous voulez sur le reste.

Mes deux façons de gérer cela.

Enregistrez-le dans une variable d'élimination (C # 7)

Exemple

_ = Task.Run(() => DoMyStuff()).ConfigureAwait(false);

Depuis l'introduction des rejets dans C # 7, je considère maintenant que c'est mieux que de supprimer l'avertissement. Parce qu'il supprime non seulement l'avertissement, mais rend également clair l'intention d'incendier et d'oublier.

De plus, le compilateur pourra l'optimiser en mode version.

Supprimez-le simplement

#pragma warning disable 4014
...
#pragma warning restore 4014

est une solution assez sympa pour "tirer et oublier".

La raison pour laquelle cet avertissement existe est que dans de nombreux cas, vous n'avez pas l'intention d'utiliser une méthode qui renvoie une tâche sans l'attendre. Il est logique de supprimer l'avertissement lorsque vous avez l'intention de tirer et d'oublier.

Si vous ne parvenez pas à vous souvenir de l'orthographe #pragma warning disable 4014, laissez simplement Visual Studio l'ajouter pour vous. Appuyez sur Ctrl +. pour ouvrir "Actions rapides", puis "Supprimer CS2014"

En tout

C'est stupide de créer une méthode qui prend quelques ticks de plus à exécuter, juste dans le but de supprimer un avertissement.

Un moyen simple d'arrêter l'avertissement est d'attribuer simplement la tâche lors de son appel:

Task fireAndForget = WorkAsync(); // No warning now

Et donc dans votre message d'origine, vous feriez:

static async Task StartWorkAsync()
{
    // Fire and forget
    var fireAndForget = WorkAsync(); // Tell the compiler you know it's a task that's being returned 

    // more unrelated async/await stuff here, e.g.:
    // ...
    await Task.Delay(2000); 
}

La raison de l'avertissement est que WorkAsync renvoie un Taskqui n'est jamais lu ou attendu. Vous pouvez définir le type de retour de WorkAsync sur voidet l'avertissement disparaîtra.

En général, une méthode renvoie un Tasklorsque l'appelant a besoin de connaître l'état du travailleur. Dans le cas d'un feu et oubliez, void doit être retourné pour ressembler à ce que l'appelant est indépendant de la méthode appelée.

static async void WorkAsync()
{
    await Task.Delay(1000);
    Console.WriteLine("Done!");
}

static async Task StartWorkAsync()
{
    WorkAsync(); // no warning since return type is void

    // more unrelated async/await stuff here, e.g.:
    // ...
    await Task.Delay(2000); 
}

Pourquoi ne pas l'envelopper dans une méthode asynchrone qui renvoie void? Un peu long mais toutes les variables sont utilisées.

static async Task StartWorkAsync()
{   
     async void WorkAndForgetAsync() => await WorkAsync();
     WorkAndForgetAsync(); // no warning
}

J'ai trouvé cette approche par accident aujourd'hui. Vous pouvez définir un délégué et attribuer d'abord la méthode async au délégué.

    delegate Task IntermediateHandler();



    static async Task AsyncOperation()
    {
        await Task.Yield();
    }

et appelle ça comme ça

(new IntermediateHandler(AsyncOperation))();

...

J'ai pensé qu'il était intéressant que le compilateur ne donne pas exactement le même avertissement lors de l'utilisation du délégué.