public void Process(IEnumerable<FileSystemWatcherEventArgs> watchArgs) { IEnumerable<IGrouping<string, FileSystemWatcherEventArgs>> groupedFileModifications = watchArgs .GroupBy(this.GetKey) .Select(p => p); IList<Task> jobs = new List<Task>(); foreach (var fileModifications in groupedFileModifications) { _logger.Trace("[Start]: File processing {0}", fileModifications.Key); var operationBatch = new OperationBatch(fileModifications.Key, fileModifications.ToList()); IFileOperationManager operationManager = _fileOperationManagerFactory.Create(_destinationPath); Task task = operationManager.ProcessFileOperations(operationBatch); jobs.Add(task); } try { Task.WaitAll(jobs.ToArray()); } catch (AggregateException ex) { for (int i = 0; i < ex.InnerExceptions.Count; ++i) { _logger.Error(ex.InnerExceptions[i]); } } }
public async Task ProcessFileOperations(OperationBatch operationBatch) { // TODO: seems that operation list could be analyzed and simplified. // For ex., if we have sequential changes operations then need to investigate the possibility // to reduce the graph of such operations. IList<FileSystemWatcherEventArgs> fileOperations = operationBatch.Operations; for (int i = 0; i < fileOperations.Count; ++i) { IOperation operation = _operationFactory.Create(fileOperations[i], _destinationPath); await operation.Perform(); } }
public async Task PerformSynchronization() { foreach (var file in Directory.EnumerateFiles(_sourcePath)) { _logger.Trace("[Start]: Synchronization '{0}'", file); FileSystemWatcherEventArgs args = this.CreateArgs(file); var fileOperationManager = _fileOperationManagerFactory.Create(_destinationPath); var operationBatch = new OperationBatch(file, new List<FileSystemWatcherEventArgs> {args}); try { await fileOperationManager.ProcessFileOperations(operationBatch); } catch (Exception ex) { _logger.Error(ex); } finally { _logger.Trace("[End]: Synchronization '{0}'", file); } } }