/// <summary>
/// Starts a background thread and runs the current command queue.
/// When finished The WorkCompleted event will be raised.
/// </summary>
public void RunAsync(IMessenger messenger)
{
_bgWorker.DoWork += RunWorker;
_bgWorker.RunWorkerCompleted += NotifyWorkCompleted;
_bgWorker.RunWorkerAsync(messenger);
}
/// <summary>
/// Updates the given playerstatistics.
/// If the worker is currently busy, it will unsubscribe from its completed event and create a new worker to perform the update.
/// </summary>
/// <param name="playerStatistics"></param>
public void Update(IPlayerStatistics playerStatistics)
{
PlayerThatIsCurrentlyUpdated = playerStatistics.PlayerIdentity;
CreateWorkerForSingleStatisticUpdate();
_workerForSingleStatistic.RunWorkerAsync(playerStatistics);
}
public WorkerTesterResult RunWorkerAsync()
{
WorkerTesterResult result = new WorkerTesterResult();
worker.OnDoWork += (sender, e) =>
{
result.IsDoWorkCalled = true;
result.DoWorkArgument = e.Argument;
result.IsBusy = worker.IsBusy;
result.CancellationPending = worker.CancellationPending;
};
worker.OnRunWorkerCompleted += (sender, e) =>
{
result.IsRunWorkerCompletedCalled = true;
};
worker.RunWorkerAsync();
return(result);
}
private void OnLoadData()
{
IsBusy = true; // view is bound to IsBusy to show 'loading' message.
_bgworker.DoWork += (sender, e) =>
{
MyData = wcfClient.LoadData();
};
_bgworker.RunWorkerCompleted += (sender, e) =>
{
IsBusy = false;
};
_bgworker.RunWorkerAsync();
}
/// <summary>
/// Update the given collection of playerstatistics in the background, unless the worker is still busy in which case it just returns.
/// </summary>
/// <param name="playerStatistics"></param>
public void Update(IEnumerable <IPlayerStatistics> playerStatistics)
{
if (playerStatistics == null)
{
Log.Debug("Passed playerStatistics were null -> couldn't update");
return;
}
if (_workerForCollectionUpdate.IsBusy)
{
return;
}
_workerForCollectionUpdate.RunWorkerAsync(playerStatistics);
}
protected virtual void ImportHandHistoriesUsing(IHandHistoryRetriever handHistoryRetriever)
{
PrepareToImportHandHistoriesUsing(handHistoryRetriever);
_backgroundWorker.DoWork += (s, e) => {
if (_numberOfHandsToImport > 0)
{
while (!handHistoryRetriever.IsDone)
{
ImportNextBatchOfHandHistoriesUsing(handHistoryRetriever);
}
}
};
_backgroundWorker.RunWorkerCompleted += (s, e) => FinishedImportingHandHistories();
_backgroundWorker.RunWorkerAsync();
}
public void Run(RandomizerWorkerSettings settings, Action <List <AppFile> > onFinished, Action <string> onFailed, Action onCancelled)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
if (onFinished == null)
{
throw new ArgumentNullException("onFinished");
}
if (onFailed == null)
{
throw new ArgumentNullException("onFailed");
}
if (onCancelled == null)
{
throw new ArgumentNullException("onCancelled");
}
_backgroundWorker.WorkerSupportsCancellation = true;
_backgroundWorker.OnDoWork += (sender, e) =>
{
List <AppFile> filesFound = new List <AppFile>();
List <AppFile> filesToCopy = new List <AppFile>();
List <AppFile> filesExisting = new List <AppFile>();
if (!IsCancellationPending(e))
{
if (settings.DeleteFromTargetFolder)
{
foreach (AppFile info in _fileService.GetFiles(settings.PathTo))
{
if (IsCancellationPending(e))
{
return;
}
_fileService.DeleteFile(info);
}
}
}
if (!IsCancellationPending(e))
{
if (settings.OnDuplicateDoNotCopy)
{
foreach (AppFile file in _fileService.GetFiles(settings.PathTo))
{
if (IsCancellationPending(e))
{
return;
}
filesExisting.Add(file);
}
}
}
if (!IsCancellationPending(e) && settings.PathsFrom != null)
{
foreach (string path in settings.PathsFrom)
{
foreach (AppFile file in _traverseService.TraverseFolder(path))
{
if (IsCancellationPending(e))
{
return;
}
filesFound.Add(file);
}
}
}
if (!IsCancellationPending(e))
{
if (settings.SelectedLimit == LimitType.FilesTotalSize)
{
foreach (AppFile file in _fileService.GetFilesByMaxFileSize(settings.FindOnlyUniqueFiles, filesFound, filesExisting, settings.SizeLimitBytes))
{
if (IsCancellationPending(e))
{
return;
}
filesToCopy.Add(file);
}
}
else if (settings.SelectedLimit == LimitType.FilesNumber || settings.SelectedLimit == LimitType.FilesNumberPerFolder)
{
int filesNumber = 0;
if (settings.SelectedLimit == LimitType.FilesNumber)
{
filesNumber = settings.FilesNumberLimit;
}
else if (settings.SelectedLimit == LimitType.FilesNumberPerFolder)
{
filesNumber = settings.FoldersNumberLimit * settings.FilesNumberPerFolderLimit;
}
foreach (AppFile file in _fileService.GetFilesByFilesNumber(settings.FindOnlyUniqueFiles, filesFound, filesExisting, filesNumber))
{
if (IsCancellationPending(e))
{
return;
}
filesToCopy.Add(file);
}
}
}
e.Result = filesToCopy;
};
_backgroundWorker.OnRunWorkerCompleted += (sender, e) =>
{
if (e.Error != null)
{
_uiContext.Post(x => onFailed(e.Error.Message), null);
}
else if (e.Cancelled)
{
_uiContext.Post(x => onCancelled(), null);
}
else
{
_uiContext.Post(x => onFinished((List <AppFile>)e.Result), null);
}
};
if (_backgroundWorker.IsBusy)
{
_backgroundWorker.CancelAsync();
}
_backgroundWorker.RunWorkerAsync();
}
public void Run(CopyWorkerParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
if (parameters.Settings == null)
{
throw new ArgumentNullException("settings");
}
if (parameters.OnStarted == null)
{
throw new ArgumentNullException("onStarted");
}
if (parameters.OnFileChanged == null)
{
throw new ArgumentNullException("onFileChanged");
}
if (parameters.OnProgressChanged == null)
{
throw new ArgumentNullException("onProgressChanged");
}
if (parameters.OnFinished == null)
{
throw new ArgumentNullException("onFinished");
}
if (parameters.OnFailed == null)
{
throw new ArgumentNullException("onFailed");
}
if (parameters.OnCancelled == null)
{
throw new ArgumentNullException("onCancelled");
}
_backgroundWorker.WorkerReportsProgress = true;
_backgroundWorker.WorkerSupportsCancellation = true;
_backgroundWorker.OnProgressChanged += (sender, e) =>
{
_uiContext.Post(x => parameters.OnProgressChanged(e.ProgressPercentage), null);
_uiContext.Post(x => parameters.OnFileChanged((AppFile)e.UserState), null);
};
_backgroundWorker.OnDoWork += (sender, e) =>
{
_uiContext.Post(x => parameters.OnStarted(), null);
if (!IsCancellationPending(e))
{
int index = 1;
int filesCount = parameters.Settings.FilesToCopy.Count();
RenameAndSortFiles(parameters.Settings);
if (parameters.Settings.SelectedLimit == LimitType.FilesNumberPerFolder)
{
int currentFolderIndex = 0;
string pathTo = "";
int processedFilesCount = 0;
foreach (AppFile file in parameters.Settings.FilesToCopy)
{
if (currentFolderIndex == 0 || processedFilesCount == parameters.Settings.FilesPerFolderNumber)
{
++currentFolderIndex;
processedFilesCount = 0;
pathTo = string.Format("{0}/CD{1:00}", parameters.Settings.PathTo, currentFolderIndex);
_fileSystem.CreateDirectory(pathTo);
}
string filePath = string.Format(CultureInfo.CurrentCulture, "{0}/{1}", pathTo, file.FileNameFull);
// if exists skip file copy and move to the next file
if (_fileSystem.FileExists(filePath))
{
if (parameters.Settings.OnDuplicateDoNotCopy)
{
ReportProgress(file, ref index, filesCount);
continue;
}
else if (parameters.Settings.OnDuplicateOverwrite)
{
_fileSystem.DeleteFile(filePath);
}
else if (parameters.Settings.OnDuplicateAddPrefix || parameters.Settings.OnDuplicateAddSuffix)
{
file.FileNameFull = _fileHelper.GenerateUniqueFileName(file, _charsGenerator, parameters.Settings.CharsPositionOnDuplicate);
}
}
if (IsCancellationPending(e))
{
return;
}
if (currentFolderIndex > parameters.Settings.FoldersNumber)
{
break;
}
_fileSystem.CopyTo(file.FilePath, string.Format(CultureInfo.CurrentCulture, "{0}/{1}", pathTo, file.FileNameFull));
ReportProgress(file, ref index, filesCount);
++processedFilesCount;
}
}
else
{
foreach (AppFile file in parameters.Settings.FilesToCopy)
{
string filePath = string.Format(CultureInfo.CurrentCulture, "{0}/{1}", parameters.Settings.PathTo, file.FileNameFull);
// if exists skip file copy and move to the next file
if (_fileSystem.FileExists(filePath))
{
if (parameters.Settings.OnDuplicateDoNotCopy)
{
ReportProgress(file, ref index, filesCount);
continue;
}
else if (parameters.Settings.OnDuplicateOverwrite)
{
_fileSystem.DeleteFile(filePath);
}
else if (parameters.Settings.OnDuplicateAddPrefix || parameters.Settings.OnDuplicateAddSuffix)
{
file.FileNameFull = _fileHelper.GenerateUniqueFileName(file, _charsGenerator, parameters.Settings.CharsPositionOnDuplicate);
}
}
if (IsCancellationPending(e))
{
return;
}
_fileSystem.CopyTo(file.FilePath, string.Format(CultureInfo.CurrentCulture, "{0}/{1}", parameters.Settings.PathTo, file.FileNameFull));
ReportProgress(file, ref index, filesCount);
}
}
}
e.Result = true;
};
_backgroundWorker.OnRunWorkerCompleted += (sender, e) =>
{
if (e.Error != null)
{
_uiContext.Post(x => parameters.OnFailed(e.Error.Message), null);
}
else if (e.Cancelled)
{
_uiContext.Post(x => parameters.OnCancelled(), null);
}
else
{
_uiContext.Post(x => parameters.OnFinished(), null);
}
};
if (_backgroundWorker.IsBusy)
{
_backgroundWorker.CancelAsync();
}
_backgroundWorker.RunWorkerAsync();
}
