C# IReadOnlyList.GroupBy方法代码示例

        private void LoadChangeScripts()
        {
            var scripts = new DirectoryInfo(path);
            Files = scripts.GetFiles("*.sql", SearchOption.AllDirectories)
                           .Select(x => ScriptFile.Load(x))
                           .OrderBy(x => x)
                           .ToList();

            var duplicates = Files.GroupBy(x => x.FileNameHash).Where(x => x.Count() > 1);
            if (duplicates.Any())
            {
                var sb = new StringBuilder();
                foreach (var duplicate in duplicates)
                {
                    sb.AppendLine($"Duplicate Filename Detected: \"{duplicate.First().FileName}\"");
                    foreach (var file in duplicate)
                    {
                        sb.AppendLine($"\t\"{file.FilePath}\"");
                    }
                }
                sb.AppendLine();
                sb.AppendLine("All filenames must be unique. Including those in separate subdirectories.");
                throw new Exception(sb.ToString());
            }
        }

        public DeclarationFinder(
            IReadOnlyList<Declaration> declarations, 
            IEnumerable<CommentNode> comments,
            IEnumerable<IAnnotation> annotations)
        {
            _comments = comments.GroupBy(node => node.QualifiedSelection.QualifiedName)
                .ToDictionary(grouping => grouping.Key, grouping => grouping.ToArray());
            _annotations = annotations.GroupBy(node => node.QualifiedSelection.QualifiedName)
                .ToDictionary(grouping => grouping.Key, grouping => grouping.ToArray());

            _declarationsByName = declarations.GroupBy(declaration => new
                {
                    IdentifierName = declaration.Project != null && 
                        declaration.DeclarationType == DeclarationType.Project
                            ? declaration.Project.Name
                            : declaration.IdentifierName
                })
                .ToDictionary(grouping => grouping.Key.IdentifierName, grouping => grouping.ToArray());
        }

        private void LoadTypes()
        {
            m_allTypes = new LiftedList<TypeDefinition>(
                MetadataTable.TypeDef.RowCount(m_peFile),
                index => m_peFile.GetRow(new ZeroBasedIndex(index), MetadataTable.TypeDef),
                pRow => new TypeDefinition((TypeDefRow*)pRow, this),
                () => m_peFile.IsDisposed
            );

            var nestedTypes = new LiftedValueTypeList<NestedTypeInfo>(
                MetadataTable.NestedClass.RowCount(m_peFile),
                index=>m_peFile.GetRow(new ZeroBasedIndex(index), MetadataTable.NestedClass),
                x=> {
                    var pRow = (NestedClassRow*) x;
                    return new NestedTypeInfo(
                        m_allTypes[((ZeroBasedIndex)(pRow->GetNestedClass(m_peFile))).Value],
                        m_allTypes[((ZeroBasedIndex)(pRow->GetEnclosingClass(m_peFile))).Value]
                    );
                },
                ()=>m_peFile.IsDisposed
            );

            var enclosingTypes = nestedTypes.Select(x => x.NestedType.DeclaringType = x.EnclosingType).ToHashSet();
            m_allTypes.GroupBy(x => x.DeclaringType).ForEach(
                x => (x.Key ?? (IMutableTypeContainer)this).Types = x.ToList().AsReadOnly()
            );
            m_allTypes.Where(
                x => !enclosingTypes.Contains(x)
            ).ForEach(
                (IMutableTypeContainer x) => x.Types = new List<TypeDefinition>().AsReadOnly()
            );
        }

        private IReadOnlyList<RelationshipCandidate> RemoveInheritedInverseNavigations(
            IReadOnlyList<RelationshipCandidate> relationshipCandidates)
        {
            var relationshipCandidatesByRoot = relationshipCandidates.GroupBy(r => r.TargetTypeBuilder.Metadata.RootType())
                .ToDictionary(g => g.Key, g => g.ToList());
            foreach (var relationshipCandidatesHierarchy in relationshipCandidatesByRoot.Values)
            {
                var filteredRelationshipCandidates = new HashSet<RelationshipCandidate>();
                foreach (var relationshipCandidate in relationshipCandidatesHierarchy)
                {
                    RemoveInheritedInverseNavigations(
                        relationshipCandidate, relationshipCandidatesHierarchy, filteredRelationshipCandidates);
                }
            }

            return relationshipCandidates;
        }

        private int? GetDuplicatedVersion(IReadOnlyList<Migration> migrations)
        {
            int duplicatedVersion = migrations
                .GroupBy(x => x.Version)
                .Where(x => x.Count() > 1)
                .Select(x => x.Key)
                .FirstOrDefault();

            return duplicatedVersion == 0 ? (int?)null : duplicatedVersion;
        }