GroupBy

142 references to GroupBy

AnalyzerRunner (1)

DiagnosticAnalyzerRunner.cs (1)

134var slowestFiles = documentPerformance.OrderBy(pair => pair.Value.EditsPerSecond).GroupBy(pair => pair.Key.ProjectId);

Aspire.Dashboard.Components.Tests (1)

Controls\StructuredLogDetailsTests.cs (1)

69var duplicate = properties.GroupBy(p => p.Key).Where(g => g.Count() >= 2).FirstOrDefault();

Aspire.Hosting (1)

Dcp\ApplicationExecutor.cs (1)

1272foreach (var group in executableResources.GroupBy(e => e.ModelResource))

Aspire.Hosting.Azure.AppContainers (1)

AzureContainerAppsInfrastructure.cs (1)

345var endpointsByTargetPort = endpoints.GroupBy(e => e.TargetPort)

CodeGenerator (7)

src\Servers\Kestrel\shared\KnownHeaders.cs (7)

446var groups = values.GroupBy(header => header.EqualIgnoreCaseBytesFirstTerm()) 791HeadersByLength = requestHeaders.OrderBy(x => x.Name.Length).GroupBy(x => x.Name.Length), 798HeadersByLength = responseHeaders.OrderBy(x => x.Name.Length).GroupBy(x => x.Name.Length), 805HeadersByLength = responseTrailers.OrderBy(x => x.Name.Length).GroupBy(x => x.Name.Length), 1324{AppendSwitch(loop.Headers.GroupBy(x => x.Name.Length).OrderBy(x => x.Key))} 1503var groupedHeaders = staticHeaders.GroupBy(h => Encoding.ASCII.GetString(h.HeaderField.Name)).Select(g => 1524var groupedHeaders = staticHeaders.GroupBy(h => Encoding.ASCII.GetString(h.HeaderField.Name)).Select(g =>

InMemory.FunctionalTests (2)

Http2\Http2TestBase.cs (1)

984.GroupBy(g => g.Key)

src\Servers\Kestrel\shared\test\Http3\Http3InMemory.cs (1)

714.GroupBy(g => g.Key)

installer.tasks (1)

StaticFileRegeneration\RegenerateThirdPartyNotices.cs (1)

118.GroupBy(r => r.Repo)

IOperationGenerator (2)

IOperationClassWriter.cs (2)

103foreach (var grouping in _tree.Types.OfType<AbstractNode>().GroupBy(n => n.Namespace)) 316.GroupBy(e => e.entry.Value)

Microsoft.AspNetCore.App.Analyzers (2)

Mvc\DetectAmbiguousActionRoutes.cs (1)

36.GroupBy(ar => new ActionRouteGroupKey(ar.ActionSymbol, ar.RouteUsageModel.RoutePattern, ar.HttpMethods, controllerHasActionToken, wellKnownTypes));

RouteHandlers\DetectAmbiguousRoutes.cs (1)

32.GroupBy(u => new MapOperationGroupKey(u.MapOperation.Builder, u.ResolvedOperation!, u.MapOperation.RouteUsageModel.RoutePattern, u.MapOperation.RouteUsageModel.UsageContext.HttpMethods));

Microsoft.AspNetCore.Components.Tests (1)

Routing\RouteTableFactoryTests.cs (1)

1142.GroupBy(rt => rt.Handler)

Microsoft.AspNetCore.Grpc.Swagger (1)

Internal\XmlComments\GrpcXmlCommentsDocumentFilter.cs (1)

32.GroupBy(actionDesc => actionDesc.RouteValues["controller"]!)

Microsoft.AspNetCore.Mvc.ApiExplorer (1)

ApiDescriptionGroupCollectionProvider.cs (1)

78.GroupBy(d => d.GroupName)

Microsoft.AspNetCore.OpenApi (1)

Services\OpenApiDocumentService.cs (1)

512var groupedFormParameters = formParameters.GroupBy(parameter => parameter.ParameterDescriptor.Name);

Microsoft.AspNetCore.Routing (3)

Matching\ILEmitTrieFactory.cs (3)

106var groups = entries.GroupBy(e => e.text.Length).ToArray(); 331var groups = entries.GroupBy(e => GetUInt64Key(e.text, index)).ToArray(); 449var groups = entries.GroupBy(e => GetUInt16Key(e.text, index)).ToArray();

Microsoft.AspNetCore.Routing.Microbenchmarks (2)

src\Http\Routing\test\UnitTests\Matching\RouteMatcherBuilder.cs (1)

35.GroupBy(e => (e.Order, e.RoutePattern.InboundPrecedence, e.RoutePattern.RawText))

src\Http\Routing\test\UnitTests\Matching\TreeRouterMatcherBuilder.cs (1)

42.GroupBy(e => (e.Order, e.RoutePattern.InboundPrecedence, e.RoutePattern.RawText))

Microsoft.AspNetCore.Routing.Tests (5)

Matching\DfaMatcherBuilderTest.cs (3)

3605.GroupBy(e => e.Metadata.GetMetadata<TestMetadata1>().State) 3647.GroupBy(e => e.Metadata.GetMetadata<TestMetadata2>().State) 3672.GroupBy(e => e.Metadata.GetMetadata<TestMetadata1>().State)

Matching\RouteMatcherBuilder.cs (1)

35.GroupBy(e => (e.Order, e.RoutePattern.InboundPrecedence, e.RoutePattern.RawText))

Matching\TreeRouterMatcherBuilder.cs (1)

42.GroupBy(e => (e.Order, e.RoutePattern.InboundPrecedence, e.RoutePattern.RawText))

Microsoft.AspNetCore.Server.Kestrel.Core.Tests (6)

Http2\Http2HPackEncoderTests.cs (1)

663.GroupBy(k => k.Key)

src\Servers\Kestrel\shared\KnownHeaders.cs (5)

Microsoft.AspNetCore.Server.Kestrel.Microbenchmarks (1)

src\Servers\Kestrel\shared\test\Http3\Http3InMemory.cs (1)

714.GroupBy(g => g.Key)

Microsoft.Build.Engine.UnitTests (1)

BackEnd\BuildManager_Tests.cs (1)

3967Assert.True(_logger.AllBuildEvents.OfType<ProjectEvaluationStartedEventArgs>().GroupBy(args => args.BuildEventContext.EvaluationId).All(g => g.Count() == 1));

Microsoft.Build.Tasks.CodeAnalysis (1)

GenerateMSBuildEditorConfig.cs (1)

82var groupedItems = MetadataItems.GroupBy(i => NormalizeWithForwardSlash(i.GetMetadata("FullPath")));

Microsoft.Build.Tasks.UnitTests (1)

Hash_Tests.cs (1)

97.GroupBy(h => h)

Microsoft.Cci.Extensions (1)

Mappings\AttributesMapping.cs (1)

43var attrGroups = attributes.GroupBy(c => c.Constructor.DocId());

Microsoft.CodeAnalysis (7)

CommandLine\ReportAnalyzerUtil.cs (2)

82.GroupBy(kvp => kvp.Key.GetType().Assembly) 128.GroupBy(t => t.Generator.GetGeneratorType().Assembly)

DiagnosticAnalyzer\AnalysisResultBuilder.cs (1)

341foreach (var diagsByKey in diagnostics.GroupBy(getKeyFunc))

DiagnosticAnalyzer\AnalyzerDriver.cs (3)

1456var actionsByAnalyzers = analyzerActions.SymbolActions.GroupBy(action => action.Analyzer); 1488var actionsByAnalyzers = analyzerActions.GroupBy(action => action.Analyzer); 1832foreach (var groupedActions in symbolEndActions.GroupBy(a => a.Analyzer))

SourceGeneration\GeneratorDriver.cs (1)

33Debug.Assert(state.Generators.GroupBy(s => s.GetGeneratorType()).Count() == state.Generators.Length); // ensure we don't have duplicate generator types

Microsoft.CodeAnalysis.CodeStyle (3)

src\Analyzers\Core\Analyzers\IDEDiagnosticIdToOptionMappingHelper.cs (2)

44var groups = options.GroupBy(o => o.IsPerLanguage); 58var languageGroups = group.GroupBy(o => ((ISingleValuedOption)o).LanguageName);

src\Analyzers\Core\Analyzers\RemoveUnusedMembers\AbstractRemoveUnusedMembersDiagnosticAnalyzer.cs (1)

640foreach (var group in documentationComments.GroupBy(d => d.SyntaxTree))

Microsoft.CodeAnalysis.CodeStyle.Fixes (5)

src\Analyzers\Core\CodeFixes\MakeFieldReadonly\AbstractMakeFieldReadonlyCodeFixProvider.cs (1)

60var declaratorsByField = declarators.GroupBy(g => g.FirstAncestorOrSelf<TFieldDeclarationSyntax>()!);

src\Analyzers\Core\CodeFixes\MakeMethodSynchronous\AbstractMakeMethodSynchronousCodeFixProvider.cs (1)

159var groupedLocations = locations.GroupBy(loc => loc.Document);

src\Analyzers\Core\CodeFixes\MatchFolderAndNamespace\AbstractChangeNamespaceToMatchFolderCodeFixProvider.CustomFixAllProvider.cs (1)

78.GroupBy(diagnostic => diagnostic.Location.SourceTree)

src\Analyzers\Core\CodeFixes\UnsealClass\AbstractUnsealClassCodeFixProvider.cs (1)

61declarationReferences.GroupBy(reference => solution.GetDocumentId(reference.SyntaxTree)!))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxEditorExtensions.cs (1)

165var nodesBySemanticBoundary = originalNodePairs.GroupBy(pair => getSemanticBoundary(syntaxFacts, pair.nodes.semanticNode));

Microsoft.CodeAnalysis.CSharp (2)

BoundTree\LengthBasedStringSwitchData.cs (1)

187foreach (var group in casesWithGivenLength.GroupBy(c => c.value[bestCharacterPosition]))

Symbols\Source\ConstantEvaluationHelpers.cs (1)

276fieldsInvolvedInCycles.AddRange(graph.Keys.GroupBy(static f => f.DeclaringCompilation).

Microsoft.CodeAnalysis.CSharp.CodeStyle.Fixes (1)

src\Analyzers\CSharp\CodeFixes\UsePrimaryConstructor\CSharpUsePrimaryConstructorCodeFixProvider.cs (1)

533foreach (var group in removedMembers.Values.GroupBy(n => n.memberNode.SyntaxTree))

Microsoft.CodeAnalysis.CSharp.Features (3)

Completion\CompletionProviders\CrefCompletionProvider.cs (1)

241foreach (var group in symbols.GroupBy(s => s.Name))

InitializeParameter\CSharpInitializeMemberFromPrimaryConstructorParameterCodeRefactoringProvider.cs (1)

275foreach (var group in parameter.ContainingType.DeclaringSyntaxReferences.GroupBy(r => r.SyntaxTree))

src\Analyzers\CSharp\CodeFixes\UsePrimaryConstructor\CSharpUsePrimaryConstructorCodeFixProvider.cs (1)

533foreach (var group in removedMembers.Values.GroupBy(n => n.memberNode.SyntaxTree))

Microsoft.CodeAnalysis.CSharp.Test.Utilities (1)

CompilationTestUtils.cs (1)

464var annotationsByMethod = allAnnotations.GroupBy(annotation => annotation.Expression.Ancestors().OfType<BaseMethodDeclarationSyntax>().First()).ToArray();

Microsoft.CodeAnalysis.EditorFeatures.UnitTests (1)

CodeActions\CodeChangeProviderMetadataTests.cs (1)

63var exportedProvidersByName = exportedProviders.GroupBy(

Microsoft.CodeAnalysis.Features (11)

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.GlobalSuppressMessageFixAllCodeAction.cs (1)

74foreach (var grouping in diagnosticsByDocument.GroupBy(d => d.Key.Project))

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.RemoveSuppressionCodeAction.BatchFixer.cs (1)

135foreach (var removeSuppressionFixesForTree in attributeRemoveFixes.GroupBy(fix => fix.SyntaxTreeToModify))

CodeRefactorings\AddMissingImports\AbstractAddMissingImportsFeatureService.cs (1)

141.GroupBy(change => change.Span)

ExternalAccess\VSTypeScript\VSTypeScriptNavigateToSearchService.cs (1)

65foreach (var group in priorityDocuments.GroupBy(d => d.Project))

IntroduceParameter\AbstractIntroduceParameterCodeRefactoringProvider.cs (1)

246source: methodCallSites.GroupBy(kvp => kvp.Key.Project),

NavigateTo\NavigateToSearcher.cs (1)

360var groups = projectGroup.GroupBy(GetNavigateToSearchService);

src\Analyzers\Core\Analyzers\IDEDiagnosticIdToOptionMappingHelper.cs (1)

44var groups = options.GroupBy(o => o.IsPerLanguage);

src\Analyzers\Core\CodeFixes\MakeFieldReadonly\AbstractMakeFieldReadonlyCodeFixProvider.cs (1)

60var declaratorsByField = declarators.GroupBy(g => g.FirstAncestorOrSelf<TFieldDeclarationSyntax>()!);

src\Analyzers\Core\CodeFixes\MakeMethodSynchronous\AbstractMakeMethodSynchronousCodeFixProvider.cs (1)

159var groupedLocations = locations.GroupBy(loc => loc.Document);

src\Analyzers\Core\CodeFixes\MatchFolderAndNamespace\AbstractChangeNamespaceToMatchFolderCodeFixProvider.CustomFixAllProvider.cs (1)

78.GroupBy(diagnostic => diagnostic.Location.SourceTree)

src\Analyzers\Core\CodeFixes\UnsealClass\AbstractUnsealClassCodeFixProvider.cs (1)

61declarationReferences.GroupBy(reference => solution.GetDocumentId(reference.SyntaxTree)!))

Microsoft.CodeAnalysis.LanguageServer.Protocol (3)

Features\UnifiedSuggestions\UnifiedSuggestedActionsSource.cs (1)

393foreach (var group in actions.GroupBy(a => a.CodeActionPriority))

src\LanguageServer\Microsoft.CommonLanguageServerProtocol.Framework\AbstractLanguageServer.cs (1)

106.GroupBy(m => m.MethodName))

src\LanguageServer\Microsoft.CommonLanguageServerProtocol.Framework\RequestExecutionQueue.cs (1)

103.GroupBy(m => m.MethodName))

Microsoft.CodeAnalysis.UnitTests (1)

MetadataReferences\MetadataHelpersTests.cs (1)

451Assert.False(nestedNamespaces.GroupBy(pair => pair.Key).Where(g => g.Count() > 1).Any());

Microsoft.CodeAnalysis.Workspaces (16)

CodeFixes\FixAllOccurrences\BatchFixAllProvider.cs (2)

70foreach (var group in docIdToTextMerger.GroupBy(kvp => kvp.Key.ProjectId)) 208foreach (var group in allChangedDocumentsInDiagnosticsOrder.GroupBy(d => d.Id))

CodeFixes\FixAllOccurrences\FixAllContextHelper.cs (1)

134foreach (var (textDocument, diagnosticsForDocument) in diagnostics.GroupBy(d => solution.GetTextDocumentForLocation(d.Location)))

Diagnostics\Extensions.cs (1)

222foreach (var group in additionalPragmaSuppressionDiagnostics.GroupBy(d => d.Location.SourceTree!))

FindSymbols\ReferenceLocationExtensions.cs (2)

20var documentGroups = referenceLocations.GroupBy(loc => loc.Document); 21var projectGroups = documentGroups.GroupBy(g => g.Key.Project);

Log\StatisticResult.cs (1)

37var mode = values.GroupBy(i => i).OrderByDescending(g => g.Count()).First().Key;

ReassignedVariable\AbstractReassignedVariableService.cs (1)

198foreach (var group in containingType.DeclaringSyntaxReferences.GroupBy(r => r.SyntaxTree))

Rename\ConflictEngine\ConflictResolver.cs (1)

202foreach (var implicitReferenceLocationsPerLanguage in implicitReferenceLocations.GroupBy(loc => loc.Document.Project.Language))

Rename\ConflictEngine\ConflictResolver.Session.cs (1)

105.GroupBy(d => d.ProjectId)

Rename\ConflictEngine\MutableConflictResolution.cs (1)

153var documentToRelatedLocationsMap = this.RelatedLocations.GroupBy(loc => loc.DocumentId).ToImmutableDictionary(

Rename\SymbolicRenameLocations.ReferenceProcessing.cs (1)

335foreach (var documentsGroupedByLanguage in RenameUtilities.GetDocumentsAffectedByRename(originalSymbol, solution, renameLocations).GroupBy(d => d.Project.Language))

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxEditorExtensions.cs (1)

165var nodesBySemanticBoundary = originalNodePairs.GroupBy(pair => getSemanticBoundary(syntaxFacts, pair.nodes.semanticNode));

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\InitializeParameter\AbstractInitializerParameterService.cs (1)

206foreach (var group in accessors.GroupBy(node => node.SyntaxTree))

Workspace\Solution\SolutionCompilationState.cs (1)

803.GroupBy(static d => d.documentId.ProjectId)

Workspace\Solution\SolutionCompilationState.SkeletonReferenceCache.cs (1)

283var groups = emitResult.Diagnostics.GroupBy(d => d.Id).Select(g => $"{g.Key}:{g.Count()}");

Microsoft.CodeAnalysis.Workspaces.UnitTests (1)

CodeStyle\NamingStylePreferencesUpgradeTests.cs (1)

197var duplicates = enumNamesAndValues.GroupBy(e => e.value)

Microsoft.CommonLanguageServerProtocol.Framework.Package (2)

AbstractLanguageServer.cs (1)

106.GroupBy(m => m.MethodName))

RequestExecutionQueue.cs (1)

103.GroupBy(m => m.MethodName))

Microsoft.DotNet.Build.Tasks.Installers (1)

src\GenerateJsonObjectString.cs (1)

43foreach (var group in Properties.GroupBy(item => item.ItemSpec))

Microsoft.DotNet.Build.Tasks.Packaging (6)

CreateTrimDependencyGroups.cs (1)

73.GroupBy(dependency => dependency.TargetFramework)

GenerateRuntimeDependencies.cs (3)

89var runtimeGroups = Dependencies.GroupBy(d => d.GetMetadata("TargetRuntime")); 109var targetPackageGroups = runtimeGroup.GroupBy(d => GetTargetPackageId(d, packageAliases)); 115var dependencyGroups = targetPackageGroup.GroupBy(d => d.ItemSpec);

PromoteDependencies.cs (2)

48var refSets = dependencies.Where(d => d.Id != "_._").Where(d => d.IsReference).GroupBy(d => NuGetFramework.Parse(d.TargetFramework)).ToDictionary(g => g.Key, g => g.ToArray()); 53var libSets = dependencies.Where(d => !d.IsReference).GroupBy(d => NuGetFramework.Parse(d.TargetFramework)).ToDictionary(g => g.Key, g => g.ToArray());

Microsoft.DotNet.GenFacades (1)

GenPartialFacadeSourceGenerator.cs (1)

42IEnumerable<string> duplicates = seedNames.GroupBy(x => x)

Microsoft.DotNet.SharedFramework.Sdk (1)

src\CreateFrameworkListFile.cs (1)

98.GroupBy(f => f.Item.ItemSpec)

Microsoft.DotNet.SignTool (1)

src\SignTool.cs (1)

76var filesGroupedByCertificate = osxFilesToSign.GroupBy(fsi => fsi.SignInfo.Certificate);

Microsoft.DotNet.SourceBuild.Tasks (1)

src\WriteBuildOutputProps.cs (1)

62.GroupBy(identity => identity.Id)

Microsoft.DotNet.VersionTools (1)

Automation\PullRequestCreator.cs (1)

194.GroupBy(s => s.Emoticon)

Microsoft.Extensions.DependencyModel (2)

DependencyContextJsonReader.cs (1)

785foreach (IGrouping<string?, RuntimeTargetEntryStub> ridGroup in targetLibrary.RuntimeTargets.GroupBy(e => e.Rid))

DependencyContextWriter.cs (1)

409.GroupBy(library => library.Name + DependencyContextStrings.VersionSeparator + library.Version);

Microsoft.Extensions.Http.Resilience.Tests (1)

Helpers\OptionsUtilities.cs (1)

54.GroupBy(property => property.Name)

Microsoft.Extensions.Logging.AzureAppServices (2)

BlobLoggerProvider.cs (1)

57var eventGroups = messages.GroupBy(GetBlobKey);

FileLoggerProvider.cs (1)

43foreach (var group in messages.GroupBy(GetGrouping))

Microsoft.Extensions.Logging.Generators (1)

LoggerMessageGenerator.Parser.cs (1)

75foreach (IGrouping<SyntaxTree, ClassDeclarationSyntax> group in classes.GroupBy(x => x.SyntaxTree))

Microsoft.Extensions.Options.SourceGeneration (1)

Parser.cs (1)

50foreach (var group in classes.GroupBy(x => x.TypeSyntax.SyntaxTree))

Microsoft.Gen.ComplianceReports (1)

Parser.cs (1)

35IEnumerable<IGrouping<SyntaxTree, TypeDeclarationSyntax>> typesBySyntaxTree = classes.GroupBy(x => x.SyntaxTree);

Microsoft.Gen.Logging (1)

Parsing\Parser.cs (1)

51foreach (var group in types.GroupBy(x => x.SyntaxTree))

Microsoft.Gen.Metrics (1)

Parser.cs (1)

68foreach (var typeDeclarationGroup in types.GroupBy(x => x.SyntaxTree))

Microsoft.Gen.MetricsReports (1)

src\Generators\Microsoft.Gen.Metrics\Parser.cs (1)

68foreach (var typeDeclarationGroup in types.GroupBy(x => x.SyntaxTree))

Microsoft.Interop.ComInterfaceGenerator (1)

VtableIndexStubGenerator.cs (1)

123.SelectMany(static (data, ct) => data.GroupBy(stub => stub.ContainingSyntaxContext))

Microsoft.ML.AutoML (5)

AutoMLExperiment\AutoMLExperiment.cs (1)

224var mostRecentAddedStopServices = stopServices.GroupBy(s => s.GetType()).Select(g => g.Last()).ToList();

ColumnInference\TextFileContents.cs (1)

110var mostCommon = columnCounts.GroupBy(x => x).OrderByDescending(x => x.Count()).First();

PipelineSuggesters\PipelineSuggester.cs (2)

100history = history.GroupBy(r => r.Pipeline.Trainer.TrainerName).Select(g => g.First()); 115.GroupBy(h => h.Pipeline.Trainer.TrainerName)

Utils\UserInputValidationUtil.cs (1)

303var groups = values.GroupBy(v => v);

Microsoft.ML.Fairlearn (2)

Metrics\FairlearnMetricCatalog.cs (2)

93}).GroupBy(kv => kv.id) 186var groups = evalDf.Rows.GroupBy(r => r[sensitiveCol.Index]);

Microsoft.ML.Tests (4)

Scenarios\Api\TestApi.cs (4)

381var uniqueTrain = stratTrainWorkclass.GroupBy(x => x.ToString()).Select(x => x.First()).ToList(); 383var uniqueTest = stratTestWorkClass.GroupBy(x => x.ToString()).Select(x => x.First()).ToList(); 393var uniqueSeedTrain = stratTrainWithSeedWorkclass.GroupBy(x => x.ToString()).Select(x => x.First()).ToList(); 395var uniqueSeedTest = stratTestWithSeedWorkClass.GroupBy(x => x.ToString()).Select(x => x.First()).ToList();

Microsoft.ML.Tokenizers (1)

Model\WordPieceTokenizer.cs (1)

45SpecialTokensReverse = options.SpecialTokens is not null ? options.SpecialTokens.GroupBy(kvp => kvp.Value).ToDictionary(g => g.Key, g => g.First().Key) : null;

Microsoft.VisualStudio.LanguageServices (2)

Preview\PreviewEngine.cs (1)

162var orderedChangedDocuments = changedDocuments.GroupBy(d => d.ProjectId).OrderByDescending(g => g.Count()).Flatten();

TableDataSource\Suppression\VisualStudioSuppressionFixService.cs (1)

475foreach (var group in builder.GroupBy(kvp => kvp.Key.ProjectId))

RunTests (1)

AssemblyScheduler.cs (1)

322var tests = deserialized.GroupBy(GetTypeName)

System.Linq (2)

System\Linq\AggregateBy.cs (2)

24/// This method is comparable to the <see cref="GroupBy{TSource, TKey}(IEnumerable{TSource}, Func{TSource, TKey})"/> methods 68/// This method is comparable to the <see cref="GroupBy{TSource, TKey}(IEnumerable{TSource}, Func{TSource, TKey})"/> methods

xunit.console (1)

common\AssemblyResolution\Microsoft.Extensions.DependencyModel\DependencyContextJsonReader.cs (1)

391foreach (var ridGroup in targetLibrary.RuntimeTargets.GroupBy(e => e.Rid))