private static void Main(string[] args) { CancellationTokenSource cts = new CancellationTokenSource(); Console.CancelKeyPress += (sender, e) => { e.Cancel = true; cts.Cancel(); }; // Since Console apps do not have a SyncronizationContext, we're leveraging the built-in support // in WPF to pump the messages via the Dispatcher. // See the following for additional details: // http://blogs.msdn.com/b/pfxteam/archive/2012/01/21/10259307.aspx // https://github.com/DotNetAnalyzers/StyleCopAnalyzers/pull/1362 SynchronizationContext previousContext = SynchronizationContext.Current; try { var context = new DispatcherSynchronizationContext(); SynchronizationContext.SetSynchronizationContext(context); DispatcherFrame dispatcherFrame = new DispatcherFrame(); Task mainTask = MainAsync(args, cts.Token); mainTask.ContinueWith(task => dispatcherFrame.Continue = false); Dispatcher.PushFrame(dispatcherFrame); mainTask.GetAwaiter().GetResult(); } finally { SynchronizationContext.SetSynchronizationContext(previousContext); } }
public void Dulicate_message_is_detected() { var builder = new CqrsEngineBuilder(); builder.Memory(m => { m.AddMemorySender("in", s => s.IdGenerator(() => "same")); m.AddMemoryRouter("in", c => "memory:null"); }); var observer = new ImmediateEventsObserver(); builder.Advanced.RegisterObserver(observer); using (var token = new CancellationTokenSource()) using (var build = builder.Build()) { var sender = build.Resolve<IMessageSender>(); sender.SendOne(new Message()); sender.SendOne(new Message()); observer.Event += @event => { var e = @event as EnvelopeDuplicateDiscarded; if (e != null) { token.Cancel(); } }; build.Start(token.Token); token.Token.WaitHandle.WaitOne(10000); Assert.IsTrue(token.IsCancellationRequested); } }
public void Start(Func<Task> callback, TimeSpan? interval, Action<Exception> errorCallback) { tokenSource = new CancellationTokenSource(); var token = tokenSource.Token; task = Task.Run(async () => { while (!token.IsCancellationRequested) { try { if (interval.HasValue) { await Task.Delay(interval.Value, token).ConfigureAwait(false); } else { tokenSource.Cancel(); } await callback().ConfigureAwait(false); } catch (OperationCanceledException) { // nop } catch (Exception ex) { errorCallback(ex); } } }, CancellationToken.None); }
public static IYubicoResponse Validate(IEnumerable<string> urls, string userAgent) { var tasks = new List<Task<IYubicoResponse>>(); var cancellation = new CancellationTokenSource(); foreach (var url in urls) { var thisUrl = url; var task = new Task<IYubicoResponse>(() => DoVerify(thisUrl, userAgent), cancellation.Token); task.ContinueWith(t => { }, TaskContinuationOptions.OnlyOnFaulted); tasks.Add(task); task.Start(); } while (tasks.Count != 0) { // TODO: handle exceptions from the verify task. Better to be able to propagate cause for error. var completed = Task.WaitAny(tasks.Cast<Task>().ToArray()); var task = tasks[completed]; tasks.Remove(task); if (task.Result != null) { cancellation.Cancel(); return task.Result; } } return null; }
public Task SearchAsync(string searchPattern, FileSearchMode mode, int count, IFileCollection files, CancellationToken cancellationToken) { if (String.IsNullOrEmpty(searchPattern)) { files.Clear(); foreach (string filePath in pinStateService.GetList()) files.Add(Path.GetFileNameWithoutExtension(filePath), filePath, true); if (lastCancellation != null) { lastCancellation.Cancel(); lastCancellation = null; } return Task.FromResult(true); } if (cancellationToken.IsCancellationRequested) return Async.CompletedTask; lastCancellation = new CancellationTokenSource(); cancellationToken.Register(() => lastCancellation.Cancel()); Task result = innerService.SearchAsync(searchPattern, mode, count, files, lastCancellation.Token); return result; }
static void testCancellation() { IEnumerable<int> million = Enumerable.Range (3, 1000000); var cancelSource = new CancellationTokenSource(); var primeNumberQuery = from n in million.AsParallel().WithCancellation (cancelSource.Token) where Enumerable.Range (2, (int) Math.Sqrt (n)).All (i => n % i > 0) select n; new Thread (() => { Thread.Sleep (100); // Cancel query after cancelSource.Cancel(); // 100 milliseconds. }).Start(); try { // Start query running: int[] primes = primeNumberQuery.ToArray(); // We'll never get here because the other thread will cancel us. } catch (OperationCanceledException) { Console.WriteLine("Query canceled"); } }
public void Run() { while (true) { var fetch = CommonTasks.ExecuteScript("Crawlers\\Scripts\\Bicing.js"); var parse = fetch.ContinueWith<Tuple<Station, NameValueCollection>[]>(Parse, TaskContinuationOptions.OnlyOnRanToCompletion | TaskContinuationOptions.ExecuteSynchronously); var store = parse.ContinueWith(Store, TaskContinuationOptions.OnlyOnRanToCompletion); try { Task.WaitAll(fetch, parse, store); } catch (AggregateException e) { e.Handle(x => { System.Console.WriteLine(x.Message); return true; }); } CancellationTokenSource source = new CancellationTokenSource(); Task.Factory.StartNew(() => StationLoop(parse.Result), source.Token); Thread.Sleep(TimeSpan.FromHours(12)); source.Cancel(); } }
public async void ReloadServerList() { BeginLoading(); _reloadingCts.Cancel(); var oldsrc = _reloadingCts; _reloadingCts = new System.Threading.CancellationTokenSource(); CancellationToken token = _reloadingCts.Token; oldsrc.Cancel(false); try { await Task.Factory.StartNew(o => ReloadInternal((CancellationToken)o), token, token). ContinueWith(t => { if (t.Status == TaskStatus.RanToCompletion) { RememberLastVisiblyItems(); } }); } catch (Exception) { // ignored } EndLoading(); }
/// <inheritdoc/> protected override Task RunTestsAsync(IMessageBus messageBus, object[] constructorArguments, ExceptionAggregator aggregator, CancellationTokenSource cancellationTokenSource) { if (!messageBus.QueueMessage(new TestStarting(this, DisplayName))) cancellationTokenSource.Cancel(); else { try { lambda(); if (!messageBus.QueueMessage(new TestPassed(this, DisplayName, 0, null))) cancellationTokenSource.Cancel(); } catch (Exception ex) { if (!messageBus.QueueMessage(new TestFailed(this, DisplayName, 0, null, ex))) cancellationTokenSource.Cancel(); } } if (!messageBus.QueueMessage(new TestFinished(this, DisplayName, 0, null))) cancellationTokenSource.Cancel(); return Task.FromResult(0); }
/// <summary> /// /// </summary> /// <param name="connection">the connection to monitor for messages</param> /// <param name="cts">cancellation token to cancel on error or no data received</param> /// <param name="timeout">timeout to wait for messages</param> public NMSConnectionMonitor(IConnection connection, CancellationTokenSource cts, TimeSpan? timeout = null) { QuitOk = true; connection.ExceptionListener += (e) => { Trace.TraceError("Connection error: {0}", e); QuitOk = false; cts.Cancel(); }; if (timeout.HasValue) { _timer = new Timer((state) => { if (!connection.IsStarted || !_lastMsgRecd.HasValue || _lastMsgRecd.Value <= (DateTime.UtcNow.Subtract(timeout.Value))) { Trace.TraceInformation("Connection Monitor: Connection Stopped or No data recd for {0}, closing connection", timeout); QuitOk = false; cts.Cancel(); } }, null, timeout.Value, timeout.Value); } }
public static async Task<List<Light>> RetrieveLights() { var cts = new CancellationTokenSource(); List<Light> retVal = new List<Light>(); cts.CancelAfter(5000); try { HttpClient client = new HttpClient(); string ip, username; int port; SettingsService.RetrieveSettings(out ip, out port, out username); var response = await client.GetAsync(new Uri(string.Format("http://{0}:{1}/api/{2}/lights/", ip, port, username))).AsTask(cts.Token); if (!response.IsSuccessStatusCode) { cts.Cancel(); } string jsonResponse = await response.Content.ReadAsStringAsync(); //System.Diagnostics.Debug.WriteLine(jsonResponse); retVal = ParseLights(jsonResponse); var IgnoredTask = UpdateLightsPhraseList(retVal); IgnoredTask.Start(); } catch (Exception) { cts.Cancel(); } return retVal; }
private static void Processor_ProcessExit(object sender, EventArgs e) { if (!_cs.IsCancellationRequested) { _cs.Cancel(); } }
public void Test() { using (var source = new CancellationTokenSource()) { var dev = AzureStorage.CreateConfigurationForDev(); WipeAzureAccount.Fast(s => s.StartsWith("test-"), dev); var b = new RawEngineBuilder(); b.Dispatch(dev.CreateInbox("test-publish"), bytes => { if (bytes[0] == 42) source.Cancel(); }); using (var engine = b.Build()) { var task = engine.Start(source.Token); dev.CreateQueueWriter("test-publish").PutMessage(new byte[] {42}); if (!task.Wait(5000)) { source.Cancel(); } } } }
public static void Queue( this IMessageBus messageBus, ITest test, Func<ITest, IMessageSinkMessage> createTestResultMessage, CancellationTokenSource cancellationTokenSource) { Guard.AgainstNullArgument("messageBus", messageBus); Guard.AgainstNullArgument("createTestResultMessage", createTestResultMessage); Guard.AgainstNullArgument("cancellationTokenSource", cancellationTokenSource); if (!messageBus.QueueMessage(new TestStarting(test))) { cancellationTokenSource.Cancel(); } else { if (!messageBus.QueueMessage(createTestResultMessage(test))) { cancellationTokenSource.Cancel(); } } if (!messageBus.QueueMessage(new TestFinished(test, 0, null))) { cancellationTokenSource.Cancel(); } }
/// <summary>モジュール名を指定してモジュールをロードします。</summary> /// <param name="serviceName">モジュール名</param> /// <param name="args">モジュールロード時のオプション(使っていません)</param> /// <returns>ロードされたモジュール</returns> public async Task<QiServiceModule> LoadService(string serviceName, params object[] args) { if (IsDisposed) throw new ObjectDisposedException(nameof(QiSession)); int id = PublishPostId(); QiServiceModule result = null; JToken errorData = new JObject(); bool success = false; bool disconnected = false; CancellationTokenSource cts = new CancellationTokenSource(); var token = cts.Token; //コードの通りだが、成功と失敗のイベントを監視しつつ通信を試す using (var _ = Observable.FromEventPattern<QiSessionReplyEventArgs>(this, nameof(ReplyReceived)) .FirstAsync(ep => ep.EventArgs.Id == id) .Subscribe(ep => { success = true; result = QiServiceModule.CreateFromMetaObject(this, ep.EventArgs.Data); cts.Cancel(); })) using (var __ = Observable.FromEventPattern<QiSessionReplyEventArgs>(this, nameof(ErrorReceived)) .FirstAsync(ep => ep.EventArgs.Id == id) .Subscribe(ep => { success = false; errorData = ep.EventArgs.Data; cts.Cancel(); })) using (var ___ = Observable.FromEventPattern<EventArgs>(this, nameof(Disconnected)) .Take(1) .Subscribe(____ => { success = false; disconnected = true; cts.Cancel(); })) { Post(id, "ServiceDirectory", "service", new JArray(new JValue(serviceName))); await Task.Delay(Timeout.Infinite, token); if (disconnected) { throw new QiSessionDisconnectedException(); } if(!success) { throw new QiSessionLoadServiceFailedException(id, serviceName, errorData); } return result; } }
public async Task Run(CancellationToken cancel_token) { try { cancel_token.ThrowIfCancellationRequested(); await Handshake(cancel_token); var local_cancel = new CancellationTokenSource(); cancel_token.Register(() => { local_cancel.Cancel(); Close(); }); var send_messages = SendServerMessages(local_cancel.Token); var recv_messages = RecvAndProcessMessages(local_cancel.Token); Task.WaitAny(send_messages, recv_messages); local_cancel.Cancel(); Close(); Task.WaitAll(send_messages, recv_messages); } catch (IOException e) { if (!disposed) { logger.Error(e); } } catch (AggregateException e) { if (!disposed) { logger.Error(e); } } finally { Close(); } }
public void Dispose() { _callback = null; _state = null; _changeSource?.Cancel(); _changeSource?.Dispose(); }
static void Main(string[] args) { var cancellationTokenSource = new CancellationTokenSource(); var cancellationToken = cancellationTokenSource.Token; cancellationTokenSource.Cancel(); var t2 = Task.Run(() => { while (true) { cancellationToken.ThrowIfCancellationRequested(); Console.WriteLine("In loop"); Thread.Sleep(1000); } }, cancellationToken) .ContinueWith(prev => { Console.WriteLine($"t2 status is now {prev.Status}"); }); cancellationToken.Register(() => { Console.WriteLine("this will run when cancelled"); }); Thread.Sleep(4000); cancellationTokenSource.Cancel(); Console.ReadLine(); }
private void FaceCompare_FormClosing(object sender, FormClosingEventArgs e) { if (_cts != null) { _cts.Cancel(); } }
protected async Task ExecuteWithProgressDialogAsync(Func<CancellationToken, Task> asyncFunc, CancellationToken pageExitCancellationToken) { await UiDispatchService.DispatchOnUiThread(async () => { IDialogService dialogService; try { dialogService = DialogService; } catch (Exception e) { Debug.WriteLine(e); return; } if (dialogService.IsProgressDialogOpen()) { return; } try { var timeOutCancellationTokenSource = new CancellationTokenSource(); var invokeTask = asyncFunc.Invoke(timeOutCancellationTokenSource.Token); if (pageExitCancellationToken.IsCancellationRequested) { timeOutCancellationTokenSource.Cancel(); pageExitCancellationToken.ThrowIfCancellationRequested(); } await Task.WhenAny(Task.Delay(250, pageExitCancellationToken), invokeTask); if (!invokeTask.IsCompleted) { dialogService.ShowProgressDialog(); } if (pageExitCancellationToken.IsCancellationRequested) { timeOutCancellationTokenSource.Cancel(); pageExitCancellationToken.ThrowIfCancellationRequested(); } await Task.WhenAny(Task.Delay(8000, pageExitCancellationToken), invokeTask); if (invokeTask.IsFaulted) { throw invokeTask.Exception.InnerException; } } finally { dialogService.CloseProgressDialog(); } }); }
public void StopListening() { StopIntervalTimer(); if (_readCancellationTokenSource != null && _readCancellationTokenSource.Token.CanBeCanceled) { _readCancellationTokenSource.Cancel(); } }
private void CancellationTokenSource_CancelShouldWorkIfFirstTime() { var cancelCount = 0; var cts = new CancellationTokenSource(); cts.Token.Register(() => { cancelCount++; cts.Cancel(); }); cts.Cancel(); Assert.IsTrue(cancelCount == 1); }
private async Task<bool> Process(CancellationToken cancellationToken) { var result = await _queueOperator.NextAsync( new QueueName(_actorDescriptor.SourceQueueName)); var cancellationTokenSource = new CancellationTokenSource(); if (result.IsSuccessful) { TheTrace.TraceInformation("Receieved a message. Id: {0} Queue: {1} ", result.PollingResult.Id, _actorDescriptor.SourceQueueName); var actor = (IProcessorActor)_serviceLocator.GetService(_actorDescriptor.ActorType); try { // this is NOT supposed to be awaited upon!! _queueOperator.KeepExtendingLeaseAsync(result.PollingResult, TimeSpan.FromSeconds(30), cancellationTokenSource.Token).SafeObserve(); // Would have been great to make this fixed memory foot-print with real iterable vs. list var events = (await actor.ProcessAsync(result.PollingResult)).ToArray(); // the enumerable has to be turned into a list anyway. it does further on var groups = events.GroupBy(x=>x.QueueName); foreach (var gr in groups) { await _queueOperator.PushBatchAsync(gr); TryDisposeMessages(gr); } cancellationTokenSource.Cancel(); await _queueOperator.CommitAsync(result.PollingResult); TheTrace.TraceInformation("Processing succeeded. Id: {0} Queue: {1} " , result.PollingResult.Id, _actorDescriptor.SourceQueueName); } catch (Exception exception) { TheTrace.TraceInformation("Processing failed. Id: {0} Queue: {1} ", result.PollingResult.Id, _actorDescriptor.SourceQueueName); TheTrace.TraceError(exception.ToString()); cancellationTokenSource.Cancel(); _queueOperator.AbandonAsync(result.PollingResult).SafeObserve().Wait(); } finally { if (result.IsSuccessful) TryDisposeMessage(result.PollingResult); _serviceLocator.ReleaseService(actor); } } return result.IsSuccessful; }
public void SignalToStop() { if (_jpegStream != null) { _jpegStream.NewFrame -= JpegStreamNewFrame; _jpegStream.SignalToStop(); _tokenSource.Cancel(); _signal.Set(); _faceComparer.SignalToStop(); } }
private async Task<bool> Process(CancellationToken cancellationToken) { var result = await _queueOperator.NextAsync( new QueueName(_actorDescriptor.SourceQueueName)); var cancellationTokenSource = new CancellationTokenSource(); if (result.IsSuccessful) { TheTrace.TraceInformation("Receieved a message. Id: {0} Queue: {1} ", result.PollingResult.Id, _actorDescriptor.SourceQueueName); var actor = (IProcessorActor)_serviceLocator.GetService(_actorDescriptor.ActorType); try { _queueOperator.KeepExtendingLeaseAsync(result.PollingResult, TimeSpan.FromSeconds(30), cancellationTokenSource.Token).SafeObserve(); var events = (await actor.ProcessAsync(result.PollingResult)).ToArray(); cancellationTokenSource.Cancel(); await _queueOperator.CommitAsync(result.PollingResult); var groups = events.GroupBy(x=>x.QueueName); foreach (var gr in groups) { await _queueOperator.PushBatchAsync(gr); TryDisposeMessages(gr); } TheTrace.TraceInformation("Processing succeeded. Id: {0} Queue: {1} " , result.PollingResult.Id, _actorDescriptor.SourceQueueName); } catch (Exception exception) { TheTrace.TraceInformation("Processing failed. Id: {0} Queue: {1} ", result.PollingResult.Id, _actorDescriptor.SourceQueueName); TheTrace.TraceError(exception.ToString()); cancellationTokenSource.Cancel(); _queueOperator.AbandonAsync(result.PollingResult).SafeObserve().Wait(); } finally { if (result.IsSuccessful) TryDisposeMessage(result.PollingResult); _serviceLocator.ReleaseService(actor); } } return result.IsSuccessful; }
public async Task CancelConnectToNonExistentServer_Throws_OperationCanceledException() { using (NamedPipeClientStream client = new NamedPipeClientStream(".", "notthere")) { var ctx = new CancellationTokenSource(); Task clientConnectToken = client.ConnectAsync(ctx.Token); ctx.Cancel(); await Assert.ThrowsAnyAsync<OperationCanceledException>(() => clientConnectToken); ctx.Cancel(); await Assert.ThrowsAnyAsync<OperationCanceledException>(() => client.ConnectAsync(ctx.Token)); } }
public void Cancel() { var cts = new CancellationTokenSource(); int[] called = { 0 }; cts.Token.Register(l => { Assert.AreEqual("v", l); ++called[0]; }, "v"); cts.Cancel(); Assert.AreEqual(1, called[0], "#1"); called[0] = 0; cts.Token.Register(() => { called[0] += 12; }); cts.Cancel(); Assert.AreEqual(12, called[0], "#2"); }
public async Task CancelConnectToNonExistentServer_Throws_OperationCanceledException() { using (NamedPipeClientStream client = new NamedPipeClientStream(".", "notthere")) { var ctx = new CancellationTokenSource(); if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) // [ActiveIssue(812, PlatformID.AnyUnix)] - Unix implementation currently ignores timeout and cancellation token once the operation has been initiated { Task clientConnectToken = client.ConnectAsync(ctx.Token); ctx.Cancel(); await Assert.ThrowsAnyAsync<OperationCanceledException>(() => clientConnectToken); } ctx.Cancel(); await Assert.ThrowsAnyAsync<OperationCanceledException>(() => client.ConnectAsync(ctx.Token)); } }
protected override async Task RunTestsOnMethodAsync(IMessageBus messageBus, Type classUnderTest, object[] constructorArguments, MethodInfo methodUnderTest, List<BeforeAfterTestAttribute> beforeAfterAttributes, ExceptionAggregator aggregator, CancellationTokenSource cancellationTokenSource) { var executionTime = 0M; var originalCulture = Thread.CurrentThread.CurrentCulture; var originalUICulture = Thread.CurrentThread.CurrentUICulture; try { var cultureInfo = CultureInfo.GetCultureInfo(culture); Thread.CurrentThread.CurrentCulture = cultureInfo; Thread.CurrentThread.CurrentUICulture = cultureInfo; executionTime = await RunTestWithArgumentsAsync(messageBus, classUnderTest, constructorArguments, methodUnderTest, null, DisplayName, beforeAfterAttributes, aggregator, cancellationTokenSource); } catch (Exception ex) { if (!messageBus.QueueMessage(new Xunit.Sdk.TestStarting(this, DisplayName))) cancellationTokenSource.Cancel(); else { if (!messageBus.QueueMessage(new Xunit.Sdk.TestFailed(this, DisplayName, executionTime, null, ex.Unwrap()))) cancellationTokenSource.Cancel(); } if (!messageBus.QueueMessage(new Xunit.Sdk.TestFinished(this, DisplayName, executionTime, null))) cancellationTokenSource.Cancel(); } finally { Thread.CurrentThread.CurrentCulture = originalCulture; Thread.CurrentThread.CurrentUICulture = originalUICulture; } }
void IBackgroundTask.Run(IBackgroundTaskInstance taskInstance) { var cancel = new System.Threading.CancellationTokenSource(); taskInstance.Canceled += (s, e) => { cancel.Cancel(); cancel.Dispose(); }; BackgroundTaskDeferral deferral = taskInstance.GetDeferral(); try { // Handle geofence state change reports GetGeofenceStateChangedReports(GeofenceMonitor.Current.LastKnownGeoposition); } catch (UnauthorizedAccessException) { WriteStatusToAppData("Location permissions are disabled. Enable access through the settings."); } finally { deferral.Complete(); } }
/// <summary> /// Execute a delegate and if it does not finish in the timeout period then terminate it /// </summary> /// <param name="obj">the extension object</param> /// <param name="timeout">the amount of time to wait before terminating the action</param> /// <param name="action">the delegate to execute</param> /// <param name="responseDelegate">(optional) delgate to receive reporting text on how the action finished</param> /// <returns>True if the action delegate completes and false otherwise</returns> /// <exception cref="AggregateException">Aggregates exceptions thrown in the action delegate(see InnerExceptions)</exception> public static bool ExecuteActionOrTimeout(this object obj, TimeSpan timeout, Action action, Action <string> responseDelegate = null) { DateTime end = DateTime.Now + timeout; TaskFactory factory = new TaskFactory(); var cancelSource = new System.Threading.CancellationTokenSource(timeout); var task = factory.StartNew(action, cancelSource.Token); while (DateTime.Now < end) { if (task.IsCanceled) { responseDelegate?.Invoke($"\n{action.Target}.{action.Method} cancelled before timeout"); return(false); } else if (task.IsFaulted) { responseDelegate?.Invoke($"\n{action.Target}.{action.Method} faulted before timeout"); throw task.Exception; } else if (task.IsCompleted) { responseDelegate?.Invoke($"\n{action.Target}.{action.Method} completed before timeout"); return(true); } } cancelSource.Cancel(); responseDelegate?.Invoke($"\n{action.Target}.{action.Method} timed out"); return(false); }
private static void CancelTasksWithSoftExit() { var cts = new System.Threading.CancellationTokenSource(); var token = cts.Token; var t = new Task( () => { int i = 0; while (true) { // Soft exit -> check the token if cancellation is requested if (token.IsCancellationRequested) { break; } Console.WriteLine($"{i++}\t"); } }, token ); t.Start(); Console.ReadKey(); cts.Cancel(); }
public static T.CancellationToken ToTpl(this CancellationToken ct) { var cts = new T.CancellationTokenSource(); ct.Register(() => cts.Cancel()); return(cts.Token); }
private void Main_FormClosing(object sender, FormClosingEventArgs e) { if (_CameraPara.HasVideoDevice) { _CancellationTokenSource.Cancel(); System.Threading.Thread.Sleep(500); this.VideoPlayer.Stop(); if (_FaceMatchEngine != IntPtr.Zero) { Face.Match.Close(_FaceMatchEngine); } //if (_FaceTraceEnginer != IntPtr.Zero) // Face.Trace.Close(_FaceTraceEnginer); if (_FaceDetectEnginer != IntPtr.Zero) { Face.Detect.Close(_FaceDetectEnginer); } //if (_FaceAgeEngine != IntPtr.Zero) // Face.Age.Close(_FaceAgeEngine); //if (_FaceGenderEngine != IntPtr.Zero) // Face.Gender.Close(_FaceGenderEngine); } }
public void Stop() { try { CTS.Cancel(); } catch { } try { t1.Abort(); } catch { } try { t2.Abort(); } catch { } foreach (var a in clients) { try { a.Client.Close(); } catch { } } try { tcpl.Stop(); } catch { } System.Threading.Thread.Sleep(500); }
public static void Main (string[] args) { ButtonEvents buts = new ButtonEvents (); var tokenSource = new CancellationTokenSource(); var token = tokenSource.Token; var dialog = new InfoDialog("Attach distance sensor", false); dialog.Show(); var sensor = SensorAttachment.Wait<MSAngleSensor>(token);//wait for sensor to attached on any port LcdConsole.WriteLine("Up reset angle"); LcdConsole.WriteLine("Down read RMP"); LcdConsole.WriteLine("Enter read angle"); LcdConsole.WriteLine("Left read raw"); LcdConsole.WriteLine("Esc. terminate"); buts.EscapePressed += () => { tokenSource.Cancel(); }; buts.EnterPressed += () => { LcdConsole.WriteLine ("Angle: " + sensor.ReadAngle().ToString()); }; buts.UpPressed += () => { LcdConsole.WriteLine ("Reset angle"); sensor.ResetAngle(); }; buts.DownPressed += () => { LcdConsole.WriteLine ("Read RPM: " + sensor.ReadRPM().ToString()); }; buts.LeftPressed += () => { LcdConsole.WriteLine ("Read raw: " + sensor.ReadRAW().ToString()); }; token.WaitHandle.WaitOne(); }
static void Main(string[] args) { map.Add(0, 0); map.Add(1, 1); System.Threading.CancellationTokenSource cts = new System.Threading.CancellationTokenSource(); //signalDetect(outputFolder + "signal.csv", cts); //BitSignalDetect(outputFolder + "signal.csv", cts); //MorseSignalDetect("morse.csv", cts); //simpleTest(cts); WeatherDataOutput("WeatherData.csv", cts); //dumpSignalIQ(outputFolder + "IQ.csv", cts); //dumpSignalIQRAW(outputFolder + "IQRaw.bin", cts); //downSameTest("SingalIQ.csv", "SingalIQ_Down1000.csv",cts); //dumpIQToWaveFile(outputFolder+"IQ.csv", outputFolder+"Wave.csv", cts); //dumpIQToLPFWaveFile(outputFolder + "IQ.csv", outputFolder + "LPF.csv", cts); //dumpIQToLPFWaveSQFile(outputFolder + "IQ.csv", outputFolder + "LPFSQ.csv", 0.6f,cts); //dumpIQToLPF_Wave_MA_SQFile(outputFolder + "IQ.csv", outputFolder + "LPF_MV_SQ.csv", 0.3f, cts); //dumpIQToLPF_Wave_MA_SQ_SCFile(outputFolder + "IQ.csv", outputFolder + "LPF_MV_SQ_SC.csv", 0.3f, cts); dumpQueue(cts.Token); Console.ReadLine(); cts.Cancel(); Console.WriteLine("waiting for threads exit..."); PipelineManager.Default.WaitAllExit(); Console.WriteLine("done"); }
public override long RunPass() { _queueEventProcessor.Reset(); var cts = new CancellationTokenSource(); Task.Factory.StartNew(_queueEventProcessor.Run, cts.Token); var sw = Stopwatch.StartNew(); for (var i = 0; i < Iterations; i++) { _queue.Add(i); } while (!_queueEventProcessor.Done) { // busy spin } var opsPerSecond = (Iterations * 1000L) / (sw.ElapsedMilliseconds); cts.Cancel(true); Assert.AreEqual(ExpectedResult, _queueEventProcessor.Value, "RunQueuePass"); return opsPerSecond; }
public FetchedJobsWatcherFacts() { var options = new RedisStorageOptions() { Db = RedisUtils.GetDb() }; _storage = new RedisStorage(RedisUtils.GetHostAndPort(), options); _cts = new CancellationTokenSource(); _cts.Cancel(); }
static void Main() { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); var cache = GetDataFolder(); using (var source = new CancellationTokenSource()) { var builder = Sys.Configure(cache); var fastSubject = new Subject<ISystemEvent>(); builder.Advanced.Observers.Clear(); builder.Advanced.RegisterObserver(fastSubject); using (var host = builder.Build()) { Console.WriteLine("Starting host"); var task = host.Start(source.Token); var form = new Form1(host, fastSubject); form.FormClosing += (sender, args) => source.Cancel(); Application.Run(form); task.Wait(5000); } } }
public void TestWaitReleaseAsyncWithCancellation() { // TODO: rewrite test once cancellation is properly supported during systematic testing. this.Test(async() => { Semaphore semaphore = Semaphore.Create(1, 1); Specification.Assert(semaphore.CurrentCount is 1, "Semaphore count is {0} instead of 1.", semaphore.CurrentCount); SystemTasks.CancellationTokenSource tokenSource = new SystemTasks.CancellationTokenSource(); Task task = Task.Run(async() => { await Task.Delay(1); tokenSource.Cancel(); }); await semaphore.WaitAsync(tokenSource.Token); Specification.Assert(semaphore.CurrentCount is 0 || semaphore.CurrentCount is 1, "Semaphore count is {0} instead of 0 or 1.", semaphore.CurrentCount); semaphore.Release(); Specification.Assert(semaphore.CurrentCount is 1, "Semaphore count is {0} instead of 1.", semaphore.CurrentCount); await task; semaphore.Dispose(); }); }
private static async Task CancelAllWhenAnyCompletes(Task leaderTask, Task renewLeaseTask, CancellationTokenSource cts) { await Task.WhenAny(leaderTask, renewLeaseTask); // Cancel the user's leader task or the renewLease Task, as it is no longer the leader. cts.Cancel(); var allTasks = Task.WhenAll(leaderTask, renewLeaseTask); try { await Task.WhenAll(allTasks); } catch (Exception) { if (allTasks.Exception != null) { allTasks.Exception.Handle(ex => { if (!(ex is OperationCanceledException)) { Trace.TraceError(ex.Message); } return true; }); } } }
public static void RunTaskFactoryTests_Cancellation_Negative() { CancellationTokenSource cancellationSrc = new CancellationTokenSource(); //Test constructor that accepts cancellationToken cancellationSrc.Cancel(); TaskFactory tf = new TaskFactory(cancellationSrc.Token); var cancelledTask = tf.StartNew(() => { }); EnsureTaskCanceledExceptionThrown(() => cancelledTask.Wait()); // Exercising TF<int>(cancellationToken) with a cancelled token cancellationSrc.Cancel(); TaskFactory<int> tfi = new TaskFactory<int>(cancellationSrc.Token); cancelledTask = tfi.StartNew(() => 0); EnsureTaskCanceledExceptionThrown(() => cancelledTask.Wait()); }
public static int Main(string[] args) { if (args.Length == 0) { Console.WriteLine("KestrelHelloWorld <url to host>"); return 1; } var url = new Uri(args[0]); Args = string.Join(" ", args); var host = new WebHostBuilder() .UseServer("Microsoft.AspNetCore.Server.Kestrel") .UseUrls(url.ToString()) .UseStartup<Startup>() .Build(); ServerCancellationTokenSource = new CancellationTokenSource(); // shutdown server after 20s. var shutdownTask = Task.Run(async () => { await Task.Delay(20000); ServerCancellationTokenSource.Cancel(); }); host.Run(ServerCancellationTokenSource.Token); shutdownTask.Wait(); return 0; }
public void Disconnect() { if (!IsConnected) { return; } CancelListen.Cancel(); }
public void Stop() { if (Log.IsTraceEnabled) { _log.Trace(string.Format(Resources.ProcessorThreadStopping, _thread.ManagedThreadId, _processor.GetType().FullName)); } _cancellationTokenSource.Cancel(); _processor.AttemptDispose(); if (_thread.IsAlive) { _thread.Join(ThreadJoinTimeoutInterval); } }
private void ExitMenuButton_Click(object sender, EventArgs e) { if (Table.Rows.Count > 0) { cts?.Cancel(); Add.Wait(); Add.Dispose(); } Application.Exit(); }
public void StreamThreadCommitIntervalWorkflow() { var source = new System.Threading.CancellationTokenSource(); var config = new StreamConfig <StringSerDes, StringSerDes>(); config.ApplicationId = "test"; config.Guarantee = ProcessingGuarantee.AT_LEAST_ONCE; config.PollMs = 1; config.CommitIntervalMs = 1; var serdes = new StringSerDes(); var builder = new StreamBuilder(); builder.Stream <string, string>("topic").To("topic2"); var topo = builder.Build(); var supplier = new SyncKafkaSupplier(); var producer = supplier.GetProducer(config.ToProducerConfig()); var consumer = supplier.GetConsumer(config.ToConsumerConfig("test-consum"), null); consumer.Subscribe("topic2"); var thread = StreamThread.Create( "thread-0", "c0", topo.Builder, new StreamMetricsRegistry(), config, supplier, supplier.GetAdmin(config.ToAdminConfig("admin")), 0) as StreamThread; thread.Start(source.Token); producer.Produce("topic", new Confluent.Kafka.Message <byte[], byte[]> { Key = serdes.Serialize("key1", new SerializationContext()), Value = serdes.Serialize("coucou", new SerializationContext()) }); //WAIT STREAMTHREAD PROCESS MESSAGE System.Threading.Thread.Sleep(100); var message = consumer.Consume(100); Assert.AreEqual("key1", serdes.Deserialize(message.Message.Key, new SerializationContext())); Assert.AreEqual("coucou", serdes.Deserialize(message.Message.Value, new SerializationContext())); var offsets = thread.GetCommittedOffsets(new List <TopicPartition> { new TopicPartition("topic", 0) }, TimeSpan.FromSeconds(10)).ToList(); Assert.AreEqual(1, offsets.Count); Assert.AreEqual(1, offsets[0].Offset.Value); Assert.AreEqual(0, offsets[0].TopicPartition.Partition.Value); Assert.AreEqual("topic", offsets[0].Topic); source.Cancel(); thread.Dispose(); }
private void Form1_FormClosing(object sender, FormClosingEventArgs e) { if (_CameraPara.HasVideoDevice) { _CancellationTokenSource.Cancel(); System.Threading.Thread.Sleep(500); this.VideoPlayer.Stop(); ArcFace.Api.Close(); } }
public bool TryDequeue(out T value, int timeout = Timeout.Infinite) { lock (queue) { while (queue.Count == 0) { if (closing || (timeout < Timeout.Infinite) || !Monitor.Wait(queue, timeout)) { value = default(T); CancellationTokenSource?.Cancel(); value.Dispose(); return(false); } } CancellationTokenSource?.Cancel(); value = (T)queue.Dequeue(); value.Dispose(); GC.Collect(); return(true); } }
public void StopRecording() { if (recorder != null) { recorder.Stop(); isRecording = false; token.Cancel(); recorder.Release(); recorder = null; } CopyWaveFile(GetTempFilename(), filePath); }
/// <summary> /// Closes the device. /// </summary> /// <returns></returns> public async Task CloseAsync() { if (m_cts != null) { m_closeTask = new TaskCompletionSource <bool>(); if (m_cts != null) { m_cts.Cancel(); } m_cts = null; } await m_closeTask.Task; await CloseStreamAsync(m_stream); m_stream = null; lock (m_lockObject) { m_isOpening = false; IsOpen = false; } }
static void Main(string[] args) { var options = new Options(); if (CommandLine.Parser.Default.ParseArgumentsStrict(args, options)) { var client = new Statsd(options.Host, options.Port, prefix: options.Namespace, connectionType: options.UseTCP ? ConnectionType.Tcp : ConnectionType.Udp); var tokenSource = new System.Threading.CancellationTokenSource(); var stopwatch = Stopwatch.StartNew(); var totalMetricsSent = 0; var letters = new String[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J" }; var tasks = new List <Task>(); int numThreads = options.Threads == 0 ? 1 : options.Threads; for (int count = 0; count < numThreads; count++) { int myTaskNumber = count; var task = Task.Factory.StartNew(() => { var rnd = new Random(); int taskNumber = myTaskNumber; if (taskNumber == 0) { Console.WriteLine("Feeding stats to {0}:{1}, ctrl+c to exit.", options.Host, options.Port); } while (true) { client.LogCount("test.count.one." + rnd.Next(5)); client.LogCount("test.count.bigValue", rnd.Next(50)); client.LogTiming("test.timing." + rnd.Next(5), rnd.Next(100, 2000)); client.LogGauge("test.gauge." + rnd.Next(5), rnd.Next(100)); client.LogCalendargram("test.calendargram.users", letters.Next(), "m"); Thread.Sleep(options.Delay); Interlocked.Add(ref totalMetricsSent, 4); if (taskNumber == 0 && stopwatch.ElapsedMilliseconds >= 5000) { Console.WriteLine("Total sent: {0}", totalMetricsSent); stopwatch.Restart(); } } }, tokenSource.Token); tasks.Add(task); } Console.CancelKeyPress += (sender, e) => { tokenSource.Cancel(); }; Task.WaitAll(tasks.ToArray()); } }
public void Stop() { Log.Info("Stopping..."); shutdown = true; using (stopLoop) { stopLoop.Cancel(); using (loopTask) { loopTask.Wait(); } } Log.Info("Stopped"); }
private void Form1_FormClosing(object sender, FormClosingEventArgs e) { if (_VideoSource != null) { _CancellationTokenSource.Cancel(); for (int i = 0; i < 10; i++) { if (_MatchTask.Status == TaskStatus.RanToCompletion) { break; } Thread.Sleep(1000); } this.VideoPlayer.Stop(); ArcFace.Api.Close(); } }
public void Stop() { try { if (Task != null && CancellationTokenSource != null) { CancellationTokenSource.Cancel(); } if (Task != null) { Task.Abort(); Task = null; } } catch (Exception ee) { } }
/// <summary> /// Stops the timer. /// </summary> private void Stop() { if (_cancellationTokenSource != null) { _cancellationTokenSource.Cancel(); _cancellationTokenSource = null; } #if USE_INTERNAL_TIMER lock (_lock) { if (_timer != null) { _timer.Change(Timeout.Infinite, Timeout.Infinite); _timer = null; } } #endif }
private async Task ShowPanel(Label label, Control panel) { panel.BringToFront(); panel.Visible = true; label.Visible = false; panel.Focus(); var cancel = new System.Threading.CancellationTokenSource(); var token = cancel.Token; EventHandler visibleChanged = null; visibleChanged = delegate { cancel.Cancel(); }; panel.VisibleChanged += visibleChanged; var r = this.RectangleToScreen(panel.Bounds); do { try { await Task.Delay(500, token); } catch (TaskCanceledException) { break; } }while (forceShowPanel || r.Contains(Cursor.Position) || Control.MouseButtons.HasFlag(MouseButtons.Left)); panel.VisibleChanged -= visibleChanged; if (!cancel.IsCancellationRequested) { panel.Visible = false; label.Visible = true; } cancel.Dispose(); }
private void Dispose() { Trace.WriteLine("Disposing"); if (IsDisposed) { return; } // should cancel all registered events CancellationTokenSource.Cancel(); // issue into messenger Messenger.IssueCancellation(CancellationTokenSource); // should close out database and issue cancellation to token Messenger.Dispose(); IsDisposed = true; Trace.WriteLine("Cleanup complete"); }
private void queryBtn_Click(object sender, EventArgs e) { if (_cts != null) { _cts.Cancel(); } this.ClearAll(); var c = CriteriaOperator.Parse("CaptureTime >= ? And CaptureTime <= ?", this.TimeRange.From, this.TimeRange.To); videoCollection.Criteria = c; pageSelector = new XPPageSelector(); pageSelector.PageSize = 50; pageSelector.CurrentPage = 0; pageSelector.Collection = videoCollection; UpdateCurrentPage(); }