¿Cuándo deshacerse de CancellationTokenSource?

La clase CancellationTokenSourcees desechable. Un vistazo rápido en Reflector demuestra el uso de KernelEventun recurso no administrado (muy probable). Como CancellationTokenSourceno tiene finalizador, si no lo desechamos, el GC no lo hará.

Por otro lado, si observa las muestras enumeradas en el artículo Cancelación de MSDN en Subprocesos administrados , solo un fragmento de código elimina el token.

¿Cuál es la forma correcta de deshacerse de él en código?

1. No puede ajustar el código con el que comienza su tarea paralela usingsi no lo espera. Y tiene sentido tener cancelación solo si no espera.
2. Por supuesto, puede agregar una ContinueWithtarea con una Disposellamada, pero ¿es ese el camino a seguir?
3. ¿Qué pasa con las consultas PLINQ cancelables, que no se sincronizan de nuevo, sino que simplemente hacen algo al final? Vamos a decir .ForAll(x => Console.Write(x))?
4. ¿Es reutilizable? ¿Se puede usar el mismo token para varias llamadas y luego desecharlo junto con el componente host, digamos control UI?

Debido a que no tiene algo como un Resetmétodo de limpieza IsCancelRequestedy Tokencampo, supongo que no es reutilizable, por lo tanto, cada vez que inicie una tarea (o una consulta PLINQ), debe crear una nueva. ¿Es verdad? En caso afirmativo, mi pregunta es ¿cuál es la estrategia correcta y recomendada para tratar Disposeen esos CancellationTokenSourcecasos?

Hablando sobre si es realmente necesario llamar a Dispose on CancellationTokenSource... Tuve una pérdida de memoria en mi proyecto y resultó que ese CancellationTokenSourceera el problema.

Mi proyecto tiene un servicio, que lee constantemente la base de datos y dispara diferentes tareas, y estaba pasando tokens de cancelación vinculados a mis trabajadores, por lo que incluso después de que terminaron de procesar los datos, los tokens de cancelación no se eliminaron, lo que causó una pérdida de memoria.

La cancelación de MSDN en subprocesos administrados lo establece claramente:

Tenga en cuenta que debe llamar Disposeal origen del token vinculado cuando haya terminado con él. Para un ejemplo más completo, vea Cómo: escuchar las solicitudes de cancelación múltiple .

Utilicé ContinueWithen mi implementación.

No pensé que ninguna de las respuestas actuales fuera satisfactoria. Después de investigar encontré esta respuesta de Stephen Toub ( referencia ):

Depende. En .NET 4, CTS.Dispose tenía dos propósitos principales. Si se accedió a la WaitHandle de CancellationToken (por lo tanto, la asignó perezosamente), Dispose eliminará ese controlador. Además, si el CTS se creó mediante el método CreateLinkedTokenSource, Dispose desvinculará el CTS de los tokens a los que estaba vinculado. En .NET 4.5, Dispose tiene un propósito adicional, que es si el CTS usa un Timer debajo de las cubiertas (por ejemplo, se llamó a CancelAfter), el Timer será descartado.

Es muy raro que se use CancellationToken.WaitHandle, por lo que la limpieza después de eso generalmente no es una buena razón para usar Dispose. Sin embargo, si está creando su CTS con CreateLinkedTokenSource, o si está utilizando la funcionalidad del temporizador de CTS, puede ser más impactante usar Dispose.

La parte audaz creo que es la parte importante. Él usa "más impactante", lo que lo deja un poco vago. Lo estoy interpretando como que Disposese debe hacer un llamado en esas situaciones, de lo contrario Disposeno es necesario usarlo .

Eché un vistazo en ILSpy para el, CancellationTokenSourcepero solo puedo encontrar m_KernelEventcuál es realmente una ManualResetEvent, que es una clase de contenedor para un WaitHandleobjeto. Esto debe ser manejado adecuadamente por el GC.

Siempre debes disponer CancellationTokenSource.

Cómo desecharlo depende exactamente del escenario. Propones varios escenarios diferentes.

1. usingsolo funciona cuando está utilizando CancellationTokenSourcealgún trabajo paralelo que está esperando. Si ese es tu senario, entonces genial, es el método más fácil.

2. Cuando use tareas, use una ContinueWithtarea como indicó para deshacerse de ella CancellationTokenSource.

3. Para plinq puedes usarlo usingya que lo estás ejecutando en paralelo pero esperando a que todos los trabajadores de ejecución paralela terminen.

4. Para la IU, puede crear una nueva CancellationTokenSourcepara cada operación cancelable que no esté vinculada a un solo desencadenador de cancelación. Mantenga una List<IDisposable>y agregue cada fuente a la lista, eliminándolas todas cuando se elimine su componente.

5. Para los subprocesos, cree un nuevo subproceso que se una a todos los subprocesos de trabajo y cierre la fuente única cuando finalicen todos los subprocesos de trabajo. Ver CancellationTokenSource, ¿Cuándo desechar?

Siempre hay una manera. IDisposableLas instancias siempre deben desecharse. Las muestras a menudo no lo hacen porque son muestras rápidas para mostrar el uso principal o porque agregar todos los aspectos de la clase que se está demostrando sería demasiado complejo para una muestra. La muestra es solo una muestra, no necesariamente (o incluso generalmente) el código de calidad de producción. No todas las muestras son aceptables para copiarse en el código de producción tal cual.

Esta respuesta sigue apareciendo en las búsquedas de Google, y creo que la respuesta votada no da la historia completa. Después de revisar el código fuente de CancellationTokenSource(CTS) y CancellationToken(CT), creo que para la mayoría de los casos de uso, la siguiente secuencia de código está bien:

if (cancelTokenSource != null)
{
    cancelTokenSource.Cancel();
    cancelTokenSource.Dispose();
    cancelTokenSource = null;
}

El m_kernelHandlecampo interno mencionado anteriormente es el objeto de sincronización que respalda la WaitHandlepropiedad en las clases CTS y CT. Solo se crea una instancia si accede a esa propiedad. Por lo tanto, a menos que esté utilizando WaitHandlepara algunos sincronización de hilos de la vieja escuela en su Taskdisponer de llamada no tendrá ningún efecto.

Por supuesto, si lo está utilizando, debe hacer lo que sugieren las otras respuestas anteriores y retrasar la llamada Disposehasta que WaitHandlese complete cualquier operación que use el identificador, porque, como se describe en la documentación de la API de Windows para WaitHandle , los resultados no están definidos.

Ha pasado mucho tiempo desde que pregunté esto y obtuve muchas respuestas útiles, pero me encontré con un problema interesante relacionado con esto y pensé en publicarlo aquí como otra respuesta:

Debe llamar CancellationTokenSource.Dispose()solo cuando esté seguro de que nadie intentará obtener la Tokenpropiedad del CTS . De lo contrario, usted debe no la llamas, porque es una carrera. Por ejemplo, mira aquí:

https://github.com/aspnet/AspNetKatana/issues/108

En la solución para este problema, el código que lo hizo anteriormente cts.Cancel(); cts.Dispose();fue editado solo cts.Cancel();porque cualquiera que tenga la mala suerte de intentar obtener el token de cancelación para observar su estado de cancelación después de Dispose haber sido llamado, desafortunadamente también tendrá que manejarlo ObjectDisposedException, además de OperationCanceledExceptionque estaban planeando

Tratcher hace otra observación clave relacionada con esta solución: "La eliminación solo es necesaria para los tokens que no se cancelarán, ya que la cancelación hace la misma limpieza". es decir, ¡hacer en Cancel()lugar de deshacerse es bastante bueno!

Hice una clase segura para subprocesos que une a CancellationTokenSourcea Task, y garantiza que CancellationTokenSourcese eliminará cuando se Taskcomplete su asociado . Utiliza cerraduras para garantizar que CancellationTokenSourceno se cancele durante o después de que se haya eliminado. Esto sucede para cumplir con la documentación , que establece:

El Disposemétodo solo debe usarse cuando se CancellationTokenSourcehayan completado todas las demás operaciones en el objeto.

Y también :

El Disposemétodo deja el CancellationTokenSourceen un estado inutilizable.

Aquí está la clase:

public class CancelableExecution
{
    private readonly bool _allowConcurrency;
    private Operation _activeOperation;

    private class Operation : IDisposable
    {
        private readonly object _locker = new object();
        private readonly CancellationTokenSource _cts;
        private readonly TaskCompletionSource<bool> _completionSource;
        private bool _disposed;

        public Task Completion => _completionSource.Task; // Never fails

        public Operation(CancellationTokenSource cts)
        {
            _cts = cts;
            _completionSource = new TaskCompletionSource<bool>(
                TaskCreationOptions.RunContinuationsAsynchronously);
        }
        public void Cancel()
        {
            lock (_locker) if (!_disposed) _cts.Cancel();
        }
        void IDisposable.Dispose() // Is called only once
        {
            try
            {
                lock (_locker) { _cts.Dispose(); _disposed = true; }
            }
            finally { _completionSource.SetResult(true); }
        }
    }

    public CancelableExecution(bool allowConcurrency)
    {
        _allowConcurrency = allowConcurrency;
    }
    public CancelableExecution() : this(false) { }

    public bool IsRunning =>
        Interlocked.CompareExchange(ref _activeOperation, null, null) != null;

    public async Task<TResult> RunAsync<TResult>(
        Func<CancellationToken, Task<TResult>> taskFactory,
        CancellationToken extraToken = default)
    {
        var cts = CancellationTokenSource.CreateLinkedTokenSource(extraToken, default);
        using (var operation = new Operation(cts))
        {
            // Set this as the active operation
            var oldOperation = Interlocked.Exchange(ref _activeOperation, operation);
            try
            {
                if (oldOperation != null && !_allowConcurrency)
                {
                    oldOperation.Cancel();
                    await oldOperation.Completion; // Continue on captured context
                }
                var task = taskFactory(cts.Token); // Run in the initial context
                return await task.ConfigureAwait(false);
            }
            finally
            {
                // If this is still the active operation, set it back to null
                Interlocked.CompareExchange(ref _activeOperation, null, operation);
            }
        }
    }

    public Task RunAsync(Func<CancellationToken, Task> taskFactory,
        CancellationToken extraToken = default)
    {
        return RunAsync<object>(async ct =>
        {
            await taskFactory(ct).ConfigureAwait(false);
            return null;
        }, extraToken);
    }

    public Task CancelAsync()
    {
        var operation = Interlocked.CompareExchange(ref _activeOperation, null, null);
        if (operation == null) return Task.CompletedTask;
        operation.Cancel();
        return operation.Completion;
    }

    public bool Cancel() => CancelAsync() != Task.CompletedTask;
}

Los métodos principales de la CancelableExecutionclase son el RunAsyncy el Cancel. Por defecto, las operaciones concurrentes no están permitidas, lo que significa que llamarRunAsync por segunda vez se cancelará silenciosamente y esperará la finalización de la operación anterior (si aún se está ejecutando), antes de comenzar la nueva operación.

Esta clase se puede usar en aplicaciones de cualquier tipo. Sin embargo, su uso principal es en aplicaciones de IU, dentro de formularios con botones para iniciar y cancelar una operación asincrónica, o con un cuadro de lista que cancela y reinicia una operación cada vez que se cambia su elemento seleccionado. Aquí hay un ejemplo del primer caso:

private readonly CancelableExecution _cancelableExecution = new CancelableExecution();

private async void btnExecute_Click(object sender, EventArgs e)
{
    string result;
    try
    {
        Cursor = Cursors.WaitCursor;
        btnExecute.Enabled = false;
        btnCancel.Enabled = true;
        result = await _cancelableExecution.RunAsync(async ct =>
        {
            await Task.Delay(3000, ct); // Simulate some cancelable I/O operation
            return "Hello!";
        });
    }
    catch (OperationCanceledException)
    {
        return;
    }
    finally
    {
        btnExecute.Enabled = true;
        btnCancel.Enabled = false;
        Cursor = Cursors.Default;
    }
    this.Text += result;
}

private void btnCancel_Click(object sender, EventArgs e)
{
    _cancelableExecution.Cancel();
}

El RunAsyncmétodo acepta un extra CancellationTokencomo argumento, que está vinculado a lo creado internamente CancellationTokenSource. El suministro de este token opcional puede ser útil en escenarios avanzados.