private void tmiStop_Click(object sender, EventArgs e) { _workTime.Dispose(); CreateWorkTime(); this.ShowInTaskbar = true; this.Show(); }
public AsyncCommandBinding(ICommand command, ExecutedRoutedEventHandler executed, CanExecuteRoutedEventHandler canExecute, RunWorkerCompletedEventHandler runWokrerCompleted) { if (command == null) { throw new ArgumentNullException("command"); } _task = new BackgroundWorker(); _task.DoWork += delegate { executed(null, null); }; _task.RunWorkerCompleted += (s, e) => { runWokrerCompleted(s, e); _task.Dispose(); }; Command = command; if (executed != null) { Executed += delegate { if (!_task.IsBusy) _task.RunWorkerAsync(); }; } if (canExecute != null) { CanExecute += canExecute; } }
private void BindList() { try { BackgroundWorker worker = new BackgroundWorker(); worker.DoWork += (o, ea) => { if (list == null) { list = new List<DataModel.TranslationEntryDiff>(); list = transManage.GetDiffStrings(); searchList = list; } Dispatcher.Invoke(new Action(() => gvList.ItemsSource = searchList)); }; worker.RunWorkerCompleted += (o, ea) => { pBar.Visibility = Visibility.Hidden; worker.Dispose(); }; SetStatusLabelValue(tsslblException, ""); pBar.Visibility = Visibility.Visible; worker.RunWorkerAsync(); } catch(Exception ex) { SetStatusLabelValue(tsslblException, ex.Message); } }
public static void StartAsync(Action a) { BackgroundWorker bg = new BackgroundWorker(); bg.DoWork += delegate { a(); }; bg.RunWorkerCompleted += delegate { bg.Dispose(); }; bg.RunWorkerAsync(); }
/// <summary> /// Starts execution of a background operation. /// </summary> /// <param name="action">The operation to be invoked by a <see cref="System.ComponentModel.BackgroundWorker"/>.</param> public static void RunWorkerAsync(Action<object, DoWorkEventArgs> action) { var w = new BackgroundWorker(); w.DoWork += (s, e) => action(s, e); w.RunWorkerCompleted += (s, e) => w.Dispose(); w.RunWorkerAsync(); }
private void search_Click(object sender, EventArgs e) { BackgroundWorker bgWorker = new BackgroundWorker(); bgWorker.DoWork += new DoWorkEventHandler(bgWorker_DoWork); bgWorker.RunWorkerAsync(); bgWorker.Dispose(); search.Enabled = false; }
private void MyToolWindow_Loaded(object sender, RoutedEventArgs e) { if (_loaded) return; var overflowGrid = explorerToolbar.Template.FindName("OverflowGrid", explorerToolbar) as FrameworkElement; if (overflowGrid != null) { overflowGrid.Visibility = Visibility.Collapsed; } //explorerToolbar.Foreground = Helpers.VSThemes.GetWindowText(); //explorerToolbar.Background = Helpers.VSThemes.GetCommandBackground(); //toolTray.Background = explorerToolbar.Background; //sep2.Background = sep1.Background = Helpers.VSThemes.GetToolbarSeparatorBackground(); TreeView1.Background = grid1.Background = Helpers.VSThemes.GetToolWindowBackground(); Updated.Visibility = System.Windows.Visibility.Collapsed; // Look for update async BackgroundWorker bw = new BackgroundWorker(); bw.DoWork += new DoWorkEventHandler(bw_DoWork); bw.RunWorkerCompleted += (s, ea) => { try { if ((Boolean)ea.Result == true) { Updated.Visibility = System.Windows.Visibility.Visible; myStoryboard.Begin(this); } else { Updated.Visibility = System.Windows.Visibility.Collapsed; } } finally { bw.Dispose(); } }; // Animate updated button DoubleAnimation myDoubleAnimation = new DoubleAnimation(); myDoubleAnimation.From = 0.1; myDoubleAnimation.To = 1.0; myDoubleAnimation.Duration = new Duration(TimeSpan.FromSeconds(5)); myDoubleAnimation.AutoReverse = true; myDoubleAnimation.RepeatBehavior = RepeatBehavior.Forever; myStoryboard = new Storyboard(); myStoryboard.Children.Add(myDoubleAnimation); Storyboard.SetTargetName(myDoubleAnimation, UpdatedText.Name); Storyboard.SetTargetProperty(myDoubleAnimation, new PropertyPath(TextBlock.OpacityProperty)); BuildDatabaseTree(); bw.RunWorkerAsync(); AddHandler(Keyboard.KeyDownEvent, (KeyEventHandler)HandleKeyDownEvent); txtConnections.Focus(); _loaded = true; }
private void cmdTrennen_Click(System.Object sender, System.EventArgs e) { if (client.IsConnected) { client.LeaveChannel(txtChannel1.Text); } client.Disconnect(); backgroundWorker1.CancelAsync(); backgroundWorker1.Dispose(); }
public DocumentUploader() { InitializeComponent(); CmsWebService service = new CmsWebService(); WindowsIdentity windowsUser = WindowsIdentity.GetCurrent(); if (windowsUser == null) { return; } List<string> temp = windowsUser.Name.Split('\\').ToList(); User user = service.GetUser(temp.Last()); ConnectionStringSettings settings = ConfigurationManager.ConnectionStrings["CmsEntities"]; EntityConnectionStringBuilder builder = new EntityConnectionStringBuilder(settings.ConnectionString); SqlConnectionStringBuilder conn = new SqlConnectionStringBuilder(builder.ProviderConnectionString); lblTitle.Text = string.Format("Document Version Imports: by {0} into {1} on {2}", user.UserName, conn.InitialCatalog, conn.DataSource); mMetaData.UserId = user.Id; using (mWorker = new BackgroundWorker()) { mWorker.WorkerSupportsCancellation = true; mWorker.WorkerReportsProgress = true; mWorker.ProgressChanged += bw_ProgressChanged; mWorker.RunWorkerCompleted += bw_RunWorkerCompleted; mWorker.DoWork += (s1, e1) => { try { if (mWorker.CancellationPending) { mWorker.CancelAsync(); mWorker.Dispose(); } else { //WORK ImportDocuments(mWorker); } } catch (ThreadAbortException) { Thread.ResetAbort(); } }; } }
private void buttonValidate_Click(object sender, EventArgs e) { var doValidate = MessageBox.Show("SnakeBite will close the Steam validation window automatically when ready, please do not cancel or close the Steam window.", "SnakeBite", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning); if (doValidate == DialogResult.Cancel) return; System.Diagnostics.Process.Start("steam://validate/287700/"); BackgroundWorker bw = new BackgroundWorker(); bw.DoWork += (obj, var) => { int sleep = 0; int maxSleep = 7500; while (true) { System.Threading.Thread.Sleep(100); sleep += 100; if(!BackupManager.GameFilesExist()) // break when files are removed by Steam { try { Microsoft.VisualBasic.Interaction.AppActivate("Validating Steam files"); SendKeys.SendWait("%{F4}"); } catch { MessageBox.Show("Unable to locate and close the Steam window, you may need to launch Steam before trying again, or validate manually through the Steam application.", "Steam Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } break; } if (sleep >= maxSleep) // break on timeout { try { Microsoft.VisualBasic.Interaction.AppActivate("Validating Steam files"); SendKeys.SendWait("%{F4}"); } catch { MessageBox.Show("Timed out waiting for Steam window. Please launch Steam before trying again, or validate manually through the Steam application.", "Steam Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } break; } } bw.Dispose(); }; bw.RunWorkerAsync(); BackupManager.DeleteOriginals(); }
private void importBtn_Click(object sender, EventArgs e) { string SelectExcelFile = filePath.Text; if (string.IsNullOrEmpty(SelectExcelFile)) { errorMsg.Text = "Excel文件不能为空!"; return; } this.importBtn.Enabled = false; this.pictureBox1.Visible = true; BackgroundWorker worker = new BackgroundWorker(); worker.DoWork += new DoWorkEventHandler(worker_DoWork); worker.RunWorkerAsync(); worker.Dispose(); }
public static void Show(string WindowTitle, string ProgressText, Action WorkerFunction) { var progressWindow = new formProgress(); progressWindow.StatusText.Text = ProgressText; var progressWorker = new BackgroundWorker(); progressWorker.DoWork += (obj, var) => { WorkerFunction(); progressWindow.Invoke((MethodInvoker)delegate { progressWindow.Close(); }); progressWorker.Dispose(); }; progressWorker.RunWorkerAsync(); progressWindow.ShowDialog(); }
public static void Kill(object parameter) { BackgroundWorker worker = new BackgroundWorker(); worker.DoWork += async (sender, args) => { var textBlock = parameter as TextBlock; if (textBlock != null) await textBlock.Dispatcher.InvokeAsync(async () => { FastbootTools.Kill(); await textBlock.Dispatcher.InvokeAsync(() => textBlock.Text = "FASTBOOT KILLED"); }); }; worker.RunWorkerCompleted += (sender, args) => worker.Dispose(); worker.RunWorkerAsync(); }
public static void Prepare(object parameter) { BackgroundWorker worker = new BackgroundWorker(); worker.DoWork += async (sender, args) => { var textBlock = parameter as TextBlock; if (textBlock != null) await textBlock.Dispatcher.InvokeAsync(async () => { Fastboot = new FastbootTools(textBlock); await Fastboot.Prepare(); }); }; worker.RunWorkerCompleted += (sender, args) => worker.Dispose(); worker.RunWorkerAsync(); }
public void SaveFile(string SVFile, List <string> Data, System.ComponentModel.BackgroundWorker worker, System.ComponentModel.DoWorkEventArgs e) { CurrentState state = new CurrentState(); int counter = 0; string TextSent = ""; string tempTxt = ""; // SVFile.DefaultExt = ".txt"; using (System.IO.StreamWriter file = new System.IO.StreamWriter(SVFile, false)) { for (int y = 0; y <= Data.Count - 1;) { if ((worker.CancellationPending == true)) { e.Cancel = true; worker.Dispose(); worker = null; GC.Collect(); MessageBox.Show("Canceled"); break; } TextSent = ""; for (int x = 0; x <= columns - 1; x++) { if (x + y != Data.Count) { TextSent += Data[y + x] + " "; } } TextSent = Data[y] + " " + Data[y + 1] + " " + Data[y + 2] + " " + Data[y + 3] + " " + Data[y + 4] + " " + Data[y + 5] + " " + Data[y + 6] + " " + Data[y + 7] + " " + Data[y + 8] + " " + Data[y + 9] + " " + Data[y + 10]; file.WriteLine(TextSent); y += columns; counter++; if (counter % 100 == 0) { state.LinesCounted = counter; state.DataStorage = Data; worker.ReportProgress(0, state); } } } if (worker != null) { MessageBox.Show("Finished saving the file."); } }
public void Stop() { nf.AddToINFO($@"Closing Measurment."); Application.DoEvents(); measWorker.CancelAsync(); while (measWorker.CancellationPending) { nf.AddToINFO($@"Cancellation pending...", InfoLine); Thread.Sleep(1000); measWorker.Dispose(); Application.DoEvents(); } nf.AddToINFO($@"Measurment is closed.", InfoLine); WorkerEndOutput(); Application.DoEvents(); }
public static void ExecuteListDevices(object parameter) { UIParameters parameters = (UIParameters)parameter; if (parameters != null) { Context = parameters.Context; BackgroundWorker worker = new BackgroundWorker(); worker.DoWork += async (sender, args) => { await Context.Dispatcher.InvokeAsync(async () => { _adb = new AdbTools(Context); await _adb.ListDevices(parameters.Context2, parameters.Bool); }); }; worker.RunWorkerCompleted += (sender, args) => worker.Dispose(); worker.RunWorkerAsync(); } }
public void path_DoubleClick(object sender, MouseButtonEventArgs e) { FolderBrowserDialog way = new FolderBrowserDialog(); DialogResult result = way.ShowDialog(); if (result == System.Windows.Forms.DialogResult.OK) { path.Text = way.SelectedPath; picName = (Directory.GetFiles(path.Text, "*jpg")).ToList(); ShowImage(picName[0]); progress.Value = 0; progress.Maximum = picName.Count; bw = new BackgroundWorker(); bw.WorkerReportsProgress = true; bw.DoWork += bw_DoWork; bw.ProgressChanged += bw_ProgressChanged; bw.RunWorkerAsync(); bw.Dispose(); } }
public void Generate(int size, RenderContext context) { m_Context = context; m_Worker = new BackgroundWorker(); m_Worker.WorkerReportsProgress = true; m_Worker.WorkerSupportsCancellation = true; m_Worker.DoWork += bgw_DoWork; //Work Event m_Worker.RunWorkerCompleted += m_Worker_RunWorkerCompleted; //Event that is run in the background; Console.WriteLine("Opening new Thread"); m_Worker.RunWorkerAsync(size); m_Worker.CancelAsync(); m_Worker.Dispose(); }
private void Window_Loaded(object sender, RoutedEventArgs e) { lblPath.Text = ConfigurationManager.AppSettings["PathOnNova"].ToString(); BackgroundWorker worker = new BackgroundWorker(); worker.DoWork += (o, ea) => { for (int i = 10; i > 0; i--) { Thread.Sleep(1000); ChangeButtonText(btnClose, "Close after " + (i - 1).ToString() + " seconds"); } }; worker.RunWorkerCompleted += (o, ea) => { Application.Current.Shutdown(); worker.Dispose(); }; worker.RunWorkerAsync(); }
private void Dispose(bool disposing) { if (!this.disposed) { if (disposing) { try { if (_WaitDialog != null) { _WaitDialog.Close(); } _WaitDialog = null; _WorkThread.Dispose(); } catch { } } disposed = true; } }
public void UpdateCount(System.ComponentModel.BackgroundWorker worker, System.ComponentModel.DoWorkEventArgs e) { int temp = 0; //while (temp != 9999999999999) //{ temp += 1; // while (flag == false) // { state.LinesCounted = count; worker.ReportProgress(0, state); if ((worker.CancellationPending == true)) { e.Cancel = true; worker.Dispose(); worker = null; GC.Collect(); MessageBox.Show("Canceled"); // break; } // } }
private void InitializeUpdater() { updater = Utilities.Updater.Instance(this); BackgroundWorker worker = new BackgroundWorker(); worker.WorkerReportsProgress = true; worker.DoWork += new DoWorkEventHandler( delegate (object o, DoWorkEventArgs args) { BackgroundWorker theWorker = o as BackgroundWorker; while (true) { // Wait 5 seconds before checking, we don't want to blast the popup in their face Thread.Sleep(5000); theWorker.ReportProgress((updater.CheckForUpdates() ? 100 : 1)); Thread.Sleep(300000); } }); worker.ProgressChanged += new ProgressChangedEventHandler( delegate (object o, ProgressChangedEventArgs args) { if (args.ProgressPercentage == 100) { updater.StartDownload(); } }); worker.RunWorkerAsync(); FormClosing += (send, e) => { // Garbage collect the background worker worker.Dispose(); }; }
private void Grabar() { WebcamCtrl.StartRecording(); stopWatch.Start(); dt.Start(); BackgroundWorker bw = new BackgroundWorker(); bw.DoWork += new DoWorkEventHandler(bw_DoWork); // bw.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bw_RunWorkerCompleted); bw.RunWorkerCompleted += (s, e) => { try { if (e.Error != null) { // Handle failure. } } finally { // Use wkr outer instead of casting. bw.Dispose(); } }; // Kick off the Async thread bw.RunWorkerAsync(); }
private void RunBackGround(string targ) { BackgroundWorker W = new BackgroundWorker(); switch (targ) { case ND: W.DoWork += new DoWorkEventHandler(NoD); break; case NV: W.DoWork += new DoWorkEventHandler(NoV); break; } W.RunWorkerAsync(); W.Dispose(); }
private void lnkGoogleAPI_Elevation_Get_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e) { try { BackgroundWorker bgw = new BackgroundWorker(); bgw.DoWork += delegate (object bgwSender, DoWorkEventArgs bgwEvent) { using (Process process = new Process()) { process.StartInfo.UseShellExecute = true; process.StartInfo.FileName = "https://developers.google.com/maps/documentation/elevation/get-api-key"; process.Start(); } }; bgw.RunWorkerCompleted += delegate (object bgwSender, RunWorkerCompletedEventArgs bgwEvent) { bgw.Dispose(); }; bgw.RunWorkerAsync(); } catch (Exception x) { MessageBox.Show(x.Message, Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error); } }
public static void ExecuteReboot(object parameter) { SingleCommandParameters parameters = (SingleCommandParameters)parameter; Context = parameters.Context; BackgroundWorker worker = new BackgroundWorker(); worker.DoWork += async (sender, args) => { await Context.Dispatcher.InvokeAsync(() => { _adb = new AdbTools(Context); }); await Task.Run(async () => await _adb.Reboot(parameters.Bool, parameters.Target)); }; worker.RunWorkerCompleted += (sender, args) => worker.Dispose(); worker.RunWorkerAsync(); }
public static void ExecutePrepare(object parameter) { Context = (TextBlock)parameter; BackgroundWorker worker = new BackgroundWorker(); worker.DoWork += async (sender, args) => { await Context.Dispatcher.InvokeAsync(() => { _adb = new AdbTools(Context); }); await Task.Run(async () => await _adb.Prepare()); }; worker.RunWorkerCompleted += (sender, args) => worker.Dispose(); worker.RunWorkerAsync(); }
public static void ExecuteRemoteDisconnect(object parameter) { SingleCommandParameters parameters = parameter as SingleCommandParameters; if (parameters != null) { Context = parameters.Context; BackgroundWorker worker = new BackgroundWorker(); worker.DoWork += async (sender, args) => { await Context.Dispatcher.InvokeAsync(async () => { _adb = new AdbTools(Context); await _adb.RemoteDisconnect(parameters.Bool); }); }; worker.RunWorkerCompleted += (sender, args) => worker.Dispose(); worker.RunWorkerAsync(); } }
public static void ExecuteSingleCommand(object parameter) { TwoCommandParameters parameters = parameter as TwoCommandParameters; if (parameters != null) { Context = parameters.Context; BackgroundWorker worker = new BackgroundWorker(); worker.DoWork += async (sender, args) => { await Context.Dispatcher.InvokeAsync(async () => { _adb = new AdbTools(Context); var cmds = new string[1]; cmds[0] = parameters.Text; await _adb.Execute(cmds, parameters.Bool, parameters.Target); }); }; worker.RunWorkerCompleted += (sender, args) => worker.Dispose(); worker.RunWorkerAsync(); } }
public static void ExecutePull(object parameter) { FiveTextCommandParameters parameters = (FiveTextCommandParameters)parameter; Context = parameters.Context; BackgroundWorker worker = new BackgroundWorker(); worker.DoWork += async (sender, args) => { await Context.Dispatcher.InvokeAsync(async () => { _adb = new AdbTools(Context); String[] paths = new string[4]; if (!string.IsNullOrEmpty(parameters.Text2)) paths[0] = parameters.Text2; if (!string.IsNullOrEmpty(parameters.Text3)) paths[1] = parameters.Text3; if (!string.IsNullOrEmpty(parameters.Text4)) paths[2] = parameters.Text4; if (!string.IsNullOrEmpty(parameters.Text5)) paths[3] = parameters.Text5; await _adb.Pull(parameters.Text, parameters.Bool, paths, parameters.Target); }); }; worker.RunWorkerCompleted += (sender, args) => worker.Dispose(); worker.RunWorkerAsync(); }
public static void ExecuteRoot(object parameter) { var parameters = (RootParameters)parameter; Context = parameters.Context; AdbTools adb = new AdbTools(Context); BackgroundWorker worker = new BackgroundWorker(); worker.DoWork += async (sender, args) => { await parameters.Window.Dispatcher.InvokeAsync(async () => { if (parameters.SuperSU || parameters.SuperUser) { if (ConnectionChecker.IsConnectedToInternet) { var controller = await parameters.Window.ShowProgressAsync("Please wait", "Downloading...", false, new MetroDialogSettings() { AnimateShow = true, AnimateHide = true, ColorScheme = MetroDialogColorScheme.Theme }); if (parameters.SuperUser) { await DownloadFile("http://www.file.appsapk.com/download/Superuser.apk", "Superuser.apk", parameters.Window, controller); if (File.Exists("Superuser.apk")) { await adb.Root(parameters.CreateNoWindow, parameters.Target); } else { await parameters.Window.ShowMessageAsync("Unknown error", null); } } if (parameters.SuperSU) { await DownloadFile("http://www.file.appsapk.com/download/SuperSU.apk", "Superuser.apk", parameters.Window, controller); if (File.Exists("Superuser.apk")) { await adb.Root(parameters.CreateNoWindow, parameters.Target); } else { await parameters.Window.ShowMessageAsync("Unknown error", null); } } } else { await parameters.Window.ShowMessageAsync("Error", "You must have an internet connection."); } } else { await parameters.Window.ShowMessageAsync("Error", "You must select app"); } }); }; worker.RunWorkerCompleted += (sender, args) => worker.Dispose(); worker.RunWorkerAsync(); }
public void SearchFile(string FileName, List <string> Search, System.ComponentModel.BackgroundWorker worker, System.ComponentModel.DoWorkEventArgs e) { CurrentState state = new CurrentState(); int counter = 0; List <String> TempList = new List <string>(); int tempint = 0; string ReadLine; int SizeCheck = 0; int HexCounter = 0; using (FileStream fs = File.Open(FileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) using (BufferedStream bs = new BufferedStream(fs)) using (StreamReader sr = new StreamReader(bs)) { while ((ReadLine = sr.ReadLine()) != null) { if ((worker.CancellationPending == true)) { e.Cancel = true; worker.Dispose(); worker = null; GC.Collect(); MessageBox.Show("Canceled"); break; } bool RFlag = false; int TempCounter = 0; string TempString = ""; for (int x = 0; x <= ReadLine.Length - 1; x++) { char df = ReadLine[x]; if (ReadLine[x] != ',') { while (ReadLine[x] != ',') { TempString += ReadLine[x]; if (x != ReadLine.Length - 1) { x++; } else { break; } } if (TempCounter == 0) { foreach (string search in Search) { // Search.GetSelected(0) // string txt = Search.Text.ToString(); if (search == TempString) { if (TempCounter == 1 && TempString != "X") { TempDataStorage.Add(""); TempCounter++; TempDataStorage.Add(TempString); } else { TempDataStorage.Add(TempString); } if (TempCounter == 2) { tempint = Convert.ToInt16(TempString); SizeCheck = 8 - Convert.ToInt16(TempString); } if (SizeCheck != 0) { if (2 + tempint == TempCounter) { for (int Rows = 0; Rows < SizeCheck; Rows++) { TempDataStorage.Add(""); TempCounter++; } } } } } } counter++; if (counter % 100 == 0) { state.LinesCounted = counter; state.DataStorage = TempDataStorage; worker.ReportProgress(0, state); } TempCounter++; TempString = ""; } } } if (worker != null) { MessageBox.Show("Finished searching the file."); } } }
protected override void OnDestroyed() { if (searchBackgoundWorker != null && searchBackgoundWorker.IsBusy) { searchBackgoundWorker.CancelAsync(); searchBackgoundWorker.Dispose(); searchBackgoundWorker = null; } if (this.TreeView != null) { // Dispose (TreeView.GetRootNode ()); TreeView.Tree.CursorChanged -= HandleCursorChanged; this.TreeView.Clear(); this.TreeView = null; } if (definitions != null) { definitions.Clear(); definitions = null; } ActiveMember = null; if (memberListStore != null) { memberListStore.Dispose(); memberListStore = null; } if (typeListStore != null) { typeListStore.Dispose(); typeListStore = null; } if (documentationPanel != null) { documentationPanel.Destroy(); documentationPanel = null; } if (inspectEditor != null) { inspectEditor.LinkRequest -= InspectEditorhandleLinkRequest; inspectEditor.Destroy(); inspectEditor = null; } if (this.UIManager != null) { this.UIManager.Dispose(); this.UIManager = null; } this.languageCombobox.Changed -= LanguageComboboxhandleChanged; // this.searchInCombobox.Changed -= SearchInComboboxhandleChanged; // this.searchEntry.Changed -= SearchEntryhandleChanged; this.searchTreeview.RowActivated -= SearchTreeviewhandleRowActivated; hpaned1.ExposeEvent -= HPaneExpose; PropertyService.PropertyChanged -= HandlePropertyChanged; base.OnDestroyed(); }
private long MeasureProgressUpdateCost(bool doMakeProgressCalls, int iterationsToDo) { _dialog = new ProgressDialog(); BackgroundWorker worker = new BackgroundWorker(); worker.DoWork += OnDoSomeWork; _dialog.BackgroundWorker = worker; WorkArguments args = new WorkArguments(); args.doMakeProgressCalls = doMakeProgressCalls; args.secondsToUseUp = 0; args.iterationsToDo = iterationsToDo; _dialog.ProgressState.Arguments = args; Stopwatch w = new Stopwatch(); w.Start(); _dialog.ShowDialog(); _dialog.Close(); _dialog.Dispose(); _dialog = null; w.Stop(); worker.Dispose(); Debug.WriteLine("Took "+ w.Elapsed); return w.ElapsedMilliseconds; }
public static void Execute(object parameter) { ExecuteCommandParameters parameters = parameter as ExecuteCommandParameters; if (parameters != null) { Context = parameters.Context; BackgroundWorker worker = new BackgroundWorker(); worker.DoWork += async (sender, args) => { await Context.Dispatcher.InvokeAsync(async () => { _adb = new AdbTools(Context); var cmds = new List<string> { parameters.Text, parameters.Text2, parameters.Text3, parameters.Text4, parameters.Text5, parameters.Text6, parameters.Text7, parameters.Text8, parameters.Text9, parameters.Text10 }; await _adb.Execute(cmds.ToArray<string>(), parameters.Bool, parameters.Target); }); }; worker.RunWorkerCompleted += (sender, args) => worker.Dispose(); worker.RunWorkerAsync(); } }
public static void ExecuteBackup(object parameter) { BackupParameters parameters = parameter as BackupParameters; if (parameters != null) { Context = parameters.Context; BackgroundWorker worker = new BackgroundWorker(); worker.DoWork += async (sender, args) => { await Context.Dispatcher.InvokeAsync(async () => { _adb = new AdbTools(Context); if (parameters.Context2.SelectedIndex == 0) { await _adb.Backup(parameters.Text, parameters.Text2, AdbBackupMode.All, parameters.Bool, parameters.Target); } if (parameters.Context2.SelectedIndex == 1) { await _adb.Backup(parameters.Text, parameters.Text2, AdbBackupMode.Apps, parameters.Bool, parameters.Target); } if (parameters.Context2.SelectedIndex == 2) { await _adb.Backup(parameters.Text, parameters.Text2, AdbBackupMode.SystemApps, parameters.Bool, parameters.Target); } if (parameters.Context2.SelectedIndex == 3) { await _adb.Backup(parameters.Text, parameters.Text2, AdbBackupMode.AppsWithoutSystemApps, parameters.Bool, parameters.Target); } if (parameters.Context2.SelectedIndex == 4) { await _adb.Backup(parameters.Text, parameters.Text2, AdbBackupMode.SDCard, parameters.Bool, parameters.Target); } }); }; worker.RunWorkerCompleted += (sender, args) => worker.Dispose(); worker.RunWorkerAsync(); } }
private void coordinator(object obj) { coordinatorIsRunning = true; coordinatorPos = positionReader; //readerWaitEvent.Set(); readerBackgroundWorker = new BackgroundWorker(); readerBackgroundWorker.DoWork += fillBuffer; readerBackgroundWorker.RunWorkerAsync(); readBufferWorkerIsRunning = true; while (!stopCoordinator && (coordinatorPos < readVidInfo.frameCount)) { if ((internalBuffer.Count < 1) && !stopCoordinator && readBufferWorkerIsRunning) { waitForCoordinatorBufferToEmpty_WaitEvent.Set(); waitForCoordinatorBufferToFill_WaitEvent.WaitOne(); } if (((coordinatorPos - positionReader) > NUMFRAMESINMEM) && buffer && !stopCoordinator) { coordinatorWaitEvent.WaitOne(); } if (internalBuffer.Count > 0) { var ctx = internalBuffer.Dequeue(); currentHandle = (ctx as extractBitmapContext).doneEvent; (ctx as extractBitmapContext).doneEvent.WaitOne(); readQueue.Enqueue((ctx as extractBitmapContext)._currFrame); getFrameWaitEvent.Set(); coordinatorPos++; } if (buffer) { if (internalBuffer.Count < NUMFRAMESINMEM) { waitForCoordinatorBufferToEmpty_WaitEvent.Set(); //readerWaitEvent.Set(); } } else break; } stopReadBufferWorker = true; waitForCoordinatorBufferToEmpty_WaitEvent.Set(); waitForCoordinatorBufferToFill_WaitEvent.Set(); while (readBufferWorkerIsRunning) { waitForCoordinatorBufferToEmpty_WaitEvent.Set(); waitForCoordinatorBufferToFill_WaitEvent.Set(); Thread.Sleep(20); } stopReadBufferWorker = false; readerBackgroundWorker.Dispose(); readerBackgroundWorker = null; getFrameWaitEvent.Set(); coordinatorIsRunning = false; }
//public void public void ChopeFile(string OPFile, string SVFile, System.ComponentModel.BackgroundWorker worker, System.ComponentModel.DoWorkEventArgs e) { CurrentState state = new CurrentState(); bool flag = false; // Check = false; List <String> TempList = new List <string>(); int FileCounter = 0; int tempint = 0; int counter = 0; string ReadLine; int SizeCheck = 0; int HexCounter = 0; string TextSent = ""; string tempTxt = ""; //SVFile.DefaultExt = ".txt"; //e.Value = DataStorageY[e.ColumnIndex][e.RowIndex]; System.IO.StreamReader sz = new System.IO.StreamReader(OPFile); using (FileStream fs = File.Open(OPFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) using (BufferedStream bs = new BufferedStream(fs)) using (StreamReader sr2 = new StreamReader(bs)) { for (int read = 0; read <= 23; read++) { ReadLine = sr2.ReadLine(); } using (System.IO.StreamWriter file = new System.IO.StreamWriter(SVFile, false)) { while ((ReadLine = sr2.ReadLine()) != null) { if ((worker.CancellationPending == true)) { e.Cancel = true; worker.Dispose(); worker = null; GC.Collect(); MessageBox.Show("Canceled"); break; } bool RFlag = false; int TempCounter = 0; string TempString = ""; for (int x = 0; x <= ReadLine.Length - 1; x++) { if (ReadLine[x] == 'R') { ReadLine = ReadLine.Replace('R', ' '); int df = 34; RFlag = true; } int dffs = 34; } if (RFlag == false) { for (int x = 0; x <= ReadLine.Length - 1; x++) { char df = ReadLine[x]; if (ReadLine[x] != ' ') { while (ReadLine[x] != ' ') { TempString += ReadLine[x]; if (x != ReadLine.Length - 1) { x++; } else { break; } } if (TempString == "416") { flag = true; break; } else { flag = false; } if (TempCounter == 2 && TempString != "X") { TempRow[TempCounter] = ""; TempCounter++; TempRow[TempCounter] = TempString; } else { TempRow[TempCounter] = TempString; } if (TempCounter == 3) { tempint = Convert.ToInt16(TempString); SizeCheck = 8 - Convert.ToInt16(TempString); } if (SizeCheck != 0) { if (4 + tempint == TempCounter) { for (int Rows = 0; Rows < SizeCheck; Rows++) { TempRow[TempCounter] = ""; TempCounter++; } } } TempCounter++; TempString = ""; } } } if (TempRow[12] == "183") { int dsd = 34; } if (flag == false) { TextSent = TempRow[1] + "," + TempRow[3] + "," + TempRow[4] + "," + TempRow[5] + "," + TempRow[6] + "," + TempRow[7] + "," + TempRow[8] + "," + TempRow[9] + "," + TempRow[10] + "," + TempRow[11]; file.WriteLine(TextSent); //label1.Name = "Lines Saved: " + TempRow[12]; for (int x = 0; x <= 12; x++) { TempRow[x] = ""; } } counter++; if (counter % 100 == 0) { state.LinesCounted = counter; worker.ReportProgress(0, state); } } } } if (worker != null) { MessageBox.Show("Finished condensing the file."); } }