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;
}
}
