Je viens de recevoir VS2012 et j'essaie de comprendre async.

Disons que j'ai une méthode qui récupère une valeur à partir d'une source de blocage. Je ne veux pas que l'appelant de la méthode bloque. Je pourrais écrire la méthode pour prendre un rappel qui est appelé lorsque la valeur arrive, mais comme j'utilise C # 5, je décide de rendre la méthode asynchrone afin que les appelants n'aient pas à gérer les rappels:

// contrived example (edited in response to Servy's comment)
public static Task<string> PromptForStringAsync(string prompt)
{
    return Task.Factory.StartNew(() => {
        Console.Write(prompt);
        return Console.ReadLine();
    });
}

Voici un exemple de méthode qui l'appelle. Si ce PromptForStringAsyncn'était pas asynchrone, cette méthode nécessiterait l'imbrication d'un rappel dans un rappel. Avec async, j'écris ma méthode de cette manière très naturelle:

public static async Task GetNameAsync()
{
    string firstname = await PromptForStringAsync("Enter your first name: ");
    Console.WriteLine("Welcome {0}.", firstname);

    string lastname = await PromptForStringAsync("Enter your last name: ");
    Console.WriteLine("Name saved as '{0} {1}'.", firstname, lastname);
}

Jusqu'ici tout va bien. Le problème est lorsque j'appelle GetNameAsync:

public static void DoStuff()
{
    GetNameAsync();
    MainWorkOfApplicationIDontWantBlocked();
}

Tout l'intérêt de GetNameAsyncest qu'il est asynchrone. Je ne veux pas qu'il se bloque, car je veux revenir à MainWorkOfApplicationIDontWantBlocked dès que possible et laisser GetNameAsync faire son travail en arrière-plan. Cependant, l'appeler de cette façon me donne un avertissement du compilateur sur la GetNameAsyncligne:

Warning 1   Because this call is not awaited, execution of the current method continues before the call is completed. Consider applying the 'await' operator to the result of the call.

Je suis parfaitement conscient que "l'exécution de la méthode actuelle se poursuit avant que l'appel ne soit terminé". C'est le but du code asynchrone, non?

Je préfère que mon code compile sans avertissements, mais il n'y a rien à "corriger" ici car le code fait exactement ce que je compte faire. Je peux me débarrasser de l'avertissement en stockant la valeur de retour de GetNameAsync:

public static void DoStuff()
{
    var result = GetNameAsync(); // supress warning
    MainWorkOfApplicationIDontWantBlocked();
}

Mais maintenant, j'ai du code superflu. Visual Studio semble comprendre que j'ai été obligé d'écrire ce code inutile, car il supprime l'avertissement normal «valeur jamais utilisée».

Je peux également me débarrasser de l'avertissement en enveloppant GetNameAsync dans une méthode qui n'est pas asynchrone:

    public static Task GetNameWrapper()
    {
        return GetNameAsync();
    }

Mais c'est du code encore plus superflu. Je dois donc écrire du code dont je n'ai pas besoin ou que je tolère un avertissement inutile.

Y a-t-il quelque chose dans mon utilisation de l'async qui ne va pas ici?

Si vous n'avez vraiment pas besoin du résultat, vous pouvez simplement changer la GetNameAsyncsignature de pour retourner void:

public static async void GetNameAsync()
{
    ...
}

Pensez à voir la réponse à une question connexe: Quelle est la différence entre renvoyer une annulation et renvoyer une tâche?

Mettre à jour

Si vous avez besoin du résultat, vous pouvez modifier le GetNameAsyncpour renvoyer, par exemple Task<string>:

public static async Task<string> GetNameAsync()
{
    string firstname = await PromptForStringAsync("Enter your first name: ");
    string lastname = await PromptForStringAsync("Enter your last name: ");
    return firstname + lastname;
}

Et utilisez-le comme suit:

public static void DoStuff()
{
    Task<string> task = GetNameAsync();

    // Set up a continuation BEFORE MainWorkOfApplicationIDontWantBlocked
    Task anotherTask = task.ContinueWith(r => {
            Console.WriteLine(r.Result);
        });

    MainWorkOfApplicationIDontWantBlocked();

    // OR wait for the result AFTER
    string result = task.Result;
}

Je suis assez en retard dans cette discussion, mais il y a aussi la possibilité d'utiliser la #pragmadirective pré-processeur. J'ai du code asynchrone ici et là que je ne veux explicitement pas attendre dans certaines conditions, et je n'aime pas les avertissements et les variables inutilisées, tout comme vous:

#pragma warning disable 4014
SomeMethodAsync();
#pragma warning restore 4014

Le "4014"provient de cette page MSDN: Avertissement du compilateur (niveau 1) CS4014 .

Voir également l'avertissement / réponse de @ ryan-horath ici https://stackoverflow.com/a/12145047/928483 .

Les exceptions levées lors d'un appel asynchrone qui n'est pas attendu seront perdues. Pour vous débarrasser de cet avertissement, vous devez affecter la valeur de retour de tâche de l'appel asynchrone à une variable. Cela garantit que vous avez accès à toutes les exceptions levées, qui seront indiquées dans la valeur de retour.

Mise à jour pour C # 7.0

C # 7.0 ajoute une nouvelle fonctionnalité, supprimer les variables: Discards - Guide C # , qui peut également aider à cet égard.

_ = SomeMethodAsync();

Je n'aime pas particulièrement les solutions qui affectent la tâche à une variable inutilisée ou modifient la signature de la méthode pour renvoyer void. Le premier crée un code superflu et non intuitif, tandis que le second peut ne pas être possible si vous implémentez une interface ou si vous avez une autre utilisation de la fonction où vous souhaitez utiliser la tâche retournée.

Ma solution est de créer une méthode d'extension de Task, appelée DoNotAwait () qui ne fait rien. Cela supprimera non seulement tous les avertissements, ReSharper ou autre, mais rendra le code plus compréhensible et indiquera aux futurs responsables de votre code que vous aviez vraiment l'intention que l'appel ne soit pas attendu.

Méthode d'extension:

public static class TaskExtensions
{
    public static void DoNotAwait(this Task task) { }
}

Usage:

public static void DoStuff()
{
    GetNameAsync().DoNotAwait();
    MainWorkOfApplicationIDontWantBlocked();
}

Modifié pour ajouter: c'est similaire à la solution de Jonathan Allen où la méthode d'extension commencerait la tâche si elle n'était pas déjà commencée, mais je préfère avoir des fonctions à usage unique afin que l'intention de l'appelant soit complètement claire.

async void EST MAUVAIS!

1. Quelle est la différence entre renvoyer un nul et renvoyer une tâche?
2. https://jaylee.org/archive/2012/07/08/c-sharp-async-tips-and-tricks-part-2-async-void.html

Ce que je suggère, c'est que vous exécutiez explicitement le Taskvia une méthode anonyme ...

par exemple

public static void DoStuff()
{
    Task.Run(async () => GetNameAsync());
    MainWorkOfApplicationIDontWantBlocked();
}

Ou si vous vouliez le bloquer, vous pouvez attendre sur la méthode anonyme

public static void DoStuff()
{
    Task.Run(async () => await GetNameAsync());
    MainWorkOfApplicationThatWillBeBlocked();
}

Cependant, si votre GetNameAsyncméthode doit interagir avec l'interface utilisateur ou même quoi que ce soit lié à l'interface utilisateur, (WINRT / MVVM, je vous regarde), alors cela devient un peu plus funk =)

Vous devrez transmettre la référence au répartiteur de l'interface utilisateur comme ceci ...

Task.Run(async () => await GetNameAsync(CoreApplication.MainView.CoreWindow.Dispatcher));

Et puis, dans votre méthode asynchrone, vous devrez interagir avec votre interface utilisateur ou les éléments liés à l'interface utilisateur pensant que le répartiteur ...

dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => {  this.UserName = userName; });

C'est ce que je fais actuellement:

SomeAyncFunction().RunConcurrently();

Où RunConcurrentlyest défini comme ...

 /// <summary> 
 /// Runs the Task in a concurrent thread without waiting for it to complete. This will start the task if it is not already running. 
 /// </summary> 
 /// <param name="task">The task to run.</param> 
 /// <remarks>This is usually used to avoid warning messages about not waiting for the task to complete.</remarks> 
 public static void RunConcurrently(this Task task) 
 { 
     if (task == null) 
         throw new ArgumentNullException("task", "task is null."); 

     if (task.Status == TaskStatus.Created) 
         task.Start(); 
 } 

https://github.com/docevaad/Anchor/blob/master/Tortuga.Anchor/Tortuga.Anchor.source/shared/TaskUtilities.cs

https://www.nuget.org/packages/Tortuga.Anchor/

Selon l'article de Microsoft sur cet avertissement, vous pouvez le résoudre en affectant simplement la tâche renvoyée à une variable. Vous trouverez ci-dessous une traduction du code fourni dans l'exemple Microsoft:

    // To suppress the warning without awaiting, you can assign the 
    // returned task to a variable. The assignment doesn't change how
    // the program runs. However, the recommended practice is always to
    // await a call to an async method.
    // Replace Call #1 with the following line.
    Task delayTask = CalledMethodAsync(delay);

Notez que cela entraînera le message «La variable locale n'est jamais utilisée» dans ReSharper.

Ici, une solution simple.

public static class TasksExtensions
{
    public static void RunAndForget(this Task task)
    {
    }
}

Cordialement

C'est votre exemple simplifié qui provoque le code superfleux. Normalement, vous voudriez utiliser les données qui ont été extraites de la source de blocage à un moment donné dans le programme, donc vous voudriez que le résultat soit renvoyé afin qu'il soit possible d'accéder aux données.

Si vous avez vraiment quelque chose qui se passe totalement isolé du reste du programme, async ne serait pas la bonne approche. Démarrez simplement un nouveau fil pour cette tâche.

Voulez-vous vraiment ignorer le résultat? comme en ignorant les exceptions inattendues?

Sinon, vous voudrez peut-être jeter un coup d'œil à cette question: approche Fire and Forget ,

Si vous ne souhaitez pas modifier la signature de la méthode à renvoyer void(car le retour voiddoit toujours être un void ed), vous pouvez utiliser la fonctionnalité C # 7.0+ Discard comme celle-ci, qui est légèrement meilleure que l'assignation à une variable (et devrait supprimer la plupart des autres avertissements des outils de validation source):

public static void DoStuff()
{
    _ = GetNameAsync(); // we don't need the return value (suppresses warning)
    MainWorkOfApplicationIDontWantBlocked();
}