c# - cancellationtoken - Cómo "dormir" hasta que se solicite el tiempo de espera o la cancelación en.NET 4.0

cancel task run c#

Question

¿Cuál es la mejor manera de dormir una cierta cantidad de tiempo, pero ser capaz de ser interrumpido por un IsCancellationRequested de un CancellationToken ?

Estoy buscando una solución que funcione en .NET 4.0.

Me gustaría escribir

void MyFunc (CancellationToken ct)
{
//...
// simulate some long lasting operation that should be cancelable
Thread.Sleep(TimeSpan.FromMilliseconds(10000), ct);
}

Answer 1

Acabo de escribir en un blog sobre esto aquí:

CancelaciónToken and Thread.Sleep

en breve:

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

En tu contexto:

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

Answer 2

Alternativamente, creo que esto es bastante claro:

Task.Delay(waitTimeInMs, cancellationToken).Wait(cancellationToken);

Answer 3

La mejor solución que encontré hasta ahora es:

void MyFunc(CancellationToken ct)
{
//...
var timedOut = WaitHandle.WaitAny(new[] { ct.WaitHandle }, TimeSpan.FromMilliseconds(2000)) == WaitHandle.WaitTimeout;
var cancelled = ! timedOut;
}

ACTUALIZAR:

La mejor solución hasta ahora es la respuesta aceptada .

Answer 4

Para cancelar una operación asincrónica después de un cierto período de tiempo sin dejar de cancelar la operación manualmente, use algo como lo siguiente

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

Esto causará una cancelación después de cinco segundos. Para cancelar la operación, todo lo que tiene que hacer es pasar el token a su método asíncrono y usar el método token.ThrowifCancellationRequested() , donde ha configurado un controlador de eventos en algún lugar para cts.Cancel() .

Entonces un ejemplo completo es:

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);

Donde stopButton es el botón en el que hace clic para cancelar la tarea en ejecución

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

y el método se define como

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

Ahora, para permitirle trabajar con el hilo pero también habilitar la cancelación del usuario, tendrá que escribir un método de "bombeo"

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();
}
}

Tenga en cuenta que SomeAsyncMethod volverá directamente a la persona que llama. Para bloquear a la persona que llama también tendrá que mover la Task hacia arriba en la jerarquía de llamadas.