Comment “sommeil” jusqu'à l'expiration du délai d'annulation est demandée .NET 4.0

J'ai juste écrit un billet à ce sujet ici:

CancellationToken et du Fil.Le sommeil

en Bref:

var cancelled = token.WaitHandle.WaitOne(TimeSpan.FromSeconds(5));

Dans votre contexte:

void MyFunc (CancellationToken ct)
{
   //... 
   //simulate some long lasting operation that should be cancelable 
   var cancelled = ct.WaitHandle.WaitOne(TimeSpan.FromSeconds(10));
}

Pour annuler une opération asynchrone après un certain laps de temps tout en étant capable d'annuler l'opération manuellement, utilisez quelque chose comme ce qui suit

CancellationTokenSource cts = new CancellationTokenSource();
CancellationToken token = cts.Token;
cts.CancelAfter(5000);

Ce sera la cause d'une annulation après cinq secondes. Pour annuler l'opération de votre auto tout ce que vous avez à faire est de passer la token dans votre méthode async et l'utilisation de la token.ThrowifCancellationRequested() méthode, où vous avez mis en place un gestionnaire d'événement, quelque part au feu cts.Cancel().

Donc un exemple complet est:

CancellationTokenSource cts = new CancellationTokenSource();
CancellationToken token = cts.Token;
cts.CancelAfter(5000);

//Set up the event handler on some button.
if (cancelSource != null)
{
    cancelHandler = delegate
    {
        Cancel(cts);
    };
    stopButton.Click -= cancelHandler;
    stopButton.Click += cancelHandler;
}

//Now launch the method.
SomeMethodAsync(token);

Où stopButton est le bouton que vous avez cliquez ici pour annuler la tâche en cours d'exécution

private void Cancel(CancellationTokenSource cts)
{
    cts.Cancel();
}

et la méthode est définie comme

SomeMethodAsync(CancellationToken token)
{
    Task t = Task.Factory.StartNew(() => 
        {
            msTimeout = 5000;
            Pump(token);
        }, token,
           TaskCreationOptions.None,
           TaskScheduler.Default);
}

Maintenant, pour vous permettre de travailler le fil, mais aussi de permettre à l'utilisateur d'annulation, vous aurez besoin d'écrire un "pompage" méthode

int msTimeout;
bool timeLimitReached = false;
private void Pump(CancellationToken token)
{
    DateTime now = DateTime.Now;
    System.Timer t = new System.Timer(100);
    t.Elapsed -= t_Elapsed;
    t.Elapsed += t_Elapsed;
    t.Start();
    while(!timeLimitReached)
    {
        Thread.Sleep(250);
        token.ThrowIfCancellationRequested();
    }
}

void t_Elapsed(object sender, ElapsedEventArgs e)
{
    TimeSpan elapsed = DateTime.Now - this.readyUpInitialised;
    if (elapsed > msTimeout)
    {
        timeLimitReached = true;
        t.Stop();
        t.Dispose();
    }
}

Note, SomeAsyncMethod sera de retour droit de l'appelant. Pour bloquer l'appelant ainsi, vous aurez à déplacer le Task dans la hiérarchie d'appel.

La CancellationToken.WaitHandle peut lever une exception lors de l'accès après la CancellationTokenSource a été éliminé:

ObjectDisposedException: Le CancellationTokenSource a été disposé.

Dans certains cas, en particulier lorsque lié à l'annulation des sources sont éliminés manuellement (comme ils devraient l'être), cela peut être une nuisance.

Cette méthode d'extension permet de "safe annulation d'attente"; cependant, il doit être utilisé sur la collaboration avec les contrôles de, et le bon marquage, le jeton d'annulation de l'état et/ou de l'utilisation de la valeur de retour. C'est parce qu'il supprime les exceptions accéder à la WaitHandle et peut revenir plus vite que prévu.

internal static class CancellationTokenExtensions
{
    ///<summary>
    ///Wait up to a given duration for a token to be cancelled.
    ///Returns true if the token was cancelled within the duration
    ///or the underlying cancellation token source has been disposed.
    ///</summary>
    public static bool WaitForCancellation(this CancellationToken token, TimeSpan duration)
    {
        WaitHandle handle;
        try
        {
            handle = token.WaitHandle;
        }
        catch
        {
            //eg. CancellationTokenSource is disposed
            return true;
        }

        return handle.WaitOne(duration);
    }
}