public void Close()
{
_cts?.Cancel();
_cts?.Dispose();
_channel?.Writer.Complete();
try
{
_udp.Close();
}
catch { }
}
public async ValueTask ConnectAsync(Uri url, CancellationToken token)
{
ThrowIfDisposed();
_limboCts?.Cancel();
_limboCts?.Dispose();
_limboCts = new Cts();
_ws?.Dispose();
_ws = _webSocketClientFactory.CreateClient();
if (_supportsZLib)
{
_receiveZLibStream?.Dispose();
_receiveZLibStream = _createZLibStream(_receiveStream);
}
await _ws.ConnectAsync(url, token).ConfigureAwait(false);
}
private async void OnSearchTextChangedEvent(object sender, EventArgs e, object paramaters)
{
var model = (CustomerManagementPageViewModel)ParentsModel;
if (model.IsDataGridLoading)
{
if (Cts != null)
{
Cts.Cancel();
}
}
model.IsDataGridLoading = true;
if (customerDGCache == null)
{
customerDGCache = (DataGrid)((object[])paramaters)[0];
}
TextBox ctrl = (TextBox)sender;
await Task.Delay(100);
if (Cts == null)
{
Cts = new CancellationTokenSource();
}
var ct = Cts.Token;
try
{
await Task.Delay(model.DelayTextChangedHandler, ct);
customerDGCache.Items.Filter = new Predicate <object>(customer => FilterCustomerList(customer as tblCustomer, ctrl.Text));
model.IsDataGridLoading = false;
}
catch (OperationCanceledException ex)
{
if (Cts != null)
{
Cts.Dispose();
}
Cts = null;
}
}
public async Task ShouldCancelWaiting(SemaphoreSlimLock sut)
{
var mutex = GetSemaphore(sut);
await sut.WaitAsync(Cts.Token);
var second = sut.WaitAsync(Cts.Token);
await Wait();
Assert.False(second.IsCompleted);
Assert.Equal(0, mutex.CurrentCount);
Cts.Cancel();
await AssertThrowsAsync <OperationCanceledException>(
() => second);
Assert.True(second.IsCanceled);
Assert.Equal(0, mutex.CurrentCount);
}
public async Task ShouldWaitForMessageUntilCanceled(
[Frozen] Mock <IConnectionInitializer> initializer,
ConnectionHandler sut)
{
var connection = new TestConnection();
initializer.Setup(x => x.ConnectAsync(connection, Cts.Token))
.ReturnsAsync(Create <ConnectedClient>(
new ClientWithConnectionBuilder(connection)));
var result = sut.HandleAsync(connection, Cts.Token);
await Wait();
Assert.False(result.IsCompleted);
Cts.Cancel();
await Assert.ThrowsAsync <OperationCanceledException>(() => result);
}
private void GenerateNumbers()
{
CancellationToken token = Cts.Token;
try
{
Console.WriteLine("Start generating numbers");
for (int i = 0; i < BUFFER_SIZE; i++)
{
if (token.IsCancellationRequested)
{
break;
}
decimal percent = ((i / (decimal)BUFFER_SIZE) * 100);
if (percent % 1 == 0)
{
Console.WriteLine(" Generating " + (int)percent + "%");
}
int i2 = i;
Output.Add(new SeqObject <int>()
{
SeqId = i2, Value = i2
}, token);
}
Console.WriteLine("Finished generating numbers");
}
catch (Exception ex)
{
Console.WriteLine("Generating numbers failed");
if (!(ex is OperationCanceledException))
{
Cts.Cancel();
throw;
}
}
finally
{
Output.CompleteAdding();
}
}
private void BtnStop_Click(object sender, EventArgs e)
{
mrEvent.Set(); // Если останавливаем с паузы
Cts.Cancel();
timer.Stop();
CurrentState.IsPauseEnabled = false;
CurrentState.IsStartEnabled = true;
CurrentState.IsStopEnabled = false;
CurrentState.IsOpenFolderEnabled = true;
if (t.Status == TaskStatus.Running)
{
Task t2 = t.ContinueWith((t) => CurrentState.SetDefault(mainDispatcher));
}
else
{
CurrentState.SetDefault(mainDispatcher);
tvFilesFound.Nodes.Clear();
}
mrEvent.Reset();
timer.Dispose();
}
public void Dispose()
{
Cts.Cancel();
TcpListener?.Stop();
if (_hotTasks != null)
{
lock (_lock)
{
_hotTasks.Clear();
}
}
if (_clients != null)
{
foreach (var c in _clients)
{
c.Dispose();
}
}
}
public async ValueTask ConnectAsync(Uri url, CancellationToken token)
{
ThrowIfDisposed();
_limboCts?.Cancel();
_limboCts?.Dispose();
_limboCts = new Cts();
_ws?.Dispose();
_ws = _webSocketClientFactory.CreateClient();
if (_supportsZLib)
{
_receiveZLibStream?.Dispose();
_receiveZLibStream =
#if NET5_0
CreateZLibStream(_receiveStream);
#else
new ZLibStream(_receiveStream, CompressionMode.Decompress, true);
#endif
}
await _ws.ConnectAsync(url, token).ConfigureAwait(false);
}
public virtual void Stop()
{
try
{
ThrowIfDisposed();
lock (lockable)
{
if (State == AgentState.Running)
{
State = AgentState.StopRequested;
Cts.Cancel();
State = AgentState.Stopped;
}
}
}
catch (Exception exc)
{
// ignore. Just make sure stop does not throw.
Log.Debug("Ignoring error during Stop: {0}", exc);
}
Log.Debug("Stopped agent");
}
public async Task WhenAll_ShouldCancel(bool isAsynchronous)
{
var canceled1 = new ValueTask(Task.FromCanceled(new CancellationToken(true)));
var canceled2 = new ValueTask(Task.FromCanceled(new CancellationToken(true)));
var running1 = new ValueTask(Task.Delay(Timeout.Infinite, Cts.Token));
var running2 = new ValueTask(Task.Delay(Timeout.Infinite, Cts.Token));
var result = isAsynchronous
? AsyncHelpers.WhenAll(new[] { canceled1, running1, running2 })
: AsyncHelpers.WhenAll(new[] { canceled1, canceled2 });
if (isAsynchronous)
{
await Wait();
Assert.False(result.IsCompleted);
Cts.Cancel();
}
await AssertThrowsAsync <TaskCanceledException>(() => result);
Assert.True(result.IsCanceled);
}
public async Task ShouldCancelOnReceive()
{
var waiting = _sut.ReceiveAsync(Cts.Token);
await Wait();
Assert.False(waiting.IsCompleted);
Assert.Equal(TestLock.State.Started, _receiveLock.WaitState);
Assert.Equal(TestLock.State.None, _receiveLock.ReleaseState);
Assert.Equal(TestLock.State.None, _sendLock.WaitState);
Assert.Equal(TestLock.State.None, _sendLock.ReleaseState);
_connection.Verify(x => x.ReceiveAsync(Cts.Token), Times.Never);
Cts.Cancel();
await Wait();
Assert.True(waiting.IsCanceled);
Assert.Equal(TestLock.State.Canceled, _receiveLock.WaitState);
Assert.Equal(TestLock.State.None, _receiveLock.ReleaseState);
Assert.Equal(TestLock.State.None, _sendLock.WaitState);
Assert.Equal(TestLock.State.None, _sendLock.ReleaseState);
_connection.Verify(x => x.ReceiveAsync(Cts.Token), Times.Never);
}
/// <summary>
/// This method is used to cancel the task.
/// </summary>
public void Cancel()
{
if (IsCancelled)
{
return;
}
CancelledTime = DateTime.UtcNow;
IsCancelled = true;
Cts.Cancel();
try
{
if (Callback != null && !string.IsNullOrEmpty(CallbackId))
{
Callback.TimeoutTaskManager(CallbackId);
}
}
catch (Exception)
{
}
}
public void Reset()
{
lock (this)
{
_resetCts?.Cancel();
_resetCts?.Dispose();
var currentCount = _semaphore.CurrentCount;
var releaseCount = _limit - currentCount;
try
{
if (releaseCount != 0)
{
_semaphore.Release(releaseCount);
_logger.LogDebug("Reset the semaphore: {0} -> {1}.", currentCount, _limit);
}
}
finally
{
_isResetting = false;
}
}
}
public async Task ShouldUnsubscribeAfterCancellation(
[Frozen] Notificator notificator,
NotificatorConnection sut)
{
int GetSubscriptionCount()
{
return((typeof(Notificator)
.GetField(nameof(Notificator.Received), BindingFlags.Instance | BindingFlags.NonPublic)?
.GetValue(notificator) as Action)?.GetInvocationList()?.Length ?? 0);
}
Assert.Equal(0, GetSubscriptionCount());
var result = sut.ReceiveAsync(Cts.Token);
await Wait();
Assert.Equal(1, GetSubscriptionCount());
Cts.Cancel();
await SwallowAnyAsync(result.AsTask());
Assert.Equal(0, GetSubscriptionCount());
}
public void Stop( )
{
Logger.Info("Stopping Bot");
fiatMonitor?.Stop( );
Cts?.Cancel( );
}
public Task <ActionResult> ShutdownAsync()
=> Ok($"Goodbye! {DiscordHelper.Wave}", async _ =>
{
await Task.Yield();
Cts.Cancel();
});
public override void Cancel()
{
Cts.Cancel();
}
public void CancelAsync()
{
Cts?.Cancel(false);
}
public ValueTask CloseAsync(CancellationToken cancellationToken = default)
{
_cts?.Cancel();
_cts?.Dispose();
_socket.Close();
return(default);
void ICommand.Execute(object parameter)
{
Cts.Cancel();
RaiseCanExecuteChanged();
}
public Task <ActionResult> ShutdownAsync()
=> Ok($"Goodbye! {EmojiService.Wave}", _ =>
{
Cts.Cancel();
return(Task.CompletedTask);
});
/// <summary>
/// <para>
/// Cancels the thread by calling Cancel on the CancellationTokenSource. The value should be checked in the code in the specified Action parameter.
/// </para>
/// </summary>
public virtual void Cancel()
{
Cts.Cancel();
}
private static void Console_CancelKeyPress(object sender, ConsoleCancelEventArgs e)
{
Info("Ctrl-C pressed. Exiting.");
Cts.Cancel();
Exit(ExitResult.SUCCESS);
}
/// <inheritdoc/>
public void Dispose()
{
_cts.Cancel();
_cts.Dispose();
}
public async Task ParseAsync()
{
await Task.Factory.StartNew(Parse).ContinueWith((x) => Cts.Cancel());
}
public void Dispose()
{
Cts.Cancel();
Cts.Dispose();
}
/// <inheritdoc/>
public void Dispose()
{
_cts.Cancel();
_cts.Dispose();
GC.SuppressFinalize(this);
}
/// <summary>
/// 停止或暂停下载
/// </summary>
public void CancelAsync()
{
Package.Status = DownloadStatus.Pause;
Cts?.Cancel(false);
}
/// <inheritdoc/>
public virtual void Dispose()
{
_cts?.Cancel();
_cts?.Dispose();
}
