Пример #1
0
        private List <IComparableFile[]> FindSync(
            IReadOnlyCollection <FileData> srcFiles,
            ICandidatePredicate duplicateCandidatePredicate,
            IComparableFileFactory comparableFileFactory,
            CancellationToken cancellationToken)
        {
            //var stopwatch = Stopwatch.StartNew();

            var duplicateCandidates = new List <IComparableFile[]>(256);

            var fileIndex           = 0;
            var filesCount          = srcFiles.Count;
            var candidatesTotalSize = 0L;
            var candidateFilesCount = 0;

            foreach (var currentFile in srcFiles)
            {
                try
                {
                    bool IsCurrentFileAlreadyAdded(IComparableFile[] candidatesSet)
                    {
                        foreach (var candidateFile in candidatesSet)
                        {
                            if (ReferenceEquals(candidateFile.FileData, currentFile))
                            {
                                return(true);
                            }
                        }

                        return(false);
                    }

                    if (duplicateCandidates.AsParallel().Any(IsCurrentFileAlreadyAdded))
                    {
                        continue;
                    }

                    var candidates = srcFiles
                                     .AsParallel()
                                     .WithCancellation(cancellationToken)
                                     .Where(file => duplicateCandidatePredicate.IsCandidate(file, currentFile))
                                     .ToArray();

                    var candidatesLength = candidates.Length;
                    if (candidatesLength < 2)
                    {
                        continue;
                    }

                    var candidatesGroup = new IComparableFile[candidatesLength];
                    for (var index = 0; index < candidatesLength; index++)
                    {
                        var candidateFileData = candidates[index];
                        candidatesGroup[index] = comparableFileFactory.Create(candidateFileData);
                        candidatesTotalSize   += candidateFileData.Size;
                    }

                    candidateFilesCount += candidatesLength;
                    duplicateCandidates.Add(candidatesGroup);
                }
                catch (OperationCanceledException)
                {
                    throw;
                }
                catch (Exception ex)
                {
                    OnFileSystemError(currentFile.FullName, ex);
                }
                finally
                {
                    OnScanningPath(currentFile.FullName, fileIndex++, filesCount, duplicateCandidates.Count, candidateFilesCount, candidatesTotalSize);
                }
            }

            //stopwatch.Stop();
            //var elapsed = TimeSpan.FromMilliseconds(stopwatch.ElapsedMilliseconds);
            //System.Windows.MessageBox.Show($"Candidates search time: {elapsed:c}");

            return(duplicateCandidates);
        }
Пример #2
0
 public async Task <List <IComparableFile[]> > Find(IReadOnlyCollection <FileData> srcFiles, ICandidatePredicate duplicateCandidatePredicate, IComparableFileFactory comparableFileFactory, CancellationToken cancellationToken)
 {
     return(await Task.Run(() => FindSync(srcFiles, duplicateCandidatePredicate, comparableFileFactory, cancellationToken), cancellationToken));
 }