public BackgroundConnectionHelper(DoWorkEventHandler AsyncDelegate, RunWorkerCompletedEventHandler GUIDelegate, ProgressChangedEventHandler ProgressChanged) { backgroundWorker = new BackgroundWorker(); backgroundWorker.DoWork += AsyncDelegate; backgroundWorker.RunWorkerCompleted += GUIDelegate; backgroundWorker.ProgressChanged += ProgressChanged; }
public static void Remove(string path, RunWorkerCompletedEventHandler runworkerDone) { var bw = new BackgroundWorker { WorkerReportsProgress = false, WorkerSupportsCancellation = false }; bw.DoWork += RemoveFileFromIndex; bw.RunWorkerCompleted += runworkerDone; bw.RunWorkerAsync(path); }
public BackgroundConnectionHelper(DoWorkEventHandler AsyncDelegate, RunWorkerCompletedEventHandler GUIDelegate) { backgroundWorker = new BackgroundWorker(); backgroundWorker.DoWork += AsyncDelegate; backgroundWorker.RunWorkerCompleted += GUIDelegate; backgroundWorker.WorkerSupportsCancellation = true; }
private BackgroundWorker GetBackgroundWorker(DoWorkQueuedEventHandler doWork, RunWorkerCompletedEventHandler workerCompleted) { BackgroundWorker bw = new BackgroundWorker(); bw.WorkerReportsProgress = false; bw.WorkerSupportsCancellation = false; bw.DoWork += (sender, args) => { if (doWork != null) { args.Result=doWork(this, new DoWorkEventArgs(args.Argument)); } }; bw.RunWorkerCompleted += (sender, args) => { if (workerCompleted != null) { object result = args.Error == null ? args.Result : null; workerCompleted(this, new RunWorkerCompletedEventArgs(result, args.Error, args.Cancelled)); } Queue.Dequeue(); lock (_lock) { if (Queue.Count > 0) { ((BackgroundWorker)this.Queue.Peek()).RunWorkerAsync(); } } }; return bw; }
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; } }
/// <summary> /// Constructor that accepts Event handlers for executing async thread /// </summary> /// <param name="WorkerProcess">Worker Process Handler</param> /// <param name="WorkProgressHandler">Progress Changed Event Handler</param> /// <param name="WorkCompletedHandler">Call back method handler which is invoked once the Worker Process is completed</param> public WorkerHelper(DoWorkEventHandler WorkerProcess, ProgressChangedEventHandler WorkProgressHandler, RunWorkerCompletedEventHandler WorkCompletedHandler) { this.DoWork += WorkerProcess; this.ProgressChanged += WorkProgressHandler; this.RunWorkerCompleted += WorkCompletedHandler; this.WorkerReportsProgress = true; }
public FormInfo(Form owner, string Message, DoWorkEventHandler DoWork, RunWorkerCompletedEventHandler RunWorkerCompleted) { doInitialize(owner, Message, DoWork, RunWorkerCompleted, null); }
public Form1() { InitializeComponent(); this.label1.Visible = false; this.tableLayoutPanel1.Visible = false; this.pictureBox1.MouseHover += this.Control_MouseHover; this.pictureBox1.MouseWheel += this.pictureBox1_MouseWheel; this.treeView1.MouseHover += this.Control_MouseHover; this.treeView1.DragEnter += this.treeView1_DragEnter; this.treeView1.DragDrop += this.treeView1_DragDrop; this.treeView1.AfterSelect += this.treeView1_AfterSelect; this.dataGridView1.MouseHover += this.Control_MouseHover; this.dataGridView1.Columns.Add("tagName", "Tag name"); this.dataGridView1.Columns.Add("tagValue", "Tag value"); this.dataGridView1.Columns["tagName"].AutoSizeMode = DataGridViewAutoSizeColumnMode.AllCells; this.dataGridView1.Columns["tagValue"].AutoSizeMode = DataGridViewAutoSizeColumnMode.AllCells; this.dataGridView1.RowHeadersWidth = 14; this.workerCompleted = (s, e) => { this.tableLayoutPanel1.Visible = false; this.progressBar1.Value = 0; }; this.progressChanged = (s, e) => { this.progressBar1.Value = e.ProgressPercentage; }; this.fileHelper = new FileHelper(this.treeView1); this.fileHelper.zipCompleted = this.workerCompleted; this.fileHelper.zipProgressChanged = this.progressChanged; this.reader = new Reader(); }
public pgWorker(int pos, string dsn, ProgressChangedEventHandler onProgress, RunWorkerCompletedEventHandler onComplete) { this.thNo = pos; this.pg_conn = new NpgsqlConnection(dsn); try { pg_conn.Open(); pg_error = ""; } catch (Exception ex) { pg_conn = null; pg_error = ex.Message; } if (pg_conn != null) { this.bw = new BackgroundWorker(); this.bw.WorkerReportsProgress = true; this.bw.WorkerSupportsCancellation = true; this.bw.DoWork += this.bwDoWork; this.bw.ProgressChanged += onProgress; this.bw.RunWorkerCompleted += onComplete; } }
private void BackgroundCall( string service, RunWorkerCompletedEventHandler callback, Func<string,NameValueCollection,HappyIndex> serviceCall, NameValueCollection parameters = null ) { BackgroundWorker w = new BackgroundWorker(); w.RunWorkerCompleted += callback; w.DoWork += WOnDoWork; w.RunWorkerAsync(new BackgroundArgs{ Service = service, Parameters = parameters, ServiceCall = serviceCall }); }
/// <summary> /// Initializes a new instance of the <see cref="AsyncWorker"/> class. /// </summary> /// <param name="name">The name used in log messages.</param> /// <param name="worker">The worker delegate.</param> /// <param name="completed">The completed delegate.</param> public AsyncWorker( string name, DoWorkEventHandler worker, RunWorkerCompletedEventHandler completed) : this(name, worker, null, completed) { }
/// <summary> /// Creates and dispatches a PageManager to load a search page, /// parse, extract, validate and return results using the /// parameter callback EventHandlers /// </summary> /// <param name="pageNumber">Which search page number to load</param> /// <param name="criteria">The user's search criteria</param> /// <param name="pageLoadMethod">Supply the method to retrieve html</param> /// <param name="updateProgressMethod">Callback for progress updates</param> /// <param name="workerCompleteMethod">Callback when work complete</param> public PageManager(int pageNumber, SearchCriteria criteria, Func<int, string, string> pageLoadMethod, // see explanation above ProgressChangedEventHandler updateProgressMethod, RunWorkerCompletedEventHandler workerCompleteMethod) { if (pageNumber < 1) { string msg = "Supplied page number ({0}) was < 0!"; msg = string.Format(msg,pageNumber); throw new ArgumentOutOfRangeException(msg); } if (pageLoadMethod == null) { string msg = "Provided a null method to obtain page HTML!"; throw new InvalidOperationException(msg); } ProgressChanged += updateProgressMethod; // Callback RunWorkerCompleted += workerCompleteMethod; // Callback DoWork += Work; _pageLoadMethod = pageLoadMethod; _searchCriteria = criteria; _pageNumber = pageNumber; WorkerReportsProgress = true; WorkerSupportsCancellation = true; }
public static void methodAsync(int i, RunWorkerCompletedEventHandler onComplete) { BackgroundWorker bw = new BackgroundWorker(); bw.DoWork += new DoWorkEventHandler(bw_DoWork); bw.RunWorkerCompleted += onComplete; bw.RunWorkerAsync(i); }
// public void Connect() { if (!_worker.IsBusy) { this._RunWorkerCompletedEventHandler = _imageGrabber.ConnectCompletedHandler; _worker.RunWorkerAsync(_imageGrabber.ConnectHandler); } }
public static BackgroundWorker InitNewBackgroundWorker(DoWorkEventHandler doWorkEvent, ProgressChangedEventHandler progressChangedEvent, RunWorkerCompletedEventHandler runWorkerCompletedEvent) { var bw = new BackgroundWorker(); bw.RegisterDoWork(doWorkEvent); bw.RegisterProgressChanged(progressChangedEvent); bw.RegisterRunWorkerCompleted(runWorkerCompletedEvent); return bw; }
public FormInfo(Form owner, string Message, DoWorkEventHandler DoWork, RunWorkerCompletedEventHandler RunWorkerCompleted, object Argument) { doInitialize(owner, Message, DoWork, RunWorkerCompleted, Argument); }
private void SetUp(string statusText, RunWorkerCompletedEventHandler workerCompletedTask) { cdDialogPanel.Enabled = false; cdConnectButton.Enabled = false; cdTestButton.Enabled = false; cdConnectStatusLabel.Text = statusText; backgroundWorker.RunWorkerCompleted += workerCompletedTask; backgroundWorker.RunWorkerAsync(ConnectionDetail); }
private void RunBackground(DoWorkEventHandler doWork, object argument, RunWorkerCompletedEventHandler runWorkerCompleted) { using (BackgroundWorker backgroundWorker = new BackgroundWorker()) { backgroundWorker.DoWork += doWork; backgroundWorker.RunWorkerCompleted += runWorkerCompleted; backgroundWorker.RunWorkerAsync(argument); } }
public void sendEmail(string new_title, string new_body, RunWorkerCompletedEventHandler target) { BackgroundWorker worker = new BackgroundWorker(); worker.DoWork += new System.ComponentModel.DoWorkEventHandler(sendEmail); worker.RunWorkerCompleted += new System.ComponentModel.RunWorkerCompletedEventHandler(target); body = new_body; title = new_title; worker.RunWorkerAsync(); }
public void sendEmail(string new_from, string new_to, string new_reply_to, string new_title,string new_body, RunWorkerCompletedEventHandler target) { this.DoWork += new System.ComponentModel.DoWorkEventHandler(sendEmail); RunWorkerCompleted += new System.ComponentModel.RunWorkerCompletedEventHandler(target); from = new_from; to = new_to; reply_to = new_reply_to; body = new_body; title = new_title; this.RunWorkerAsync(); }
public PackingProcess(ProgressChangedEventHandler handler, RunWorkerCompletedEventHandler completedHandler) { this.DoWork += PackingProcess_DoWork; this.RunWorkerCompleted += PackingProcess_RunWorkerCompleted; this.RunWorkerCompleted += completedHandler; this.WorkerReportsProgress = true; this.WorkerSupportsCancellation = true; this.ProgressChanged += handler; IsRunning = false; IsError = false; }
public static void GetImageUrl(Filter filter, RunWorkerCompletedEventHandler callback) { Console.WriteLine("Call to GetImageUrl"); if (bgWorker == null || !bgWorker.IsBusy) { bgWorker = new BackgroundWorker(); bgWorker.DoWork += new DoWorkEventHandler(AsyncGrabImage); bgWorker.WorkerSupportsCancellation = true; bgWorker.RunWorkerCompleted += callback; bgWorker.RunWorkerAsync(filter); } }
public static void GetCardRulings(Filter filter, RunWorkerCompletedEventHandler completedDelegate) { Console.WriteLine("Call to GetCardInfo"); if(bgWorker == null || !bgWorker.IsBusy) { bgWorker = new BackgroundWorker(); bgWorker.DoWork += AsyncFindMatches; bgWorker.RunWorkerCompleted += completedDelegate; bgWorker.RunWorkerAsync(filter); } }
internal QuadResCombinBackground( MainForm UseForm, QuadResWorkerInfo WInfo ) { MForm = UseForm; DoWork += new DoWorkEventHandler( QuadResCombinBackground_DoWork ); ProgressChanged += new ProgressChangedEventHandler( QuadResCombinBackground_ProgressChanged ); RunWorkerCompleted += new RunWorkerCompletedEventHandler( QuadResCombinBackground_RunWorkerCompleted ); WorkerReportsProgress = true; WorkerSupportsCancellation = true; ProcessName = WInfo.ProcessName; }
protected AWorker(RunWorkerCompletedEventHandler when_done) { worker = new BackgroundWorker(); worker.WorkerSupportsCancellation = true; worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(worker_RunWorkerCompleted); if (when_done != null) this.Completed += when_done; worker.DoWork += new DoWorkEventHandler(preWork); worker.DoWork += new DoWorkEventHandler(worker_DoWork); }
internal ScanWorker(InputFileObject inputFileObject) { Id = DateTime.Now.Ticks; Logger.Info("Starting new ScanWorker[" + Id + "] on " + inputFileObject.SourceFileInfo.FullName); DoWork += ScanWorkerDoWork; RunWorkerCompleted += new RunWorkerCompletedEventHandler(ScanWorker_RunWorkerCompleted); WorkerReportsProgress = true; WorkerSupportsCancellation = true; ScanWorkerResult = ScanWorkerResults.NotFinished; InputFileObject = inputFileObject; }
public void RunWorkerAsync(DoWorkQueuedEventHandler doWork, RunWorkerCompletedEventHandler workerCompleted) { BackgroundWorker bw = GetBackgroundWorker(doWork, workerCompleted); Queue.Enqueue(bw); lock (_lock) { if (Queue.Count == 1) { ((BackgroundWorker)this.Queue.Peek()).RunWorkerAsync(); } } }
// Performs the task in a background worker private void BeginOperation(DoWorkEventHandler taskFunc, RunWorkerCompletedEventHandler completeFunc) { this.bw = new BackgroundWorker(); this.bw.DoWork += taskFunc; this.bw.RunWorkerCompleted += completeFunc; // Progress bar handling this.bw.WorkerReportsProgress = true; this.dl.ProgressCallback = this.bw.ReportProgress; this.bw.RunWorkerCompleted += new RunWorkerCompletedEventHandler(this.ThreadedOperationDone); this.bw.ProgressChanged += new ProgressChangedEventHandler(this.ThreadedOperationProgress); this.ThreadedOperationStart(); }
public FormInfo(Form owner, string message, DoWorkEventHandler doWork, RunWorkerCompletedEventHandler runWorkerCompleted = null, object argument = null) { InitializeComponent(); Owner = owner; InfoMessage = message; _backGroundWorkerServicer = new BackgroundWorkerServicer(); _backGroundWorkerServicer.DoWork += doWork; if (runWorkerCompleted != null) { _backGroundWorkerServicer.RunWorkerCompleted += runWorkerCompleted; } Argument = argument; }
static IBackgroundTask ExecuteOnBackgroundThread(Func<object> backgroundAction, RunWorkerCompletedEventHandler uiCallback, ProgressChangedEventHandler progressChanged) { var task = new BackgroundTask(backgroundAction); if (uiCallback != null) task.Completed += uiCallback; if (progressChanged != null) task.ProgressChanged += progressChanged; task.Start(null); return task; }
public static Guid GetGuidFromFile(string path, object sender = null, ProgressChangedEventHandler progressHandler = null, RunWorkerCompletedEventHandler completedHandler = null) { var algorithm = System.Security.Cryptography.MD5.Create(); Guid guid = HashHelper.GetGuidFromFile(algorithm, path, sender, progressHandler, completedHandler); algorithm.Dispose(); return(guid); }
/// <summary> /// 运行后台操作 /// </summary> /// <param name="backgroundWorker"></param> /// <param name="doWork"></param> /// <param name="reportProgress"></param> /// <param name="runComplete"></param> public static void RunBackgroundWorker(BackgroundWorker backgroundWorker, DoWorkEventHandler doWork, ProgressChangedEventHandler reportProgress, RunWorkerCompletedEventHandler runComplete) { ClearEventHandler(backgroundWorker, "doWorkKey"); ClearEventHandler(backgroundWorker, "progressChangedKey"); ClearEventHandler(backgroundWorker, "runWorkerCompletedKey"); backgroundWorker.WorkerReportsProgress = true; backgroundWorker.DoWork += doWork; backgroundWorker.ProgressChanged += reportProgress; backgroundWorker.RunWorkerCompleted += runComplete; backgroundWorker.RunWorkerAsync(); }
/// <summary> /// Shows the please wait window with the default status text and executes the work delegate (in a background thread). When the work /// is finished, the please wait window will be automatically closed. This method will also subscribe to the /// <see cref="BackgroundWorker.RunWorkerCompleted"/> event. /// </summary> /// <param name="workDelegate">The work delegate.</param> /// <param name="runWorkerCompletedDelegate">The run worker completed delegate.</param> public static void Show(PleaseWaitWorkDelegate workDelegate, RunWorkerCompletedEventHandler runWorkerCompletedDelegate) { Show(workDelegate, runWorkerCompletedDelegate, "Please wait...", double.NaN); }
/// <summary> /// Initializes Progress Window /// </summary> public ProgressWindow(DoWorkEventHandler work, ProgressChangedEventHandler changed, RunWorkerCompletedEventHandler complete, string message, object data, double count, Window owner, string title) { InitializeComponent(); // Init Worker Worker = new BackgroundWorker { WorkerSupportsCancellation = true, WorkerReportsProgress = true, }; Worker.ProgressChanged += ProgressChanged; Worker.RunWorkerCompleted += ProgressComplete; if (work != null) { Worker.DoWork += work; } if (changed != null) { Worker.ProgressChanged += changed; } if (complete != null) { Worker.RunWorkerCompleted += complete; } // Set up initial data DataContext = ViewModel; Owner = owner; Data = data; ViewModel.Count = count; ViewModel.Value = 0; ViewModel.Text = message; Title = title; // We only need to run the worker once loaded Loaded += StartWorker; }
public ReceivePcapOverTcpForm(PacketParser.PacketHandler packetHandler, NetworkMiner.NetworkMinerForm.AddCaseFileCallback addCaseFileCallback, SharedUtils.Pcap.PcapFileReader.CaseFileLoadedCallback caseFileLoadedCallback, RunWorkerCompletedEventHandler completedEventHandler, ushort portNumber) { this.packetHandler = packetHandler; this.addCaseFileCallback = addCaseFileCallback; this.caseFileLoadedCallback = caseFileLoadedCallback; this.completedEventHandler = completedEventHandler; InitializeComponent(); this.portNumberSelectorIncoming.Value = portNumber; this.startReceivingButton.Select(); }
public static BackgroundWorker RunSyncWork(DoWorkEventHandler doWork, RunWorkerCompletedEventHandler workCompleted) { return(RunSyncWork(doWork, workCompleted, null, true, null)); }
public void prepareToScan(IEnumerable <Fotografia> fotos, ProgressChangedEventHandler progressChanged, RunWorkerCompletedEventHandler runWorkerCompleted) { if (scansionatore != null && scansionatore.IsBusy) { throw new InvalidOperationException("scansionatore già in esecuzione"); } // Rilascio eventuale scansionatore precedente if (scansionatore != null) { scansionatore.Dispose(); } scansionatore = new BackgroundWorker(); scansionatore.WorkerReportsProgress = true; scansionatore.WorkerSupportsCancellation = true; scansionatore.DoWork += scansionatore_DoWork; // Progresso if (progressChanged != null) { scansionatore.ProgressChanged += progressChanged; } // Finale if (runWorkerCompleted != null) { scansionatore.RunWorkerCompleted += runWorkerCompleted; } scansionatore.RunWorkerCompleted += scansionatore_RunWorkerCompleted; this.fotografie = fotos; }
// TODO: cancellation token? public static BackgroundWorker CreateBackgroundWorker(DoWorkEventHandler workHandler, ProgressChangedEventHandler progressHandler = null, RunWorkerCompletedEventHandler completedHandler = null) { BackgroundWorker worker = new BackgroundWorker(); worker.DoWork += workHandler; worker.WorkerReportsProgress = progressHandler != null; worker.ProgressChanged += progressHandler; worker.RunWorkerCompleted += completedHandler; return(worker); }
public AnalyseWorker(ProgressChangedEventHandler progressChanged, RunWorkerCompletedEventHandler completed) : base(progressChanged, completed) { }
public void LoadFilesIntoLibrary(IList <string> files, ReportProgressRatio reportProgress = null, RunWorkerCompletedEventHandler callback = null) { this.fileLoadReportProgress = reportProgress; if (files != null && files.Count > 0) { BackgroundWorker loadFilesIntoLibraryBackgroundWorker = new BackgroundWorker(); loadFilesIntoLibraryBackgroundWorker.WorkerReportsProgress = true; loadFilesIntoLibraryBackgroundWorker.DoWork += new DoWorkEventHandler(loadFilesIntoLibraryBackgoundWorker_DoWork); loadFilesIntoLibraryBackgroundWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(loadFilesIntoLibraryBackgroundWorker_RunWorkerCompleted); if (callback != null) { loadFilesIntoLibraryBackgroundWorker.RunWorkerCompleted += callback; } loadFilesIntoLibraryBackgroundWorker.RunWorkerAsync(files); } }
internal void ForceMakeInactive(IMilestoneWrapper source, IMilestoneWrapper target, RunWorkerCompletedEventHandler completedEventHandler) { CheckDisposed <MainWindowData>(); if (source == null) { throw new ArgumentNullException("source"); } if (target == null) { throw new ArgumentNullException("target"); } m_BWDoWorkEventHandler = BackgroundWorker_DoForceMakeInactive; m_BWCompletedEventHandler = completedEventHandler; StartBackgroundWorker(new ForceMakeInactiveArgument() { Source = source, Target = target }); }
public static BackgroundWorker SetupBackgroundWorker( DoWorkEventHandler doWork, RunWorkerCompletedEventHandler workCompleted) { return(SetupBackgroundWorker(doWork, workCompleted, null, true)); }
private bool UnzipFile(string zip, string path, ProgressChangedEventHandler progress, RunWorkerCompletedEventHandler completed) { if (File.Exists(zip) && Directory.Exists(Path.GetDirectoryName(path))) { BackgroundWorker bw = new BackgroundWorker(); bw.WorkerReportsProgress = true; bw.WorkerSupportsCancellation = false; bw.DoWork += (sender, e) => { string zipToUnpack = zip; string unpackDirectory = path; using (ZipFile zip1 = ZipFile.Read(zipToUnpack)) { double counter = 0; double count = zip1.Count; foreach (ZipEntry entry in zip1) { counter++; entry.Extract(unpackDirectory, ExtractExistingFileAction.OverwriteSilently); bw.ReportProgress((int)(counter / count * 100)); } } }; bw.ProgressChanged += progress; bw.RunWorkerCompleted += completed; bw.RunWorkerAsync(); return(true); } else { return(false); } }
public void prepareToScan(ParamCercaFoto param, ProgressChangedEventHandler progressChanged, RunWorkerCompletedEventHandler runWorkerCompleted) { var ricercatoreSrv = LumenApplication.Instance.getServizioAvviato <IRicercatoreSrv>(); fotografie = ricercatoreSrv.cerca(param); prepareToScan(fotografie, progressChanged, runWorkerCompleted); }
/// <summary> /// Redownload files with given relative filenames. /// </summary> /// <param name="stepReport">This method will be invoked everytime the download proceed to tell the filename. This is thread-safe invoke.</param> /// <param name="downloadprogressReport">This method will be invoked everytime the download proceed. This is thread-safe invoke.</param> /// <param name="downloadFinished_CallBack">This method will be invoked when the download is finished. This is thread-safe invoke.</param> /// <returns>Bool. True if the download is succeeded, otherwise false.</returns> public static bool RedownloadFiles(ExtendedWebClient _webClient, Dictionary <string, string> fileList, EventHandler <StringEventArgs> stepReport, Func <int, int, bool> downloadprogressReport, RunWorkerCompletedEventHandler downloadFinished_CallBack) { bool continueDownload = true; Exception Myex = null; int filecount = 0; Uri currenturl = null; var asdasdads = _webClient.CacheStorage; _webClient.CacheStorage = null; List <string> failedfiles = new List <string>(); try { HttpStatusCode lastCode; byte[] buffer = new byte[1024]; //long byteprocessed, filelength; foreach (var _keypair in fileList) { if (stepReport != null) { WebClientPool.SynchronizationContext.Send(new System.Threading.SendOrPostCallback(delegate { stepReport.Invoke(_webClient, new StringEventArgs(_keypair.Key)); }), null); } using (FileStream local = File.Create(_keypair.Value, 1024)) { var _pso22fileurl = new PSO2FileUrl(Leayal.UriHelper.URLConcat(DefaultValues.Web.MainDownloadLink, _keypair.Key), Leayal.UriHelper.URLConcat(DefaultValues.Web.OldDownloadLink, _keypair.Key)); currenturl = _pso22fileurl.MainUrl; lastCode = HttpStatusCode.ServiceUnavailable; //byteprocessed = 0; //filelength = 0; try { using (HttpWebResponse theRep = _webClient.Open(currenturl) as HttpWebResponse) { if (theRep.StatusCode == HttpStatusCode.NotFound) { throw new WebException("File not found", null, WebExceptionStatus.ReceiveFailure, theRep); } else if (theRep.StatusCode == HttpStatusCode.Forbidden) { throw new WebException("Access denied", null, WebExceptionStatus.ReceiveFailure, theRep); } /*if (theRep.ContentLength > 0) * filelength = theRep.ContentLength; * else * { * HttpWebRequest headReq = _webClient.CreateRequest(currenturl, "HEAD") as HttpWebRequest; * headReq.AutomaticDecompression = DecompressionMethods.None; * HttpWebResponse headRep = headReq.GetResponse() as HttpWebResponse; * if (headRep != null) * { * if (headRep.ContentLength > 0) * filelength = headRep.ContentLength; * headRep.Close(); * } * }*/ using (var theRepStream = theRep.GetResponseStream()) { int count = theRepStream.Read(buffer, 0, buffer.Length); while (count > 0) { local.Write(buffer, 0, count); //byteprocessed += count; count = theRepStream.Read(buffer, 0, buffer.Length); } } } } catch (WebException webEx) { if (webEx.Response != null) { HttpWebResponse rep = webEx.Response as HttpWebResponse; lastCode = rep.StatusCode; } } if (lastCode == HttpStatusCode.NotFound) { currenturl = _pso22fileurl.GetTheOtherOne(currenturl.OriginalString); try { using (HttpWebResponse theRep = _webClient.Open(currenturl) as HttpWebResponse) { if (theRep.StatusCode == HttpStatusCode.NotFound) { throw new WebException("File not found", null, WebExceptionStatus.ReceiveFailure, theRep); } else if (theRep.StatusCode == HttpStatusCode.Forbidden) { throw new WebException("Access denied", null, WebExceptionStatus.ReceiveFailure, theRep); } /*if (theRep.ContentLength > 0) * filelength = theRep.ContentLength; * else * { * HttpWebRequest headReq = _webClient.CreateRequest(currenturl, "HEAD") as HttpWebRequest; * headReq.AutomaticDecompression = DecompressionMethods.None; * HttpWebResponse headRep = headReq.GetResponse() as HttpWebResponse; * if (headRep != null) * { * if (headRep.ContentLength > 0) * filelength = headRep.ContentLength; * headRep.Close(); * } * }*/ using (var theRepStream = theRep.GetResponseStream()) { int count = theRepStream.Read(buffer, 0, buffer.Length); while (count > 0) { local.Write(buffer, 0, count); //byteprocessed += count; count = theRepStream.Read(buffer, 0, buffer.Length); } } } } catch (WebException webEx) { if (webEx.Response != null) { HttpWebResponse rep = webEx.Response as HttpWebResponse; if (rep.StatusCode != HttpStatusCode.NotFound) { failedfiles.Add(_keypair.Key); } } } } else { failedfiles.Add(_keypair.Key); } } //fileList[filecount].IndexOfAny(' '); if (downloadprogressReport != null) { WebClientPool.SynchronizationContext.Send(new System.Threading.SendOrPostCallback(delegate { continueDownload = downloadprogressReport.Invoke(filecount, fileList.Count); }), null); } filecount++; } } catch (Exception ex) { Myex = ex; } _webClient.CacheStorage = asdasdads; var myevent = new RunWorkerCompletedEventArgs(failedfiles, Myex, !continueDownload); if (downloadFinished_CallBack != null) { WebClientPool.SynchronizationContext.Post(new System.Threading.SendOrPostCallback(delegate { downloadFinished_CallBack.Invoke(_webClient, myevent); }), null); } if (myevent.Error != null && !myevent.Cancelled) { if (failedfiles.Count == 0) { return(true); } } return(false); }
private BackgroundWorker GetBackgroundWorker(DoWorkQueuedEventHandler doWork, RunWorkerCompletedEventHandler workerCompleted) { BackgroundWorker bw = new BackgroundWorker(); bw.WorkerReportsProgress = false; bw.WorkerSupportsCancellation = false; bw.DoWork += (sender, args) => { if (doWork != null) { args.Result = doWork(this, new DoWorkEventArgs(args.Argument)); } }; bw.RunWorkerCompleted += (sender, args) => { if (workerCompleted != null) { object result = args.Error == null ? args.Result : null; workerCompleted(this, new RunWorkerCompletedEventArgs(result, args.Error, args.Cancelled)); } Queue.Dequeue(); lock (_lock) { if (Queue.Count > 0) { ((BackgroundWorker)this.Queue.Peek()).RunWorkerAsync(); } } }; return(bw); }
public static byte[] GetHashFromFile(string path, object sender = null, ProgressChangedEventHandler progressHandler = null, RunWorkerCompletedEventHandler completedHandler = null) { var algorithm = System.Security.Cryptography.SHA256.Create(); var hash = HashHelper.GetHashFromFile(algorithm, path, sender, progressHandler, completedHandler); algorithm.Dispose(); return(hash); }
//abonne la méthode en paramètre methodCompleted à l'évenement RunWorkerCompletedEventHandler du BackgroundWorker public void Subscribe_BackGroundWorker_Completed(RunWorkerCompletedEventHandler methodCompleted) { BGW.RunWorkerCompleted += new RunWorkerCompletedEventHandler(methodCompleted); }
public void AddRunWorkerCompleted(RunWorkerCompletedEventHandler eh) { mBw.RunWorkerCompleted += eh; }
/// <summary> /// Initializes a new instance of the <see cref="AsyncWorker"/> class. /// </summary> /// <param name="worker">The worker delegate.</param> /// <param name="completed">The completed delegate.</param> public AsyncWorker( DoWorkEventHandler worker, RunWorkerCompletedEventHandler completed) : this(null, worker, null, completed) { }
private void StartBackgroundWorker(DoWorkEventHandler doWork, ProgressChangedEventHandler progressChanged, RunWorkerCompletedEventHandler completed, object argument) { this.workBW.DoWork += doWork; this.workBW.ProgressChanged += progressChanged; this.workBW.RunWorkerCompleted += completed; this.workBW.RunWorkerAsync(argument); }
protected APCAnalyzer(CustomGameEntry game, RunWorkerCompletedEventHandler when_done) : base(game, when_done) { }
public static void startWorker(DoWorkEventHandler work, ProgressChangedEventHandler update, RunWorkerCompletedEventHandler complete) { BackgroundWorker worker = new BackgroundWorker(); worker.WorkerReportsProgress = true; worker.DoWork += work; worker.ProgressChanged += update; worker.RunWorkerCompleted += complete; worker.RunWorkerAsync(); }
protected void SetThreadEndHandlers(RunWorkerCompletedEventHandler one, RunWorkerCompletedEventHandler two, RunWorkerCompletedEventHandler three) { this.LalaOne.Worker.RunWorkerCompleted += one; this.LalaTwo.Worker.RunWorkerCompleted += two; this.LalaThree.Worker.RunWorkerCompleted += three; //this.LalaThree.Worker.RunWorkerCompleted += delegate (object o, RunWorkerCompletedEventArgs e) //{ // GameFinished(); //}; }
protected void LoadAsync(DoWorkEventHandler doWork, ProgressChangedEventHandler progressChanged, RunWorkerCompletedEventHandler runWorkerCompleted, Action <Exception> onError = null, string message = null, string subMessage = null, [CallerMemberName] string callerMemberName = "", bool forceEndOnGUIThread = false) { BeforeLoadAsync(message, subMessage, callerMemberName); if (DisableAsync) { try { doWork(null, null); if (runWorkerCompleted != null) { runWorkerCompleted(null, null); } } catch (Exception ex) { if (onError == null) { throw; } onError(ex); } return; } ShowLoading(message, subMessage, callerMemberName); var requestTime = DateTime.Now; lock (_lock) { _asyncRequests.Set(callerMemberName, requestTime); } Async.Run(doWork, progressChanged, (s, e) => { //only if its the latest request lock (_lock) { var latestRequestTime = _asyncRequests.Get(callerMemberName); if (latestRequestTime != requestTime) { return; } } HideLoading(callerMemberName); if (runWorkerCompleted != null) { try { runWorkerCompleted(s, e); } catch (Exception ex) { if (onError == null) { throw; } onError(ex); } } }, forceEndOnGUIThread: forceEndOnGUIThread); }
public bool RedownloadFiles(Dictionary <string, string> fileList, EventHandler <StringEventArgs> stepReport, Func <int, int, bool> downloadprogressReport, RunWorkerCompletedEventHandler downloadFinished_CallBack) { return(RedownloadFiles(this.myWebClient, fileList, stepReport, downloadprogressReport, downloadFinished_CallBack)); }
public AsynTask(DoWorkEventHandler doWork, RunWorkerCompletedEventHandler callBack) { worker = new BackgroundWorker(); worker.DoWork += doWork; worker.RunWorkerCompleted += callBack; }
/// <summary> /// Called when an operation was completed. /// </summary> /// <param name="asyncWorker">The asynchronous worker.</param> /// <param name="worker">The worker.</param> /// <param name="completed">The completed handler.</param> /// <param name="runWorkerCompletedEventArgs">The <see cref="System.ComponentModel.RunWorkerCompletedEventArgs"/> instance containing the event data.</param> public void CompletedExecution(AsyncWorker asyncWorker, DoWorkEventHandler worker, RunWorkerCompletedEventHandler completed, RunWorkerCompletedEventArgs runWorkerCompletedEventArgs) { if (this.log.IsDebugEnabled) { if (runWorkerCompletedEventArgs.Error == null) { this.LogOperationCompletedWithoutException(asyncWorker, worker); } else { this.LogOperationCompletedWithException(asyncWorker, worker, runWorkerCompletedEventArgs.Error); } } }
public static BackgroundWorker RunSyncWork(DoWorkEventHandler doWork, RunWorkerCompletedEventHandler workCompleted, List <object> parameters) { return(RunSyncWork(doWork, workCompleted, null, true, parameters)); }
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; } }