Comment dois-je attendre jusqu'à ce que la Tâche est terminée en C#?

Je veux envoyer une requête à un serveur et des processus la valeur retournée:

private static string Send(int id)
{
    Task<HttpResponseMessage> responseTask = client.GetAsync("aaaaa");
    string result = string.Empty;
    responseTask.ContinueWith(x => result = Print(x));
    responseTask.Wait(); //it doesn't wait for the completion of the response task
    return result;
}

private static string Print(Task<HttpResponseMessage> httpTask)
{
    Task<string> task = httpTask.Result.Content.ReadAsStringAsync();
    string result = string.Empty;
    task.ContinueWith(t =>
    {
        Console.WriteLine("Result: " + t.Result);
        result = t.Result;
    });
    task.Wait();  //it does wait
    return result;
}

Suis-je à l'aide de Task correctement? Je ne le pense pas parce que le Send() méthode renvoie string.Empty à chaque fois, alors que Print renvoie la valeur correcte.

Ce que je fais mal? Comment puis-je obtenir le résultat correct à partir d'un serveur?

InformationsquelleAutor | 2012-11-03

.net c#task task-parallel-library wait

29

Votre méthode d'Impression probablement besoin d'attendre de la continuation de finition (ContinueWith renvoie une tâche que vous pouvez attendre sur). Sinon, la deuxième ReadAsStringAsync finitions, la méthode renvoie (avant résultat est attribué dans la suite). Même problème existe dans votre méthode d'envoi. Les deux besoin d'attendre à la poursuite de toujours obtenir les résultats que vous voulez. Similaire à ci-dessous
```
private static string Send(int id)
{
    Task<HttpResponseMessage> responseTask = client.GetAsync("aaaaa");
    string result = string.Empty;
    Task continuation = responseTask.ContinueWith(x => result = Print(x));
    continuation.Wait();
    return result;
}

private static string Print(Task<HttpResponseMessage> httpTask)
{
    Task<string> task = httpTask.Result.Content.ReadAsStringAsync();
    string result = string.Empty;
    Task continuation = task.ContinueWith(t =>
    {
        Console.WriteLine("Result: " + t.Result);
        result = t.Result;
    });
    continuation.Wait();  
    return result;
}
```
- En aparté, le modèle où vous appel asynchrone, puis immédiatement à attendre sur elle, est à peu près la même chose que de simplement suivre de manière synchrone.
- C'est la meilleure solution lorsque u est coincé avec .net Framework 4.0 et que vous avez des problèmes d'ajout de microsoft.bcl.async nuget pkg afin de l'utiliser vous Attendent.
InformationsquelleAutor Kenneth Ito
6

Il attend client.GetAsync("aaaaa");, mais ne pas attendre pour result = Print(x)

Essayer responseTask.ContinueWith(x => result = Print(x)).Wait()

--EDIT--
```
Task responseTask = Task.Run(() => { 
    Thread.Sleep(1000); 
    Console.WriteLine("In task"); 
});
responseTask.ContinueWith(t=>Console.WriteLine("In ContinueWith"));
responseTask.Wait();
Console.WriteLine("End");
```
Code ci-dessus n'est pas garantie de la sortie:
```
In task
In ContinueWith
End
```
Mais ce n' (voir la newTask)
```
Task responseTask = Task.Run(() => { 
    Thread.Sleep(1000); 
    Console.WriteLine("In task"); 
});
Task newTask = responseTask.ContinueWith(t=>Console.WriteLine("In ContinueWith"));
newTask.Wait();
Console.WriteLine("End");
```
- Mais j'appelle de la tâche.Wait() au sein de la méthode Print ().
- Lorsque vous appelez task.Wait() vous attendez l'original Task, pas celui que vous avez créé avec ContinueWith
- Pourquoi n'appelez-vous pas responseTask.Wait() avant newTask.Task()?
- il n'y a pas besoin d'attendre la tâche précédente. ContinueWith garantira tâche précédente est terminée.
InformationsquelleAutor L.B

Je suis un async novice, donc je ne peux pas vous dire définitivement ce qui se passe ici. Je soupçonne qu'il y a un décalage dans l'exécution de la méthode des attentes, même si vous utilisez des tâches à l'interne dans les méthodes. Je pense que vous obtiendrez les résultats que vous attendez si vous avez changé d'Impression de revenir d'une Tâche<string>:

private static string Send(int id)
{
    Task<HttpResponseMessage> responseTask = client.GetAsync("aaaaa");
    Task<string> result;
    responseTask.ContinueWith(x => result = Print(x));
    result.Wait();
    responseTask.Wait(); //There's likely a better way to wait for both tasks without doing it in this awkward, consecutive way.
    return result.Result;
}

private static Task<string> Print(Task<HttpResponseMessage> httpTask)
{
    Task<string> task = httpTask.Result.Content.ReadAsStringAsync();
    string result = string.Empty;
    task.ContinueWith(t =>
    {
        Console.WriteLine("Result: " + t.Result);
        result = t.Result;
    });
    return task;
}

pas de test ? échec pour moi. Tâche<string> résultat est null

InformationsquelleAutor Jacob Proffitt

0

Lorsque l'on travaille avec les continuations je trouve qu'il est utile de penser à l'endroit où je vous écris .ContinueWith comme le lieu d'exécution qui reprend immédiatement les déclarations suivantes, de ne pas les déclarations de "l'intérieur" il. Dans ce cas, il devient évident que vous obtenez une chaîne vide est retournée en Envoyer. Si votre seul traitement de la réponse est de l'écrire dans la console, vous n'avez pas besoin d'Attendre dans l'Oti solution - la console d'impression, l'impression se fera sans l'attend, mais à la fois Envoyer et Imprimer doit retourner nulle dans ce cas. Exécutez cette application console et vous aurez l'impression de la page.

L'OMI, de l'attente et de la Tâche.Résultat des appels (le bloc) sont nécessaires parfois, en fonction de votre choix de flux de contrôle, mais le plus souvent ils sont un signe que vous n'avez pas vraiment l'utilisation asynchrone fonctionnalité correctement.
```
namespace TaskTest
{
    class Program
    {
        static void Main(string[] args)
        {
            Send();
            Console.WriteLine("Press Enter to exit");
            Console.ReadLine();
        }

        private static void Send()
        {
            HttpClient client = new HttpClient();
            Task<HttpResponseMessage> responseTask = client.GetAsync("http://google.com");
            responseTask.ContinueWith(x => Print(x));
        }

        private static void Print(Task<HttpResponseMessage> httpTask)
        {
            Task<string> task = httpTask.Result.Content.ReadAsStringAsync();
            Task continuation = task.ContinueWith(t =>
            {
                Console.WriteLine("Result: " + t.Result);
            });
        }
    }
}
```
- pour ne pas l'application de la console ? pas Readline disponible, n'importe quelle solution?
InformationsquelleAutor Tony

async Task<int> AccessTheWebAsync()  
{   
    //You need to add a reference to System.Net.Http to declare client.  
    HttpClient client = new HttpClient();  

    //GetStringAsync returns a Task<string>. That means that when you await the  
    //task you'll get a string (urlContents).  
    Task<string> getStringTask = 

    client.GetStringAsync("http://msdn.microsoft.com");  

    //You can do work here that doesn't rely on the string from GetStringAsync.  
    DoIndependentWork();  

    //The await operator suspends AccessTheWebAsync.  
    // - AccessTheWebAsync can't continue until getStringTask is complete.  
    // - Meanwhile, control returns to the caller of AccessTheWebAsync.  
    // - Control resumes here when getStringTask is complete.   
    // - The await operator then retrieves the string result from 
    getStringTask.  
    string urlContents = await getStringTask;  

    //The return statement specifies an integer result.  
    //Any methods that are awaiting AccessTheWebenter code hereAsync retrieve the length 
    value.  
    return urlContents.Length;  
}

InformationsquelleAutor Nainesh Patel

Un exemple propre qui répond au Titre

string output = "Error";
Task task = Task.Factory.StartNew(() =>
{
    System.Threading.Thread.Sleep(2000);
    output = "Complete";
});

task.Wait();
Console.WriteLine(output);

InformationsquelleAutor vikingfabian

Vous devez vous connecter pour publier un commentaire.