मैंने एक थ्रेड-सुरक्षित वर्ग बनाया, जो एक CancellationTokenSourceको बांधता है Task, और यह गारंटी देता है कि CancellationTokenSourceजब इसका संबद्ध Taskपूरा हो जाएगा तो इसका निपटान कर दिया जाएगा । यह यह सुनिश्चित करने के लिए लॉक का उपयोग करता है कि CancellationTokenSourceइसे रद्द करने के दौरान या बाद में रद्द नहीं किया जाएगा। यह प्रलेखन के अनुपालन के लिए होता है , जो बताता है:
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 दूसरी बार करने से नया ऑपरेशन शुरू करने से पहले चुपचाप रद्द कर दिया जाएगा और पिछले ऑपरेशन के पूरा होने का इंतजार करेगा (यदि यह अभी भी चल रहा है)।
इस वर्ग का उपयोग किसी भी प्रकार के अनुप्रयोगों में किया जा सकता है। यूआई अनुप्रयोगों में इसका प्राथमिक उपयोग हालांकि, एक अतुल्यकालिक ऑपरेशन को शुरू करने और रद्द करने के लिए बटन के साथ रूपों में होता है, या एक सूची बॉक्स के साथ रद्द करता है और हर बार उसके चयनित आइटम को बदलने के लिए एक ऑपरेशन को रद्द और पुनरारंभ करता है। यहाँ पहले मामले का एक उदाहरण है:
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विधि एक अतिरिक्त स्वीकार करता है CancellationTokenतर्क है कि करने के लिए आंतरिक रूप से बनाई गई जुड़ा हुआ है के रूप में CancellationTokenSource। इस वैकल्पिक टोकन की आपूर्ति अग्रिम परिदृश्यों में उपयोगी हो सकती है।