Exemplo n.º 1
0
        private async void Regroup(GroupingAttribute attribute, CancellationToken token)
        {
            GroupedFilesCollection rollbackGroupsBuffer = new GroupedFilesCollection(_progress);

            // Сохраним результаты предыдущей сортировки для восстановления в случае отката операции

            foreach (var group in _duplicatesCollection)
            {
                rollbackGroupsBuffer.Add(group);
            }
            // Разделим полученный ранее полный список дубликатов на группы по указанному атрибуту
            try
            {
                await _duplicatesCollection.RegroupDuplicates(attribute, token);
            }
            catch (OperationCanceledException)
            {
                _duplicatesCollection.Clear();
                // Восстановим результаты предыдущей сортировки
                foreach (var group in rollbackGroupsBuffer)
                {
                    _duplicatesCollection.Add(group);
                }
                OperationStatus status = new OperationStatus {
                    Id = SearchStatus.GroupingCanceled
                };
                ((IProgress <OperationStatus>)_progress).Report(status);
            }
        }
Exemplo n.º 2
0
 public DataModel()
 {
     Settings.Restore();
     FileSelectionOptions.Init(_settings);
     _progress             = new Progress <OperationStatus>(ReportStatus);
     _duplicatesCollection = new GroupedFilesCollection(_progress);
     _filesCollection      = new FilesGroup(_progress);
 }
        public async Task RemoveNonDuplicates(ObservableCollection <GroupingAttribute> attributeList,
                                              CancellationToken cancelToken)
        {
            IProgress <OperationStatus> progress = m_progress;
            var status = new OperationStatus
            {
                Id           = DataModel.SearchStatus.Comparing,
                TotalItems   = this[0].Count,
                HandledItems = 0,
                Stage        = string.Empty
            };

            var localAttributeList    = new List <GroupingAttribute>(attributeList);
            GroupingAttribute size    = localAttributeList.FirstOrDefault <GroupingAttribute>(a => a.Attribute == FileAttribs.Size);
            GroupingAttribute content = localAttributeList.FirstOrDefault <GroupingAttribute>(a => a.Attribute == FileAttribs.Content);

            if (content != null && size == null)
            {
                localAttributeList.Add(new GroupingAttribute("Size", FileAttribs.Size, 0));
            }


            var groupsBuffer = new GroupedFilesCollection(m_progress);

            IEnumerable <GroupingAttribute> query = from attribute in localAttributeList
                                                    orderby attribute.Attribute ascending
                                                    select attribute;

            foreach (var attribute in query)
            {
                if (attribute.Attribute == FileAttribs.None)
                {
                    continue;
                }
                status.HandledItems = 0;
                status.Stage        = attribute.Name;
                progress.Report(status);

                groupsBuffer.Clear();
                foreach (FilesGroup group in this)
                {
                    groupsBuffer.Add(group);
                }

                this.Clear();
                foreach (FilesGroup group in groupsBuffer)
                {
                    List <FilesGroup> splitResult = await group.SplitByAttribute(attribute, cancelToken, status);

                    foreach (FilesGroup newGroup in splitResult)
                    {
                        this.Add(newGroup);
                    }
                }
                m_lastAttributeUsedForGrouping = attribute;
            }
        }