[C#] CancellationTokenSource를 언제 처분해야합니까?

a CancellationTokenSource에 a 를 바인딩하는 스레드 안전 클래스를 만들었 으며 관련 완료 시 처리가 처리되도록 Task보장합니다 . 잠금을 사용하여 폐기 중 또는 폐기 후 취소되지 않도록합니다. 이것은 다음과 같은 문서 를 준수하기 위해 발생합니다 .CancellationTokenSourceTaskCancellationTokenSource

이 Dispose방법은 CancellationTokenSource객체의 다른 모든 작업 이 완료된 경우에만 사용해야합니다 .

그리고 또한 :

이 Dispose방법 CancellationTokenSource은 사용할 수없는 상태로 유지됩니다.

수업은 다음과 같습니다.

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

CancelableExecution클래스 의 주요 메소드 는 RunAsync및 Cancel입니다. 기본적으로 동시 작업은 허용되지 않습니다. 즉,RunAsync , 새 작업을 시작하기 전에 다시 하면 이전 작업 (아직 실행중인 경우)이 자동으로 취소되고 대기합니다.

이 클래스는 모든 종류의 응용 프로그램에서 사용할 수 있습니다. 기본 사용법은 UI 응용 프로그램, 비동기 작업을 시작 및 취소하는 단추가있는 양식 또는 선택한 항목이 변경 될 때마다 작업을 취소했다가 다시 시작하는 목록 상자입니다. 첫 번째 사례는 다음과 같습니다.

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

이 RunAsync메소드는 extra CancellationToken를 인수로 받아들이며 내부적으로 작성된에 연결됩니다 CancellationTokenSource. 이 선택적 토큰을 제공하는 것은 고급 시나리오에서 유용 할 수 있습니다.

---