public void TestCancelAsync() { BackgroundWorker bw = new BackgroundWorker(); bw.DoWork += DoWorkExpectCancel; bw.WorkerSupportsCancellation = true; manualResetEvent3 = new ManualResetEventSlim(false); bw.RunWorkerAsync("Message"); bw.CancelAsync(); bool ret = manualResetEvent3.Wait(TimeoutLong); Assert.True(ret); // there could be race condition between worker thread cancellation and completion which will set the CancellationPending to false // if it is completed already, we don't check cancellation if (bw.IsBusy) // not complete { if (!bw.CancellationPending) { for (int i = 0; i < 1000; i++) { Wait(TimeoutShort); if (bw.CancellationPending) { break; } } } // Check again if (bw.IsBusy) Assert.True(bw.CancellationPending, "Cancellation in Main thread"); } }
public void CancelAsyncNonBusy() { var backgroundWorker = new BackgroundWorker<object, object, object> { WorkerSupportsCancellation = true }; Assert.IsFalse(backgroundWorker.IsBusy); backgroundWorker.CancelAsync(); }
private void Initialize() { _bw?.CancelAsync(); UseWaitCursor = true; _oldSubmoduleInfo = null; if (Submodules.SelectedRows.Count == 1) { _oldSubmoduleInfo = Submodules.SelectedRows[0].DataBoundItem as GitSubmoduleInfo; } lock (_modules) { _modules.Clear(); } _bw = new BackgroundWorker(); _bw.DoWork += bw_DoWork; _bw.ProgressChanged += bw_ProgressChanged; _bw.RunWorkerCompleted += bw_RunWorkerCompleted; _bw.WorkerReportsProgress = true; _bw.WorkerSupportsCancellation = true; _bw.RunWorkerAsync(); }
public void BackgroundWorker_CancelAsync_ThrowsInvalidOperationExceptionWhenWorkerSupportsCancellationIsFalse() { using (UnitTestContext context = GetContext()) { BackgroundWorker target = new BackgroundWorker(); target.DoWork += (o, e) => { for (int i = 1; i < 11; i++) { Thread.Sleep(10); } }; target.WorkerSupportsCancellation = false; target.RunWorkerAsync(null); try { target.CancelAsync(); // this call throws exception } catch (InvalidOperationException ex) { context.Assert.Fail(ex); } context.Complete(); } }
public void TestCancelAsyncWithoutCancellationSupport() { var bw = new BackgroundWorker() { WorkerSupportsCancellation = false }; Assert.Throws<InvalidOperationException>(() => bw.CancelAsync()); }
public void Stop() { bw.CancelAsync(); }
public void Dispose() { _bw?.CancelAsync(); }
private void OnInject(object sender, RoutedEventArgs args) { if (Context.InjectionMode) { if (!Utilities.IsRunningAsAdministrator()) // checks whether the app is running as administrator { MessageBox.Show("Administrative privileges is required in order to inject a DLL into a process!", "Libjector"); return; } if (_targetProcessId is null) // checks whether the target process is selected yet { MessageBox.Show("Select a target process before continuing!", "Libjector"); return; } if (DllList.SelectedItem is not DllItemModel dllItem) // checks whether the dll is selected yet { MessageBox.Show("Select a DLL before continuing!", "Libjector"); return; } try { if (Context.SelectedMethodIndex == 3) { var mappingFlags = MappingFlags.None; if (Context.DiscardHeadersFlag) { mappingFlags |= MappingFlags.DiscardHeaders; } if (Context.SkipInitializationRoutinesFlag) { mappingFlags |= MappingFlags.SkipInitialisationRoutines; } _libraryMapper = new LibraryMapper(Process.GetProcessById(_targetProcessId.Value), dllItem.Path, mappingFlags); _libraryMapper.MapLibrary(); } else { var injectionFlags = InjectionFlags.None; if (Context.HideDllFlag) // adds hide from peb flag { injectionFlags |= InjectionFlags.HideDllFromPeb; } if (Context.RandomizeHeadersFlag) // adds randomize headers flag { injectionFlags |= InjectionFlags.RandomiseDllHeaders; } if (Context.RandomizeNameFlag) // adds randomize name flag { injectionFlags |= InjectionFlags.RandomiseDllName; } var injectionMethod = Context.SelectedMethodIndex switch { 1 => InjectionMethod.HijackThread, 2 => InjectionMethod.ManualMap, _ => InjectionMethod.CreateThread }; _injectorService?.Dispose(); // disposes any existing injector service _injectorService = new Injector(_targetProcessId.Value, dllItem.Path, injectionMethod, injectionFlags); _injectorService.InjectDll(); // injects dll into the target process if (injectionFlags.HasFlag(InjectionFlags.HideDllFromPeb)) { _injectorService.Dispose(); // disposes the injector service; if the specific flag is used goto InjectionCompleted; } } _processHandler?.Dispose(); // disposes any existing process handler _processHandler = new BackgroundWorker { WorkerSupportsCancellation = true }; _processHandler.DoWork += delegate { try { using var process = Process.GetProcessById(_targetProcessId.Value); process.WaitForExit(); // waits for the target process to exit } catch { // do nothing } }; _processHandler.RunWorkerCompleted += delegate { // disposes any existing services; as the target process has been closed _injectorService?.Dispose(); _libraryMapper?.UnmapLibrary(); ToggleInjectionMode(true); }; _processHandler.RunWorkerAsync(); // runs until the dll is ejected or the target process is closed ToggleInjectionMode(false); InjectionCompleted: MessageBox.Show("The DLL has been injected into the process!", "Libjector"); } catch (Exception exception) { MessageBox.Show("An error occurred while injecting! " + exception.Message, "Libjector"); } } else { try { _injectorService?.EjectDll(); _injectorService?.Dispose(); _libraryMapper?.UnmapLibrary(); } catch (Exception exception) { MessageBox.Show("An error occurred while ejecting! " + exception.Message, "Libjector"); } if (_processHandler?.IsBusy == true) { _processHandler?.CancelAsync(); // cancels the process handler; as the dll has been ejected } _processHandler?.Dispose(); ToggleInjectionMode(true); MessageBox.Show("The DLL has been ejected from the process!", "Libjector"); } }
private void SpeedTestForm_FormClosing(object sender, FormClosingEventArgs e) { autodetector?.Stop(); bwSpeedTestController?.CancelAsync(); }
public void Dispose() { listenerWorker?.CancelAsync(); listenWaiter?.Set(); //listenWaiter.Close(); }
private void DoWork(object sender, DoWorkEventArgs e) { List <AnimeEntry> m_aList = new List <AnimeEntry>(); double totalProcessedFiles = 0; double totalFiles = int.Parse(new XPathDocument(xmlPath).CreateNavigator().Evaluate("count(//file)").ToString()) * 2; using (XmlReader reader = XmlReader.Create(xmlPath)) { reader.ReadToFollowing("mylist"); if (reader["template"] != "mini") { Dispatcher.Invoke(new Action(delegate { MessageBox.Show("Please ensure you selected a mylist export file that used the xml-mini template.", "Invalid xml template!", MessageBoxButton.OK, MessageBoxImage.Error); })); xmlWorker.CancelAsync(); return; } // <anime> while (reader.ReadToFollowing("anime")) { while (closePending) { Thread.Sleep(500); } AnimeEntry entry = new AnimeEntry(); entry.aid = int.Parse(reader["aid"]); entry.type = reader["type"]; entry.year = reader["year"]; // <titles> reader.ReadToFollowing("default"); entry.romaji = reader.ReadElementContentAsString(); Dispatcher.BeginInvoke(new Action(delegate { importFilePath.Text = String.Format("Reading: {0}", entry.title); })); reader.ReadToFollowing("nihongo"); entry.nihongo = reader.ReadElementContentAsString().FormatNullable(); reader.ReadToFollowing("english"); entry.english = reader.ReadElementContentAsString().FormatNullable(); // </titles> // <episodes> if (!reader.ReadToFollowing("episodes")) { goto Finish; } entry.eps_total = int.Parse(reader["total"]); XmlReader episodesReader = reader.ReadSubtree(); // <episode> while (episodesReader.ReadToFollowing("episode")) { while (closePending) { Thread.Sleep(500); } EpisodeEntry episode = new EpisodeEntry(); episode.eid = int.Parse(episodesReader["eid"]); episode.airdate = episodesReader["aired"] == "-" ? null : UnixTimestamp.FromDateTime(DateTime.Parse(episodesReader["aired"], System.Globalization.CultureInfo.CreateSpecificCulture("en-GB"))); episode.watched = Convert.ToBoolean(int.Parse(episodesReader["watched"])); if (Regex.IsMatch(episodesReader["epno"].Substring(0, 1), @"\D")) { episode.spl_epno = episodesReader["epno"]; } else { episode.epno = int.Parse(episodesReader["epno"]); } // <titles> episodesReader.ReadToDescendant("english"); episode.english = episodesReader.ReadElementContentAsString(); episodesReader.ReadToFollowing("nihongo"); episode.nihongo = episodesReader.ReadElementContentAsString().FormatNullable(); episodesReader.ReadToFollowing("romaji"); episode.romaji = episodesReader.ReadElementContentAsString().FormatNullable(); // </titles> // <files> if (!episodesReader.ReadToFollowing("files")) { goto Finish; } XmlReader filesReader = episodesReader.ReadSubtree(); // <file> while (filesReader.ReadToFollowing("file")) { while (closePending) { Thread.Sleep(500); } FileEntry file = new FileEntry(); file.fid = int.Parse(filesReader["fid"]); file.lid = int.Parse(filesReader["lid"]); file.watcheddate = filesReader["watched"] == "-" ? null : UnixTimestamp.FromDateTime(DateTime.Parse(episodesReader["watched"], System.Globalization.CultureInfo.CreateSpecificCulture("en-GB"))); file.watched = file.watcheddate != null; file.generic = episodesReader["generic"] != null; if (!file.generic) // generic entries do not have this information { int gid = 0; if (filesReader["gid"] != null) { gid = int.Parse(filesReader["gid"]); } file.ed2k = filesReader["ed2k"]; file.length = double.Parse(filesReader["length"]); file.size = double.Parse(filesReader["size"]); file.source = filesReader["source"].FormatNullable(); file.acodec = ExtensionMethods.FormatAudioCodec(filesReader["acodec"].FormatNullable()); file.vcodec = ExtensionMethods.FormatVideoCodec(filesReader["vcodec"].FormatNullable()); file.vres = filesReader["vres"].FormatNullable(); if (gid != 0) { // <group_name> filesReader.ReadToFollowing("group_name"); string group_name = filesReader.ReadElementContentAsString(); // </group_name> // <group_abbr> filesReader.ReadToFollowing("group_abbr"); string group_abbr = filesReader.ReadElementContentAsString(); // </group_abbr> file.Group = new GroupEntry { gid = gid, group_name = group_name, group_abbr = group_abbr }; } } episode.Files.Add(file); importProgressBar.Dispatcher.BeginInvoke(new Action <double, double>((total, processed) => { importProgressBar.Value = Math.Ceiling(processed / total * 100); }), totalFiles, ++totalProcessedFiles); // </file> } // </files> filesReader.Close(); entry.Episodes.Add(episode); // </episode> } // </episodes> episodesReader.Close(); Finish: m_aList.Add(entry); // </anime> } // </mylist> } m_myList.OnEntryInserted += (aTitle) => { importProgressBar.Dispatcher.BeginInvoke(new Action(delegate { importFilePath.Text = String.Format("Writing: {0}", aTitle); importProgressBar.Value = Math.Ceiling(++totalProcessedFiles / totalFiles * 100); })); }; m_myList.InsertFromImport(m_aList); }
private void buttonCancel_Click(object sender, EventArgs e) { _backgroundWorker.CancelAsync(); }
private void frmExport_FormClosing(object sender, FormClosingEventArgs e) { _workerJsonLoader.CancelAsync(); _workerXmlLoader.CancelAsync(); _workerXmlGenerator.CancelAsync(); }
public void StopWork() { Worker.CancelAsync(); }
private void MainWindow_Closed(object sender, EventArgs e) { worker.CancelAsync(); }
private void Timer1OnTick(object sender, EventArgs e) { DisplayPanelWatch.Text = DateTime.Now.ToShortTimeString(); DisplayPanelWatch.ForeColor = Color.Black; DisplayPanelWatch.Visible = true; DisplayPanelWatch.Font = new Font("Segoe UI Symbo", 12F, FontStyle.Regular); try { _server.GetStatus(); DisplayPanelServerError.Text = string.Empty; if (!Trends.Visible) { DisplayPanelWatch.Visible = true; Trends.Visible = true; //Toolbar.Visible = true; DisplayPanel.Visible = Status; DisplayPanelServerError.Visible = false; _status = true; } if (_repConnectionWorker.IsBusy) { _repConnectionWorker.CancelAsync(); } } catch (Exception) { CheckTheConnectionStatus(); _status = false; if (Trends.Visible) { Trends.Visible = false; //Toolbar.Visible = false; DisplayPanel.Visible = Status; DisplayPanelServerError.Visible = false; DisplayPanelWatch.Visible = false; } } try { if (_status) { //Toolbar.Visible = true; Trends.Visible = true; DisplayPanel.Visible = Status; OffConnectionDisplayPanelIndicator.Visible = false; OnConnectionDisplayPanelIndicator.Visible = true; OnConnectionDisplayPanelIndicator.ForeColor = Color.Black; OnConnectionDisplayPanelIndicator.Font = new Font("Segoe UI Symbo", 12F, FontStyle.Regular); DisplayPanelServerError.Visible = false; DisplayPanelServerError.Text = string.Empty; } else { OffConnectionDisplayPanelIndicator.Visible = true; DisplayPanelServerError.Visible = true; OnConnectionDisplayPanelIndicator.Visible = false; DisplayPanelServerError.Font = new Font("Segoe UI Symbo", 12F, FontStyle.Regular); OffConnectionDisplayPanelIndicator.Font = new Font("Segoe UI Symbo", 12F, FontStyle.Regular); DisplayPanelServerError.Text = @"| Ошибка соединения: Идет попытка востановления соединения, пожалуйста подождите"; DisplayPanel.ForeColor = Color.PaleVioletRed; OffConnectionDisplayPanelIndicator.ForeColor = Color.PaleVioletRed; } } catch (Exception) { } }
public void CancelGame() { worker.CancelAsync(); }
private void stopButton_Click(object sender, EventArgs e) { _controller.SetCancelFlag(true); _getImagesWorker?.CancelAsync(); SetImageCountText(); }
internal void Cancel() { Worker.CancelAsync(); Client.CancelAsync(); }
protected void CancelAsync() { _worker?.CancelAsync(); }
private void button1_Click(object sender, EventArgs e) { _worker = new BackgroundWorker(); _worker.WorkerSupportsCancellation = true; _worker.DoWork += new DoWorkEventHandler((state, args) => { int i = 0; do { if (_worker.CancellationPending) { break; } switch (Pi[i]) { case '1': Player("Sounds/a1.wav"); break; case '2': Player("Sounds/a1s.wav"); break; case '3': Player("Sounds/b1.wav"); break; case '4': Player("Sounds/c1.wav"); break; case '5': Player("Sounds/c1s.wav"); break; case '6': Player("Sounds/c2.wav"); break; case '7': Player("Sounds/d1.wav"); break; case '8': Player("Sounds/e1.wav"); break; case '9': Player("Sounds/f1.wav"); break; case '0': Player("Sounds/g1.wav"); break; default: break; } i++; } while (true); }); if (button1.Text == "Start") { _worker.RunWorkerAsync(); button1.Text = "Stop"; } else { _worker.CancelAsync(); button1.Text = "Start"; } }
private void OnlineBackupLogin_FormClosing(object sender, FormClosingEventArgs e) { bw?.CancelAsync(); }
private void _cancelButton_Click(object sender, RoutedEventArgs e) { _worker.CancelAsync(); }
private void OnUnloaded(object sender, RoutedEventArgs e) { _backgroundWorker?.CancelAsync(); }
private void FormMain_FormClosing(object sender, FormClosingEventArgs e) { _backgroundWorker?.CancelAsync(); }
public void Dispose() { _bw?.CancelAsync(); _bw = null; }
public void CancelSearch() { _worker?.CancelAsync(); }
public void TestCancelInsideDoWork() { var original = SynchronizationContext.Current; try { SynchronizationContext.SetSynchronizationContext(null); var bw = new BackgroundWorker() { WorkerSupportsCancellation = true }; var barrier = new Barrier(2); bw.DoWork += (sender, e) => { barrier.SignalAndWait(); barrier.SignalAndWait(); if (bw.CancellationPending) { e.Cancel = true; } }; bw.RunWorkerCompleted += (sender, e) => { Assert.True(e.Cancelled); barrier.SignalAndWait(); }; bw.RunWorkerAsync(); barrier.SignalAndWait(); bw.CancelAsync(); barrier.SignalAndWait(); Assert.True(barrier.SignalAndWait(TimeoutLong), "Background work timeout"); } finally { SynchronizationContext.SetSynchronizationContext(original); } }
public void Close() { _eternalQueueListener?.CancelAsync(); _queueReader?.CancelAsync(); }
private void WindowClosing() { DisableElements(); _backgroundWorker?.CancelAsync(); EnableElements(); }
public void BackgroundWorker_CancelAsync_ReportsCancelledWhenWorkerSupportsCancellationIsTrue() { UnitTestContext context = GetContext(); int numTimesProgressCalled = 0; BackgroundWorker target = new BackgroundWorker(); target.DoWork += (o, e) => { // report progress changed 10 times for (int i = 1; i < 11; i++) { Thread.Sleep(100); if (target.CancellationPending) { e.Cancel = true; return; } } }; target.WorkerSupportsCancellation = true; target.RunWorkerCompleted += (o, e) => { // target does not support ReportProgress we shold get a System.InvalidOperationException from DoWork context.Assert.IsNull(e.Error); context.Assert.IsTrue(e.Cancelled); context.Assert.Success(); }; target.RunWorkerAsync(null); target.CancelAsync(); context.Complete(); }
public bool Stop() { if (_stopped) { return(_stopped); } _started = false; _stopped = true; try { if (_worker.WorkerSupportsCancellation) { _worker?.CancelAsync(); } } catch { // ignore } // in case any train is running // let them reach their destination var tasks = GetRunningRouteThreads(); if (tasks.Count > 0) { DoWorkWithModal(progress => { for (;;) { var ts = GetRunningRouteThreads(); if (ts.Count == 0) { break; } int n = ts.Count; if (n > 1) { progress.Report($"Wait for {ts.Count} trains which run for reaching their destination."); } else { progress.Report($"Wait for one train until it reaches its final destination."); } System.Threading.Thread.Sleep(250); } }); } try { StopRouteThreads(); } catch { // ignore } if (Stopped != null) { Stopped(this, null); } return(true); }
public void StopServiceAsync() { _cameraWorker?.CancelAsync(); }
private void btnCancel_Click(object sender, EventArgs e) { importWorker?.CancelAsync(); }
public override void Stop() { _backgroundWorkerCleaning?.CancelAsync(); }
/// <summary> /// Stop Indeterminate Progress Bar Animation. /// </summary> public void DoEnd() { IsRunning = false; _bgTask?.CancelAsync(); _bgTask = null; }
public void CancelAsyncNoCancellationSupported() { var backgroundWorker = new BackgroundWorker<object, object, object>(); Assert.IsFalse(backgroundWorker.IsBusy); backgroundWorker.CancelAsync(); }