Impossible de convertir de 'Système.Le filetage.Les tâches.La tâche' de 'Système.Les Collections.Génériques.Dictionnaire<string,string>'

Je crois que j'ai peut-être juste la syntaxe de mal, mais ce que j'essaie de faire est de créer une tâche qui s'exécute après l'autre tâche est terminée.

J'ai une tâche pour chaque tableau de 100 dans une liste. Il démarre un nouveau thread passage que tableau dans une méthode. La méthode retourne un dictionnaire quand il se termine. Je suis en train de créer une tâche à exécuter après la méthode est terminée, où il passe le retour de dictionnaire, à une méthode qui ne un peu plus de travail.

static void Main(string[] args)
{
try
{
stopwatch = new Stopwatch();
stopwatch.Start();
while (true)
{
startDownload();
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public static async void startDownload()
{
try
{
DateTime currentDay = DateTime.Now;
if (Helper.holidays.Contains(currentDay) == false)
{
List<string> markets = new List<string>() { "amex", "global", "nasdaq", "nyse" };
Parallel.ForEach(markets, async market =>
{
try
{
IEnumerable<string> symbolList = Helper.getStockSymbols(market);
var historicalGroups = symbolList.Select((x, i) => new { x, i })
.GroupBy(x => x.i / 100)
.Select(g => g.Select(x => x.x).ToArray());
Task<Dictionary<string, string>>[] historicalTasks =
historicalGroups.Select(x => Task.Run(() =>
Downloads.getHistoricalStockData(x, market)))
.ToArray();
Dictionary<string, string>[] historcalStockResults = await
Task.WhenAll(historicalTasks);
foreach (var dictionary in historcalStockResults)
{
Downloads.updateSymbolsInDB(dictionary);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
});
await Task.Delay(TimeSpan.FromHours(24));
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}

Êtes-vous après un tableau de Task<Dictionary<string, string>> ou un tableau de Dictionary<string, string>?
Aussi, ce n' Downloads.updateSymbolsInDB retour?
public static async Task<Dictionnaire<string, string>> getHistoricalStockData(string[] les symboles, la chaîne de marché) j'ai besoin de passer à la Tâche<Dictionnaire<string, string>>
Le updateSymbols méthode ressemble à ceci et retourne void public static void updateSymbolsInDB(Dictionnaire<string, string> erreurs)
Va updateSymbolsInDB exécuter pour chaque résultat de getHistoricalStockData, ou est-il censé exécuter une seule fois sur l'ensemble de tous les getHistoricalStockData résultats?
J'ai essayé de l'exécuter en une seule fois parce que je pensais que ce serait plus efficace

InformationsquelleAutor user3610374 | 2014-12-25

.net async-await c#multithreading task-parallel-library

5

Je vous conseille de ne pas utiliser ContinueWith à tous, si vous utilisez déjà await. La raison en est le niveau de verbosité vous vous retrouvez avec dans votre code.

Au lieu de cela, utiliser await lorsque cela est possible.
Le code se termine comme ça:
```
var historicalGroups = symbolList
.Select((x, i) => new { x, i })
.GroupBy(x => x.i / 100)
.Select(g => g.Select(x => x.x).ToArray());
var historicalTasks = historicalGroups.Select(x => Task.Run(() => 
Downloads.getHistoricalStockData(x, market)))
.ToArray();
var historcalStockResults = await Task.WhenAll(historicalTasks);
foreach (var dictionary in historcalStockResults)
{
Downloads.updateSymbolsInDB(dictionary);
}
```
Notez l'utilisation de Task.Run au lieu de Task.Factory.StartNew. Vous devez utiliser à la place. Plus sur que ici

Edit:

Si vous avez besoin pour exécuter ce code, une fois toutes les 24 heures, ajouter un Task.Delay et await sur elle :
```
await Task.Delay(TimeSpan.FromHours(24));
```
Edit 2:

La raison que votre code n'est pas le travail, c'est parce que startDownload est async void, et vous n'êtes pas en attente sur elle. Ainsi, votre while boucle conserve l'itération quel que soit votre Task.Delay.

Parce que vous êtes à l'intérieur d'une Application de Console, vous ne pouvez pas await parce que Main méthodes ne peux pas être asynchrone. Donc, pour contourner ce problème, modifiez startDownload être async Task au lieu de async void, et Wait sur ce qui est retourné Task. Notez que l'utilisation de Wait devrait presque jamais être utilisé, s'attendre pour les scénarios spéciaux (comme lors de l'exécution à l'intérieur d'une application console):
```
public async Task StartDownload()
```
et puis
```
while (true)
{
StartDownload().Wait();
}
```
Également noter que le mélange Parallel.Foreach et async-await n'est pas toujours la meilleure idée. Vous pouvez en lire plus sur que dans L'imbrication attendent en Parallèle.ForEach
- J'avais répondu avant j'ai bien compris ce que vous avez été au bout, donc comment ai-je répondu. Ce cependant, c'est la réponse que je vous recommande, car il se retrouve avec beaucoup plus lisible le code. Si vous avez toujours voulu seulement le seul Downloads.updateSymbolsInDB appel, vous pouvez remplacer l' foreach bloc avec la Aggregate logique comme je l'avais inclus dans ma réponse. Mais à nouveau, le profil d'abord pour voir si c'est même bénéfique.
- J'ai oublié de dire/demander une chose importante. J'ai ce code qui s'exécute dans une boucle et il est censé fonctionner de nouveau après 24 heures, mais je suis en utilisant la Tâche.Delay(Délai.FromHours(24)).Wait(); et ce n'est pas fait attendre 24 heures. Elle continue de s'exécuter le code encore et encore. Est-il une meilleure façon de gérer cela avec la méthode que vous avez mentionné?
- Pourquoi êtes-vous à l'aide de Wait? Si vous avez ce code s'exécutant dans certains while boucle, il suffit d'utiliser await Task.Delay(TimeSpan.FromHours(24));
- J'ai essayé ça aussi, mais ni l'un travaille. J'ai inséré une ligne de séparation à l'intérieur de la boucle while, et il continue d'appeler la méthode et de l'exécution du code qui n'est pas ce que je veux. Je crois attendent est un non appel de blocage jusqu'à ce qu'il continue à droite?
- Comment appelez-vous cette méthode? Ajoutez le code.
- Depuis tout ce que je suis en train de faire est de télécharger les données et de les enregistrer dans une base de données aussi rapidement que possible, je viens de coller avec TPL ou de l'utilisation TPL Dataflow ou simplement coller avec async et await avec les tâches?
- Ça dépend vraiment de l'emploi. Si vous êtes en train de faire async IO, tels que les appels de base de données, vous pouvez simplement utiliser async-await, pas besoin de thread. Si vous êtes de mélange async IO lié travailler avec les CPU de travail, je vous recommande d'utiliser TPL dataflow.
InformationsquelleAutor Yuval Itzchakov
2

Vous verrez que ContinueWith prend comme Tâche comme argument.

Aussi, de travailler par le biais de votre logique dans nos commentaires, il semble que vous devrez mettre à jour votre code. Vous essayez d'exécuter le Downloads.updateSymbolsInDB une fois sur le résultat de tous les WhenAll les tâches sont terminées. Dans votre cas, il semble que vous aurez besoin
```
await Task<Dictionary<string, string>>
.WhenAll(historicalGroups.Select(g => Task.Factory.StartNew(() => Downloads.getHistoricalStockData(g, market))))
.ContinueWith((i) => Downloads.updateSymbolsInDB(i.Result.Aggregate((agg, next) =>
{
foreach (var p in next)
{
if (!agg.ContainsKey(p.Key)) { agg.Add(p.Key, p.Value); }
}
return agg;
})));
```
Noter que j'ai aussi utilisé la Task<TResult> d'initier, de sorte que le ContinueWith est fortement typé pour fournir la Dictionary<string, string> i.Result.

Notez également que vous aurez envie de revoir ce que je fais dans la i.Result.Aggregate logique. Vous aurez besoin de mettre à jour que pour être correct pour votre cas. En outre, il peut être intéressant de revoir pour voir si il est plus efficace de simplement appeler Downloads.updateSymbolsInDB plusieurs fois, ou si le Aggregate appel est le meilleur choix.

(Dernière remarque: le résultat de fin est un void, de sorte que les attendent n'est pas affecté.)

En examen, il y avait un certain nombre de problèmes avec votre code (fait comme une déclaration, pas une accusation - n'en déplaise prévu). Vos tâches créées par le biais de Task.Factory.StartNew pour votre WhenAll méthode n'a pas de valeur de retour, donc de base Task objets, et n'étaient en fait que de jeter les résultats de la Downloads.getHistoricalStockData travail. Ensuite, votre ContinueWith nécessaire pour travailler avec la Task<TResult> de la WhenAll, où TResult sera un tableau de la valeur de retour de chaque tâche dans WhenAll.

EDIT: Comme l'a demandé comment le code peut être mis à jour si Downloads.updateSymbolsInDB devaient être appelée plusieurs fois, il pourrait simplement être fait que:
```
IEnumerable<string> symbolList = Helper.getStockSymbols(market);
var historicalGroups = symbolList.Select((x, i) => new { x, i })
.GroupBy(x => x.i / 100)
.Select(g => g.Select(x => x.x).ToArray());
Parallel.ForEach(historicalGroups, g => Downloads.updateSymbolsInDB(Downloads.getHistoricalStockData(g, market)));
```
- Ouais je pensais aussi, mais il me donne l'erreur que la Tâche ne contient pas une définition pour le Résultat
- J'ai mis à jour mon code et je suis encore en train de l'erreur que la Tâche ne contient pas une définition pour le Résultat
- Quel serait le bon code regarder comme si je voulais appeler la méthode plusieurs fois?
InformationsquelleAutor Mike Guthrie

Vous devez vous connecter pour publier un commentaire.