Comment utiliseriez-vous quelque chose qui fonctionne de la même manière que l'ASYNC CTP AWAIT Mot-clé? Existe-t-il une simple implémentation qui fonctionne comme attendre dans tous les cas ou attendre nécessite des implémentations différentes pour différents scénarios?
6 Réponses :
C'est possible que mon utilisation de blocs d'itérateur (rendement de rendement), vous pouvez simuler quelque chose de similaire ... mais ce serait assez moche.
J'ai donné un webinaire DEVEXPRESSION sur ce que le compilateur fait dans les coulisses il y a quelques semaines - Cela montre un code décompilé d'un couple d'exemples, ainsi que de l'explication de la manière dont le compilateur construit une tâche à retourner et à faire le "AWAITER". Cela peut vous être utile. attendre implique toujours le même type de transformation - mais c'est une assez douloureuse. La bibliothèque du côté attendre n'est pas trop compliquée, mais le bit tressant est que le compilateur construit une machine à états pour vous, permettant ainsi à la suite de revenir au bon endroit .
Vous pouvez trouver Webinar Jon mentionné sur YouTube ici: YouTube.com/watch?v=HPA2X_JVLD4
Il y a peu de mises en œuvre et d'exemples de coroutine fabriquées à partir d'itérateurs (rendement).
Un des exemples est Caliburn.Micro Framework, qui utilise ce type pour les opérations d'interface graphone asynchrones. Mais il peut facilement être généralisé pour le code général ASYNC.
the MindTouch Dream Framework implémente les coroutines sur le motif itérateur qui est fonctionnellement très similaire à ASYNC / Attendre: vs. résultat est la version de Dream de de la tâche . Le cadre DLLS fonctionne avec .NET 2.0+, mais pour le construire, vous avez besoin de 3.5, puisque nous utilisons beaucoup de syntaxe de 3,5 de nos jours.
Le nouveau Voici ce dont on ressemblerait. P> attendre code> Le mot-clé a une sémantique similaire à la déclaration de rendement code> existante code> en ce sens qu'elles provoquent tous les deux le compilateur de générer la machine d'état de style de continuation pour vous. Il est donc possible de pirater quelque chose en utilisant des itérateurs qui possèdent certains des mêmes comportements que l'ASYNC CTP. public static class AsyncHelper
{
public static Task<T> Invoke<T>(Func<TaskCompletionSource<T>, IEnumerable<Task>> method)
{
var context = SynchronizationContext.Current;
var tcs = new TaskCompletionSource<T>();
var steps = method(tcs);
var enumerator = steps.GetEnumerator();
bool more = enumerator.MoveNext();
Task.Factory.StartNew(
() =>
{
while (more)
{
enumerator.Current.Wait();
if (context != null)
{
context.Send(
state =>
{
more = enumerator.MoveNext();
}
, null);
}
else
{
enumerator.MoveNext();
}
}
}).ContinueWith(
(task) =>
{
if (!tcs.Task.IsCompleted)
{
tcs.SetResult(default(T));
}
});
return tcs.Task;
}
}
de ma lecture, les principales différences entre alors que avec retour de rendement code> et attendre code> sont que attendre code> peut fournir explicitement une nouvelle valeur dans la continuation. retour de rendement code>, vous devez accomplir la même chose par référence. P> var asyncOperationHandle = GetMeSomeValueRequest();
yield return asyncOperationHandle;
var someValue = (SomeValue)asyncOperationHandle.Result;
Bill Wagner de Microsoft a écrit Un article dans MSDN Magazine sur comment Vous pouvez utiliser la bibliothèque parallèle de tâche dans Visual Studio 2010 pour mettre en œuvre un comportement comme ASYNC, sans ajouter de dépendance sur l'ASYNC CTP.
Il utilise Task et Task async et attendre .
Je viens de publier un article sur la façon de attendre des tâches en C # 4 Utilisation d'itérateurs . Étonnamment, ce n'est ni «hacky» ni très laid, et Afaict fonctionne comme attendre. Vérifiez-le!