Comment puis-je obtenir l'équivalent de la Tâche<T>.net 3.5?

Bien que le code que j'ai montré arrive à être un temps de retard, mon
l'utilisation n'est pas limitée à retarder les choses. Il peut y avoir d'autres cas où
Je veux commencer un peu de 'long' interrogation tâche immédiatement. Un
situation typique serait un I/O bound opération, par exemple
quelque chose de l'périodiquement des requêtes d'un périphérique connecté à la série
port, puis déclenche un événement lorsque certaines conditions sont réunies.

Un notable et pratique hack pour le codage de tels scénarios avec C# 2.0 - 4.0 est d'utiliser auto-piloté IEnumerable et yield. Il permet de mettre en œuvre un asynchrone machine d'état, semblable à async/await de C# 5.0. De cette façon, vous gardez la pratique linéaire flux de code pour votre logique asynchrone. Tout langage C# code de contrôle des déclarations de travaux (d'ailleurs vous ne pouvez pas faire yield return de l'intérieur try/catch).

Par exemple, une application de console avec un minuteur:

using System;
using System.Collections;
using System.Threading;

namespace ConsoleApplication_22516303
{
    class Program
    {
        class AsyncLogic
        {
            public EventHandler Completed = delegate { };

            IEnumerable WorkAsync(Action nextStep)
            {
                using (var timer = new System.Threading.Timer(_ => nextStep()))
                {
                    timer.Change(0, 500);

                    var tick = 0;
                    while (tick < 10)
                    {
                        //resume upon next timer tick
                        yield return Type.Missing;
                        Console.WriteLine("Tick: " + tick++);
                    }
                }

                this.Completed(this, EventArgs.Empty);
            }

            public void Start()
            {
                IEnumerator enumerator = null;
                Action nextStep = () => enumerator.MoveNext();
                enumerator = WorkAsync(nextStep).GetEnumerator();
                nextStep();
            }
        }

        static void Main(string[] args)
        {
            var mre = new ManualResetEvent(false);
            var asyncLogic = new AsyncLogic();
            asyncLogic.Completed += (s, e) => mre.Set();
            asyncLogic.Start();
            mre.WaitOne();
            Console.WriteLine("Completed, press Enter to exit");
            Console.ReadLine();
        }
    }
}

Tout événement pourrait être emballé avec un gestionnaire qui appellent nextStep, semblables à celles de la minuterie de rappel. Le code devrait continuer après le correspondant yield return, lors de l'événement.

Il y a quelques implémentations de prendre avantage de cette approche, par exemple, Jeffrey Richter AsyncEnumerator.

OriginalL'auteur noseratio

Utiliser un Timer (qui est en fait comment Delay est mis en œuvre en interne).

private static HashSet<Timer> timers = new HashSet<Timer>();
public static void ExecuteAfter(Action action, TimeSpan delay)
{
    Timer timer = null;
    timer = new System.Threading.Timer(s =>
    {
        action();
        timer.Dispose();
        lock (timers)
            timers.Remove(timer);
    }, null, (long)delay.TotalMilliseconds, Timeout.Infinite);
    lock (timers)
        timers.Add(timer);
}

À votre travail d'édition, si vous utilisez une application asynchrone construit sur asynchrones IO, alors que asynchrone IO déjà exposer une méthode d'asynchronie. Il pourrait être un cas de base du modèle, elle pourrait accepter un rappel, il pourrait être à l'aide de IAsyncResult, etc. Task est encore une autre approche possible pour la programmation asynchrone, et vous êtes certainement capable de traduire n'importe quel approche à toute autre approche, si l'une est préférable pour vous, mais en général, les gens ont tendance à coller avec n'importe quelle méthode de la sous-jacentes IO qu'ils effectuent les utilisations, sauf s'ils ont une raison impérieuse de le faire autrement.

OriginalL'auteur Servy

Utilisation de pool de threads pour exécuter la méthode:

http://msdn.microsoft.com/en-us/library/kbf0f1ct(v=vs. 110).aspx

Modifier pour Servy:

La valeur par défaut du planificateur de Tâches en Parallèle de la Bibliothèque et PLINQ utilise le .NET Framework pool de threads pour la file d'attente et l'exécution de travaux. Dans l' .NET Framework 4, le pool de threads utilise les informations fournies par le Système.Le filetage.Les tâches.Type de tâche de soutenir efficacement le parallélisme à grain extrêmement fin (à court terme des unités de travail) que les tâches parallèles et des requêtes représentent souvent.

Edit 2(à cause de la rétroaction négative):

Ce code fait exactement ce que l'OP veut:

    void ReturnResponseAfterAShortDelay(WaitHandle cancellationToken)
    {
        log.InfoFormat("Deferring response for {0} ms", Settings.Default.TimeoutMs);
        ThreadPool.RegisterWaitForSingleObject(cancellationToken, 
            () => 
            {
                if (!cancellationToken.WaitOne(0))
                {
                    ReturnWhateverHasArrived();
                }
            }, 
            null, Settings.Default.TimeoutMs, true);
    }

OriginalL'auteur Bogdan