GroupBy

278 references to GroupBy

aspire (8)

Commands\AddCommand.cs (2)

391.GroupBy(p => p.Channel) 460.GroupBy(p => p.Package.Id)

Commands\DoctorCommand.cs (1)

98.GroupBy(r => r.Category)

Commands\NewCommand.cs (1)

318.GroupBy(cp => cp.Channel)

Commands\Sdk\SdkDumpCommand.cs (1)

479.GroupBy(c => c.OwningTypeName ?? "Extension Methods")

Commands\TelemetryTracesCommand.cs (1)

365.GroupBy(s => s.ParentSpanId!)

Mcp\Tools\ListIntegrationsTool.cs (1)

109.GroupBy(p => p.PackageId)

Projects\ProjectUpdater.cs (1)

46.GroupBy(step => step.ProjectFile.FullName)

Aspire.Cli.Tests (5)

Commands\ExportCommandTests.cs (2)

779.GroupBy(e => (e.serviceName, e.instanceId)) 822.GroupBy(e => (e.serviceName, e.instanceId))

Commands\TelemetryLogsCommandTests.cs (1)

120.GroupBy(e => (e.serviceName, e.instanceId))

Commands\TelemetrySpansCommandTests.cs (1)

120.GroupBy(e => (e.serviceName, e.instanceId))

Commands\TelemetryTracesCommandTests.cs (1)

168.GroupBy(e => (e.serviceName, e.instanceId))

Aspire.Confluent.Kafka.Tests (1)

OtelMetricsTests.cs (1)

115.GroupBy(x => x.Name).ToArray();

Aspire.Dashboard (11)

Model\Assistant\AssistantChatViewModel.cs (1)

384.GroupBy(m => m.Family)

Model\Otlp\SpanWaterfallViewModel.cs (1)

131var groupedLogs = logs.GroupBy(l => l.SpanId).ToDictionary(l => l.Key, g => g.ToList());

Model\TelemetryExportService.cs (9)

232.GroupBy(l => l.ResourceView.ResourceKey) 240.GroupBy(l => l.Scope) 278.GroupBy(s => s.Source.ResourceKey) 286.GroupBy(s => s.Scope) 337.GroupBy(s => s.Source.ResourceKey) 345.GroupBy(s => s.Scope) 454.GroupBy(l => l.ResourceView.ResourceKey) 462.GroupBy(l => l.Scope) 475var instrumentsByScope = instruments.GroupBy(i => i.Summary.Parent);

Aspire.Dashboard.Components.Tests (1)

Controls\StructuredLogDetailsTests.cs (1)

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

Aspire.Hosting (4)

Dcp\DcpExecutor.cs (1)

1587var groups = executables.GroupBy(e => e.ModelResource).ToList();

DeveloperCertificateService.cs (1)

53.GroupBy(c => c.Extensions.OfType<X509SubjectKeyIdentifierExtension>().FirstOrDefault()?.SubjectKeyIdentifier)

Pipelines\DistributedApplicationPipeline.cs (1)

1036var stepsByLevel = executionLevels.GroupBy(kvp => kvp.Value)

ProjectResourceBuilderExtensions.cs (1)

511.GroupBy(entry => entry.BindingAddress.Scheme);

Aspire.Hosting.Azure (1)

AzureResourcePreparer.cs (1)

257foreach (var g in roleAssignments.GroupBy(r => r.Target))

Aspire.Hosting.Azure.AppContainers (1)

ContainerAppContext.cs (1)

160.GroupBy(x => x.resolved.TargetPort.Value)

Aspire.Hosting.CodeGeneration.Go.Tests (1)

AtsGoCodeGeneratorTests.cs (1)

174.GroupBy(c => c.CapabilityId)

Aspire.Hosting.CodeGeneration.Java.Tests (1)

AtsJavaCodeGeneratorTests.cs (1)

173.GroupBy(c => c.CapabilityId)

Aspire.Hosting.CodeGeneration.Python.Tests (1)

AtsPythonCodeGeneratorTests.cs (1)

174.GroupBy(c => c.CapabilityId)

Aspire.Hosting.CodeGeneration.Rust.Tests (1)

AtsRustCodeGeneratorTests.cs (1)

174.GroupBy(c => c.CapabilityId)

Aspire.Hosting.CodeGeneration.TypeScript (3)

AtsTypeScriptCodeGenerator.cs (3)

2610.GroupBy(c => c.CapabilityId) 2643.GroupBy(c => c.CapabilityId) 2704.GroupBy(b => b.BuilderClassName)

Aspire.Hosting.CodeGeneration.TypeScript.Tests (1)

AtsTypeScriptCodeGeneratorTests.cs (1)

775.GroupBy(c => c.CapabilityId)

Aspire.Hosting.RemoteHost (1)

AtsCapabilityScanner.cs (1)

850.GroupBy(x => (x.Target, x.Capability.MethodName))

dotnet (5)

CommandFactory\CommandResolution\LockFileTargetExtensions.cs (1)

80.GroupBy(t => t.Runtime);

Commands\Test\MTP\Terminal\TerminalTestReporter.cs (1)

176IEnumerable<IGrouping<bool, TestRunArtifact>> artifactGroups = _artifacts.GroupBy(a => a.OutOfProcess);

Commands\Tool\Restore\ToolRestoreCommand.cs (1)

200.GroupBy(packageIdAndCommandName => packageIdAndCommandName.CommandName)

ToolManifest\ToolManifestEditor.cs (1)

240var duplicateKeys = deserializedManifest.Tools.GroupBy(x => x.PackageId)

ToolPackage\LocalToolsResolverCache.cs (1)

37foreach (var distinctPackageIdAndRestoredCommandMap in restoredCommandMap.GroupBy(x => x.Key.PackageId))

GenerateDocumentationAndConfigFiles (4)

src\roslyn\src\Dependencies\PooledObjects\PoolTracker.cs (1)

151foreach (var group in _outstanding.Values.GroupBy(v => (v.Type, v.PoolName)).OrderByDescending(g => g.Count()))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\FixAllContextHelper.cs (1)

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

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

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

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

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

installer.tasks (1)

StaticFileRegeneration\RegenerateThirdPartyNotices.cs (1)

118.GroupBy(r => r.Repo)

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.Mvc.ApiExplorer (1)

ApiDescriptionGroupCollectionProvider.cs (1)

78.GroupBy(d => d.GroupName)

Microsoft.AspNetCore.Razor.Utilities.Shared (1)

src\roslyn\src\Dependencies\PooledObjects\PoolTracker.cs (1)

151foreach (var group in _outstanding.Values.GroupBy(v => (v.Type, v.PoolName)).OrderByDescending(g => g.Count()))

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.Build.Framework (1)

BuildCheck\BuildCheckTracingData.cs (1)

41.GroupBy(d => d.Value.CheckFriendlyName)

Microsoft.Build.Tasks.CodeAnalysis (1)

src\roslyn\src\Compilers\Core\MSBuildTask\GenerateMSBuildEditorConfig.cs (1)

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

Microsoft.CodeAnalysis (9)

CommandLine\ReportAnalyzerUtil.cs (3)

83.GroupBy(kvp => kvp.Key.GetType().Assembly) 134.GroupBy(a => a.GetType().Assembly) 165.GroupBy(t => t.Generator.GetGeneratorType().Assembly)

DiagnosticAnalyzer\AnalysisResultBuilder.cs (1)

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

DiagnosticAnalyzer\AnalyzerDriver.cs (3)

1471var actionsByAnalyzers = analyzerActions.SymbolActions.GroupBy(action => action.Analyzer); 1503var actionsByAnalyzers = analyzerActions.GroupBy(action => action.Analyzer); 1847foreach (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

src\roslyn\src\Dependencies\PooledObjects\PoolTracker.cs (1)

151foreach (var group in _outstanding.Values.GroupBy(v => (v.Type, v.PoolName)).OrderByDescending(g => g.Count()))

Microsoft.CodeAnalysis.Analyzers (4)

src\roslyn\src\Dependencies\PooledObjects\PoolTracker.cs (1)

151foreach (var group in _outstanding.Values.GroupBy(v => (v.Type, v.PoolName)).OrderByDescending(g => g.Count()))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\FixAllContextHelper.cs (1)

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

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

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

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

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

Microsoft.CodeAnalysis.AnalyzerUtilities (1)

src\roslyn\src\Dependencies\PooledObjects\PoolTracker.cs (1)

151foreach (var group in _outstanding.Values.GroupBy(v => (v.Type, v.PoolName)).OrderByDescending(g => g.Count()))

Microsoft.CodeAnalysis.CodeStyle (4)

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

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

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

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

src\roslyn\src\Dependencies\PooledObjects\PoolTracker.cs (1)

151foreach (var group in _outstanding.Values.GroupBy(v => (v.Type, v.PoolName)).OrderByDescending(g => g.Count()))

Microsoft.CodeAnalysis.CodeStyle.Fixes (10)

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

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

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

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

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

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

src\roslyn\src\Analyzers\Core\CodeFixes\RemoveUnusedParametersAndValues\AbstractRemoveUnusedValuesCodeFixProvider.cs (1)

269return diagnostics.GroupBy(d => syntaxFacts.GetContainingMemberDeclaration(root, d.Location.SourceSpan.Start) ?? root);

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

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

src\roslyn\src\Analyzers\Core\CodeFixes\UseAutoProperty\AbstractUseAutoPropertyCodeFixProvider.cs (2)

322foreach (var group in fieldLocations.SelectMany(loc => loc.Locations).GroupBy(loc => loc.Document)) 498foreach (var group in referencedSymbols.SelectMany(r => r.Locations).GroupBy(loc => loc.Document))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\FixAllContextHelper.cs (1)

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

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

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

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

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

Microsoft.CodeAnalysis.CSharp (5)

BoundTree\LengthBasedStringSwitchData.cs (2)

154foreach (var group in inputCases.Where(c => !c.value.IsNull).GroupBy(c => c.value.StringValue!.Length)) 187foreach (var group in casesWithGivenLength.GroupBy(c => c.value[bestCharacterPosition]))

BoundTree\UnboundLambda.cs (1)

1318IEnumerable<KeyValuePair<T, BoundLambda>> minDiagnosticsGroup = candidates.GroupBy(lambda => lambda.Value.Diagnostics.Diagnostics.Length).OrderBy(group => group.Key).First();

Symbols\Source\ConstantEvaluationHelpers.cs (1)

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

Symbols\Source\SourceMemberContainerSymbol.cs (1)

2540IEnumerable<IGrouping<string, NamedTypeSymbol>> extensionsByReceiverType = GetTypeMembers("").Where(static t => t.IsExtension).GroupBy(static t => ((SourceNamedTypeSymbol)t).ExtensionGroupingName!);

Microsoft.CodeAnalysis.CSharp.CodeStyle (4)

src\roslyn\src\Analyzers\CSharp\Analyzers\RemoveUnnecessarySuppressions\UnnecessaryNullableWarningSuppressionsUtilities.cs (2)

148foreach (var typeDeclarationGroup in inFieldsOrProperties.GroupBy(t => t.rewrittenAncestor.FirstAncestorOrSelf<TypeDeclarationSyntax>())) 168foreach (var ancestorGroup in nodes.GroupBy(t => t.rewrittenAncestor))

src\roslyn\src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryUnsafeModifier\UnnecessaryUnsafeModifierUtilities.cs (1)

64foreach (var group in nodesToCheck.GroupBy(node =>

src\roslyn\src\Analyzers\CSharp\Analyzers\UsePrimaryConstructor\CSharpUsePrimaryConstructorDiagnosticAnalyzer.cs (1)

435foreach (var group in orderedParameterAssignments.GroupBy(t => t.parameter))

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

src\roslyn\src\Analyzers\CSharp\CodeFixes\AssignOutParameters\AbstractAssignOutParametersCodeFixProvider.cs (1)

105foreach (var group in containersAndLocations.GroupBy(t => t.container))

src\roslyn\src\Analyzers\CSharp\CodeFixes\RemoveUnnecessaryNullableDirective\CSharpRemoveUnnecessaryNullableDirectiveCodeFixProvider.cs (1)

57foreach (var (token, directives) in nullableDirectives.GroupBy(d => d.ParentTrivia.Token))

src\roslyn\src\Analyzers\CSharp\CodeFixes\UsePrimaryConstructor\CSharpUsePrimaryConstructorCodeFixProvider.cs (3)

531foreach (var group in removedMembers.Values.GroupBy(n => n.memberNode.SyntaxTree)) 604foreach (var group in nodesToReplace.GroupBy(n => n.SyntaxTree)) 620foreach (var group in seeTagsToReplace.GroupBy(n => n.SyntaxTree))

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseSystemThreadingLock\CSharpUseSystemThreadingLockCodeFixProvider.cs (1)

122.GroupBy(loc => loc.Document);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\InitializeParameter\InitializeParameterHelpers.cs (1)

108var groups = references.SelectMany(static r => r.Locations.Where(loc => !loc.IsImplicit)).GroupBy(static loc => loc.Document);

Microsoft.CodeAnalysis.CSharp.Features (17)

Completion\CompletionProviders\AwaitCompletionProvider.cs (1)

126foreach (var group in references.SelectMany(r => r.Locations).GroupBy(l => l.Location.SourceTree))

Completion\CompletionProviders\CrefCompletionProvider.cs (1)

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

Completion\CompletionProviders\OperatorsAndIndexer\UnnamedSymbolCompletionProvider.cs (1)

128var operatorGroups = unnamedSymbols.WhereAsArray(s => s.IsUserDefinedOperator()).GroupBy(op => op.Name);

ConvertPrimaryToRegularConstructor\ConvertPrimaryToRegularConstructorCodeRefactoringProvider.cs (2)

236foreach (var grouping in initializers.GroupBy(kvp => kvp.Value.SyntaxTree)) 366foreach (var grouping in references.GroupBy(r => r.SyntaxTree))

ImplementInterface\CSharpImplementExplicitlyCodeRefactoringProvider.cs (1)

59var referenceByDocument = implReferences.Locations.GroupBy(loc => loc.Document);

InitializeParameter\CSharpInitializeMemberFromPrimaryConstructorParameterCodeRefactoringProvider.cs (1)

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

src\roslyn\src\Analyzers\CSharp\Analyzers\RemoveUnnecessarySuppressions\UnnecessaryNullableWarningSuppressionsUtilities.cs (2)

src\roslyn\src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryUnsafeModifier\UnnecessaryUnsafeModifierUtilities.cs (1)

64foreach (var group in nodesToCheck.GroupBy(node =>

src\roslyn\src\Analyzers\CSharp\Analyzers\UsePrimaryConstructor\CSharpUsePrimaryConstructorDiagnosticAnalyzer.cs (1)

435foreach (var group in orderedParameterAssignments.GroupBy(t => t.parameter))

src\roslyn\src\Analyzers\CSharp\CodeFixes\AssignOutParameters\AbstractAssignOutParametersCodeFixProvider.cs (1)

105foreach (var group in containersAndLocations.GroupBy(t => t.container))

src\roslyn\src\Analyzers\CSharp\CodeFixes\RemoveUnnecessaryNullableDirective\CSharpRemoveUnnecessaryNullableDirectiveCodeFixProvider.cs (1)

57foreach (var (token, directives) in nullableDirectives.GroupBy(d => d.ParentTrivia.Token))

src\roslyn\src\Analyzers\CSharp\CodeFixes\UsePrimaryConstructor\CSharpUsePrimaryConstructorCodeFixProvider.cs (3)

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseSystemThreadingLock\CSharpUseSystemThreadingLockCodeFixProvider.cs (1)

122.GroupBy(loc => loc.Document);

Microsoft.CodeAnalysis.CSharp.Workspaces (1)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\InitializeParameter\InitializeParameterHelpers.cs (1)

108var groups = references.SelectMany(static r => r.Locations.Where(loc => !loc.IsImplicit)).GroupBy(static loc => loc.Document);

Microsoft.CodeAnalysis.Extensions.Package (1)

src\roslyn\src\Dependencies\PooledObjects\PoolTracker.cs (1)

151foreach (var group in _outstanding.Values.GroupBy(v => (v.Type, v.PoolName)).OrderByDescending(g => g.Count()))

Microsoft.CodeAnalysis.Features (28)

AddImport\AbstractAddImportFeatureService.cs (1)

554.GroupBy(diagnostic => diagnostic.Location.SourceSpan)

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)

113.GroupBy(change => change.Span)

CodeRefactorings\CodeRefactoringService.cs (1)

37.GroupBy(lz => new ProviderKey(lz.Metadata.Language, lz.Metadata.DocumentKind, lz.Metadata.DocumentExtension))

CodeRefactorings\SyncNamespace\AbstractChangeNamespaceService.cs (1)

485var refLocationGroups = refLocationsInSolution.GroupBy(loc => loc.Document.Id);

Completion\Providers\AbstractRecommendationServiceBasedCompletionProvider.cs (1)

309return symbols.GroupBy(symbol => symbol.Symbol.Kind).Select(group => group.ToImmutableArray()).ToImmutableArray();

ConvertTupleToStruct\AbstractConvertTupleToStructCodeRefactoringProvider.cs (2)

333foreach (var group in documentsToUpdate.GroupBy(d => d.Document.Project)) 531foreach (var group in declarationService.GetDeclarations(typeSymbol).GroupBy(r => r.SyntaxTree))

EditAndContinue\EditSession.cs (1)

926foreach (var g in newMaps.GroupBy(m => m.NewTree))

ExternalAccess\UnitTesting\SolutionCrawler\UnitTestingSolutionCrawlerRegistrationService.cs (1)

47_analyzerProviders = analyzerProviders.GroupBy(kv => kv.Metadata.Name).ToImmutableDictionary(g => g.Key, g => g.ToImmutableArray());

ExternalAccess\VSTypeScript\VSTypeScriptNavigateToSearchService.cs (1)

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

InheritanceMargin\AbstractInheritanceMarginService_Helpers.cs (1)

233foreach (var group in nonLocalImports.GroupBy(i => i.DeclaringSyntaxReference?.SyntaxTree))

IntroduceParameter\AbstractIntroduceParameterCodeRefactoringProvider.cs (1)

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

NavigateTo\AbstractNavigateToSearchService.CachedDocumentSearch.cs (1)

130var groups = documentKeys.GroupBy(d => d.Project).ToImmutableArray();

NavigateTo\NavigateToSearcher.cs (1)

361var groups = projectGroup.GroupBy(GetNavigateToSearchService);

Options\EditorConfig\EditorConfigFileGenerator.cs (1)

62foreach (var optionGrouping in options.GroupBy(o => o.Definition.Group).OrderBy(g => g.Key.Priority))

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

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

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

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

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

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

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

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

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

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

src\roslyn\src\Analyzers\Core\CodeFixes\RemoveUnusedParametersAndValues\AbstractRemoveUnusedValuesCodeFixProvider.cs (1)

269return diagnostics.GroupBy(d => syntaxFacts.GetContainingMemberDeclaration(root, d.Location.SourceSpan.Start) ?? root);

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

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

src\roslyn\src\Analyzers\Core\CodeFixes\UseAutoProperty\AbstractUseAutoPropertyCodeFixProvider.cs (2)

UnusedReferences\UnusedReferencesRemover.cs (1)

70var referencesByType = references.GroupBy(reference => reference.ReferenceType)

Microsoft.CodeAnalysis.Razor.Compiler (2)

Language\Components\ComponentEventHandlerLoweringPass.cs (2)

125.GroupBy(p => p.AttributeName) 144.GroupBy(p => p.AttributeName)

Microsoft.CodeAnalysis.ResxSourceGenerator (1)

src\roslyn\src\Dependencies\PooledObjects\PoolTracker.cs (1)

151foreach (var group in _outstanding.Values.GroupBy(v => (v.Type, v.PoolName)).OrderByDescending(g => g.Count()))

Microsoft.CodeAnalysis.Workspaces (19)

CodeFixes\FixAllOccurrences\BatchFixAllProvider.cs (2)

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

Diagnostics\Extensions.cs (1)

230foreach (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)

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

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

101.GroupBy(d => d.ProjectId) 787.GroupBy(l => l.ContainingLocationForStringOrComment)

Rename\ConflictEngine\MutableConflictResolution.cs (1)

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

Rename\SymbolicRenameLocations.ReferenceProcessing.cs (1)

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

src\roslyn\src\Dependencies\PooledObjects\PoolTracker.cs (1)

151foreach (var group in _outstanding.Values.GroupBy(v => (v.Type, v.PoolName)).OrderByDescending(g => g.Count()))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\FixAllContextHelper.cs (1)

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

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

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

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

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

Workspace\Solution\SolutionCompilationState.cs (2)

857.GroupBy(static d => d.documentId.ProjectId) 1791documentInfos.GroupBy(d => d.Id.ProjectId).Select(g =>

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

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

Microsoft.DotNet.ApiCompatibility (1)

Runner\ApiCompatRunner.cs (1)

59var differenceGroups = differences.GroupBy((c) => new { c.Left, c.Right });

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)

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

Microsoft.DotNet.Cli.Definitions (1)

Help\HelpBuilder.Default.cs (1)

228.GroupBy(t => t.Alias)

Microsoft.DotNet.GenFacades (1)

GenPartialFacadeSourceGenerator.cs (1)

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

Microsoft.DotNet.HotReload.Watch (3)

Build\LoadedProjectGraph.cs (1)

15graph.ProjectNodes.Where(n => n.ProjectInstance.GetTargetFramework() != "").GroupBy(n => n.ProjectInstance.FullPath).ToDictionary(

HotReload\CompilationHandler.cs (1)

1010.GroupBy(static node => node.ProjectInstance.FullPath)

HotReload\HotReloadDotNetWatcher.cs (1)

831.GroupBy(keySelector: change => change.Path)

Microsoft.DotNet.PackageValidation (1)

Validators\BaselinePackageValidator.cs (1)

94.GroupBy(t => (string)t.Properties["rid"]);

Microsoft.DotNet.SharedFramework.Sdk (1)

src\CreateFrameworkListFile.cs (1)

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

Microsoft.DotNet.SourceBuild.Tasks (1)

src\WriteBuildOutputProps.cs (1)

62.GroupBy(identity => identity.Id)

Microsoft.Extensions.AI.Integration.Tests (1)

VerbatimMultiPartHttpHandler.cs (1)

193=> RemoveWhiteSpace(text)?.GroupBy(c => c)

Microsoft.Extensions.DependencyModel (2)

DependencyContextJsonReader.cs (1)

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

DependencyContextWriter.cs (1)

424.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.Generators (1)

LoggerMessageGenerator.Parser.cs (1)

73foreach (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.MetadataExtractor (2)

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

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

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

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

Microsoft.Gen.Metrics (1)

Parser.cs (1)

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

Microsoft.Gen.MetricsReports (1)

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

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

Microsoft.Interop.ComInterfaceGenerator (1)

VtableIndexStubGenerator.cs (1)

158foreach (var group in data.GroupBy(s => s.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.NET.Build.Tasks (7)

CheckForDuplicateItemMetadata.cs (1)

30var groupings = Items.GroupBy(item => item.GetMetadata(MetadataName))

CollatePackageDownloads.cs (1)

27PackageDownloads = Packages.GroupBy(p => p.ItemSpec)

DependencyContextBuilder.cs (2)

225foreach (var runtimePackGroup in runtimePackAssets.GroupBy(a => a.PackageName)) 685.GroupBy(f => f.RuntimeIdentifier);

LockFileExtensions.cs (1)

236.GroupBy(t => t.Runtime);

ProduceContentAssets.cs (1)

150.GroupBy(t => t.GetMetadata(MetadataKeys.NuGetPackageId));

ResolvePackageAssets.cs (1)

1897.GroupBy(p => p.Name)

Microsoft.NET.Sdk.BlazorWebAssembly.Tasks (1)

UpgradeLegacyWasmStaticWebAssets.cs (1)

25.GroupBy(asset => asset.ComputeTargetPath("", '/'))

Microsoft.NET.Sdk.StaticWebAssets.Tasks (4)

GenerateStaticWebAssetEndpointsManifest.cs (1)

225.GroupBy(a => a.ComputeTargetPath("", '/'));

GenerateStaticWebAssetsDevelopmentManifest.cs (1)

103.GroupBy(a => a.ComputeTargetPath("", '/', StaticWebAssetTokenResolver.Instance));

UpdateStaticWebAssetEndpoints.cs (2)

45.GroupBy(e => e.Route) 48.GroupBy(e => e.Route)

Microsoft.TemplateEngine.Cli (4)

Commands\create\InstantiateCommand.cs (1)

61foreach (IGrouping<int, CliTemplateInfo> templateGrouping in templateGroup.Templates.GroupBy(g => g.Precedence).OrderByDescending(g => g.Key))

Commands\create\InstantiateCommand.Help.cs (1)

346foreach (IGrouping<int, CliTemplateInfo> templateGrouping in templateGroup.Templates.GroupBy(g => g.Precedence).OrderByDescending(g => g.Key))

Commands\create\InstantiateCommand.TabCompletion.cs (1)

50foreach (IGrouping<int, CliTemplateInfo> templateGrouping in GetAllowedTemplates(constraintManager, templateGroup).GroupBy(g => g.Precedence).OrderByDescending(g => g.Key))

TemplatePackageCoordinator.cs (1)

289foreach (var packagesGrouping in managedTemplatePackages.GroupBy(package => package.ManagedProvider))

Microsoft.TemplateEngine.Edge (2)

BuiltInManagedProvider\GlobalSettingsTemplatePackageProvider.cs (1)

85foreach (var packagesGroupedByInstaller in packages.GroupBy(s => s.Installer))

Installers\NuGet\NugetApiPackageManager.cs (1)

523return vulnerabilities.GroupBy(x => x.Severity)

Microsoft.TestPlatform.CrossPlatEngine (9)

Client\InProcessProxyexecutionManager.cs (1)

62testRunCriteria.Tests!.GroupBy(tc => tc.Source).Select(g => g.Key));

Client\Parallel\ParallelProxyDiscoveryManager.cs (1)

211.GroupBy(psw => psw.Provider);

Client\Parallel\ParallelProxyExecutionManager.cs (3)

250Dictionary<string, TestCase[]> sourceToTestCasesMap = testRunCriteria.Tests.GroupBy(t => t.Source).ToDictionary(k => k.Key, v => v.ToArray()); 254var providerGroups = sources.Select(source => new ProviderSpecificWorkload<string>(source, sourceToTestHostProviderMap[source])).GroupBy(psw => psw.Provider); 312.GroupBy(psw => psw.Provider);

Client\ProxyExecutionManager.cs (2)

188: testRunCriteria.Tests.GroupBy(tc => tc.Source).Select(g => g.Key)); 245: testRunCriteria.Tests.GroupBy(tc => tc.Source).Select(g => g.Key));

PostProcessing\ArtifactProcessingManager.cs (1)

235.GroupBy(grp => grp.TestSessionId)

TestEngine.cs (1)

452var uniqueRunConfigurations = sourceToSourceDetailMap.Values.GroupBy(k => $"{k.Framework}|{k.Architecture}");

Microsoft.VisualStudio.TestPlatform.ObjectModel (3)

Nuget.Frameworks\FrameworkReducer.cs (3)

186reduced = reduced.Where(f => NuGetFrameworkNameComparer.Instance.Equals(framework, f)).GroupBy(f => f.Version).OrderByDescending(f => f.Key).First(); 196reduced = reduced.GroupBy(f => f.Framework).OrderByDescending(f => f.Key).First(f => 416reduced = scores.GroupBy(pair => pair.Value).OrderByDescending(g => g.Key).First().Select(e => e.Key);

NuGet.Commands (2)

RestoreCommand\Diagnostics\DiagnosticUtility.cs (1)

112foreach (var codeGroup in messages.GroupBy(e => e.Code))

RestoreCommand\Utility\ToolRestoreUtility.cs (1)

128foreach (var versionRangeGroup in packagesFolderGroup.GroupBy(e =>

NuGet.Configuration (2)

PackageSource\PackageSourceProvider.cs (1)

133var disabledSources = new HashSet<string>(disabledSourcesSettings?.GroupBy(setting => setting.Key).Select(group => group.First().Key) ?? Enumerable.Empty<string>());

Settings\Items\PackageSourceMappingSourceItem.cs (1)

158Dictionary<PackagePatternItem, PackagePatternItem> otherPatterns = packageSourceMappingSourceItem.Patterns.GroupBy(item => item).ToDictionary(c => c.Key, c => c.Key);

NuGet.Credentials (1)

PluginCredentialProviderBuilder.cs (1)

79.GroupBy(Path.GetDirectoryName)

NuGet.Frameworks (3)

FrameworkReducer.cs (3)

NuGet.Packaging (8)

NuspecReader.cs (1)

221.GroupBy(n => GetAttributeValue(n, TargetFramework)))

PackageCreation\Authoring\ManifestMetadata.cs (2)

226var referenceSetGroups = referenceSets.GroupBy(set => set.TargetFramework); 257var dependencySetGroups = dependencyGroups.GroupBy(set => set.TargetFramework);

Rules\InvalidUndottedFrameworkRule.cs (1)

150.GroupBy(n => GetAttributeValue(n, TargetFramework)))

Rules\UpholdBuildConventionRule.cs (3)

66var msbuildFilesGroupedByBuildFolder = msbuildFilesInBuildFolder.GroupBy(GetBuildFolder); 70foreach (var tfm in buildFolder.GroupBy(GetTfm)) 72foreach (var extension in tfm.GroupBy(Path.GetExtension))

RuntimeModel\JsonRuntimeFormat.cs (1)

147var frameworkGroups = data.RestoreContexts.GroupBy(context => context.Framework);

NuGet.ProjectModel (1)

PackageSpecWriter.cs (1)

507foreach (var dependency in downloadDependencies.GroupBy(dep => dep.Name).OrderBy(dep => dep.Key))

NuGet.Protocol (6)

LegacyFeed\PackageSearchResourceV2Feed.cs (1)

56var results = query.GroupBy(p => p.Id)

LegacyFeed\V2FeedListResource.cs (4)

200_currentPage.Items.GroupBy(p => p.Id) 207_currentPage.Items.GroupBy(p => p.Id) 233_currentPage.Items.GroupBy(p => p.Id) 240_currentPage.Items.GroupBy(p => p.Id)

SourceRepository.cs (1)

181foreach (var group in providers.GroupBy(p => p.Value.ResourceType))

Roslyn.Diagnostics.Analyzers (4)

src\roslyn\src\Dependencies\PooledObjects\PoolTracker.cs (1)

151foreach (var group in _outstanding.Values.GroupBy(v => (v.Type, v.PoolName)).OrderByDescending(g => g.Count()))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\FixAllContextHelper.cs (1)

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

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

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

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

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

Roslyn.Diagnostics.CSharp.Analyzers (1)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\InitializeParameter\InitializeParameterHelpers.cs (1)

108var groups = references.SelectMany(static r => r.Locations.Where(loc => !loc.IsImplicit)).GroupBy(static loc => loc.Document);

sdk-tasks (1)

CalculateTemplateVersions.cs (1)

47var groups = BundledTemplates.GroupBy(bt => bt.GetMetadata("TemplateFrameworkVersion"))

System.CommandLine (1)

Help\HelpBuilder.Default.cs (1)

142.GroupBy(t => t.Alias)

System.CommandLine.StaticCompletions (1)

shells\FishShellProvider.cs (1)

145.GroupBy(o => o.Arity.MaximumNumberOfValues);

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

vstest.console (1)

Internal\ConsoleLogger.cs (1)

702var leafTestResultsPerSource = LeafTestResults?.Select(p => p.Value)?.GroupBy(r => r.TestCase.Source);

vstest.console.arm64 (1)

src\vstest\src\vstest.console\Internal\ConsoleLogger.cs (1)

702var leafTestResultsPerSource = LeafTestResults?.Select(p => p.Value)?.GroupBy(r => r.TestCase.Source);