Liste<Monobjet> ne contient pas une définition pour GetAwaiter

J'ai une méthode qui retourne une Liste<> d'un objet. Cette méthode prend du temps pour s'exécuter.

private List<MyObject> GetBigList()
{
    ... slow stuff
}

Cette méthode est appelée à partir de 4 ou 5 sources. Alors, j'ai pensé que je voudrais essayer et utiliser async et await pour garder les choses en mouvement et cette liste s'appuie. J'ai ajouté cette méthode:

public async Task<List<MyObject>> GetBigListAsync()
{
    var resultsTask = GetBigList();
    var resuls = await resultsTask;
    return resuls;
}

Mais, sur cette ligne:

var resuls = await resultsTask;

J'obtiens cette erreur:

Liste<Monobjet> ne contient pas une définition pour GetAwaiter,
et aucune méthode d'extension 'GetAwaiter' acceptant un premier argument de type List<Monobjet> a pu être trouvé.

Ce qui me manque?

Votre exemple de code ne montre pas de toute utilisation d'une Tâche dans la GetBigList méthode, ni est-il marqué que asynchrone, ce qui signifie que le résultat de cette méthode ne peut pas être attendu.
essayez async Task<Liste<Monobjet>> GetBigList()
Rappelez-vous, attendre n'est pas une opération synchrone dans une opération asynchrone. Attendent des signes le reste de la méthode actuelle comme la continuation de l'existence d'un fonctionnement asynchrone. Attendent est sur la gestion de l'asynchronisme, de ne pas le créer. Si vous voulez une opération synchrone asynchrone, vous allez devoir trouver un moyen de faire que cela se produise.

InformationsquelleAutor Casey Crookston | 2016-11-23

async-await c#

20

Il semble que vous êtes un débutant, async-vous attendent. Ce qui m'a vraiment aidé à comprendre ce que asynchrone attendent n'est le restaurant de l'analogie donnée par Eric Lippert dans cette interview. de Recherche, quelque part dans le milieu pour async attendent.

Ici, il explique que si un cuisinier doit attendre quelque chose, au lieu de ne rien faire, il commence à regarder autour pour voir si il peut faire autre chose en attendant.

Asynchrone attendent est similaire. Au lieu de l'attente d'un fichier à lire, une requête de base de données à retourner, une page web pour être téléchargé, votre thread va aller en haut de la pile d'appels pour voir si les appelants ne sont pas dans l'attente et exécute ces instructions jusqu'à ce qu'il voit dans l'attendent. Une fois qu'il voit le attendent le thread va jusqu'à la pile d'appel de nouveau pour voir si l'une des parties n'est pas en attente, etc. Après un certain temps lorsque le fichier est lu, ou que la requête est terminée, etc, les déclarations après l'attendent sont effectuées.

Normalement lors de la lecture de votre grande liste de votre thread serait très occupé au lieu de les bras croisés à attendre. Il n'est pas certain que la commande d'un autre thread pour faire les choses devraient améliorer le temps nécessaire à la lecture de votre liste. Envisager de mesurer les deux méthodes.

L'une des raisons pour utiliser asynchrone-attendre, même si cela aurait pour effet d'allonger le temps
nécessaires à la lecture de la grande liste, serait de garder l'appelant (l'utilisateur
interface?) réactive.

Pour faire de votre fonction asynchrone, vous devez effectuer les opérations suivantes:
- Déclarer la fonction asynchrone;
- Au lieu de TResult retour Task<TResult> et au lieu de void retour Task;
- Si votre fonction appelle d'autres async fonctions, envisager de se souvenir de l'retourné à la tâche plutôt que de await, faire d'autres choses utiles que vous devez faire et await la tâche lorsque vous avez besoin de la raison;
- Si vous voulez vraiment laisser un autre thread ne le occupé des choses. appel
  
  Tâche.Exécuter( () => GetBigList())
et attendent lorsque vous avez besoin des résultats.
```
private async Task<List<MyObject>> GetBigListAsync()
{
    var myTask = Task.Run( () => GetBigList());
    //your thread is free to do other useful stuff right nw
    DoOtherUsefulStuff();
    //after a while you need the result, await for myTask:
    List<MyObject> result = await myTask;

    //you can now use the results of loading:
    ProcessResult(result);
    return result;
}
```
Encore une fois: si vous n'avez rien d'utile à faire, tandis que l'autre thread est le chargement de la Liste (comme de s'assurer de l'INTERFACE utilisateur réactive), ne faites pas cela, ou au moins de mesurer si vous êtes plus rapide.

D'autres articles qui m'ont aidé à comprendre asynchrone attendent étaient
- Async attendent, par le toujours très serviable Stephen Cleary,
- et un peu plus avancé: Async-Attendre les meilleures pratiques.

InformationsquelleAutor Harald Coppoolse
12

resultTask est juste la liste retournée par GetBigList(), de sorte que rien ne se passera async là.

Ce que vous pouvez faire est de déchargement de la tâche à un thread séparé sur le pool de threads en utilisant Task.Run et le retour de la awaitable Task objet:
```
//Bad code
public Task<List<MyObject>> GetBigListAsync()
{
    return Task.Run(() => GetBigList());
}
```
Bien que l'exemple ci-dessus correspond le mieux à ce que vous essayiez de faire, il n'est pas le plus pratique. Essayez de faire de la GetBigList() asynchrone de la nature, ou si il n'y a vraiment aucun moyen, laisser la décision sur l'exécution du code dans un thread séparé pour le code d'appel et de ne pas cacher ce dans la mise en œuvre de la F. e. si le code d'appel s'exécute déjà asynchrone, il n'y a aucune raison pour pondre encore un autre thread. Cet article décrit plus en détail.

InformationsquelleAutor huysentruitw

Vous devez vous connecter pour publier un commentaire.