Key

Collections\Grouping.cs (1)

18public TKey Key { get; }

GroupBy.cs (1)

89public TKey Key => _key;

ListExtensions.cs (1)

116public TKey Key { get; }

System\Linq\Grouping.cs (1)

397public TKey Key => _key;

System\Linq\GroupJoin.cs (1)

138public TKey Key => _key;

System\Linq\GroupBy.cs (1)

435public TKey Key => _key;

System\Linq\GroupJoin.cs (1)

273public TKey Key => _key;

System\Linq\Parallel\QueryOperators\Unary\GroupByQueryOperator.cs (2)

697TGroupKey IGrouping<TGroupKey, TElement>.Key 749TGroupKey IGrouping<TGroupKey, TElement>.Key

Commands\AddCommand.cs (1)

394Channel = g.Key,

Commands\DoctorCommand.cs (2)

99.OrderBy(g => GetCategoryOrder(g.Key)); 103var categoryHeader = GetCategoryHeader(group.Key);

Commands\NewCommand.cs (3)

321var implicitGroup = byChannel.FirstOrDefault(g => g.Key.Type is Packaging.PackageChannelType.Implicit); 323.Where(g => g.Key.Type is Packaging.PackageChannelType.Explicit) 385var channel = channelGroup.Key;

Commands\Sdk\SdkDumpCommand.cs (3)

480.OrderBy(g => g.Key is null or "Extension Methods") // Sort nulls/extension methods last 481.ThenBy(g => g.Key); 485sb.AppendLine(string.Format(CultureInfo.InvariantCulture, " [{0}]", group.Key));

Commands\TelemetryTracesCommand.cs (1)

366.ToDictionary(g => g.Key, g => g.OrderBy(s => s.StartNano).ToList());

Packaging\NuGetConfigMerger.cs (3)

336var newSource = sourceGroup.Key; 399var targetSource = sourceGroup.Key; 734var sourceUrl = sourceGroup.Key;

Packaging\TemporaryNuGetConfig.cs (1)

87var sourceInfo = distinctSources.First(s => string.Equals(s.Source, sourceGroup.Key, StringComparison.OrdinalIgnoreCase));

Projects\ProjectUpdater.cs (1)

52var projectName = new FileInfo(projectGroup.Key).Name;

Commands\ExportCommandTests.cs (4)

782Resource = TelemetryTestHelper.CreateOtlpResource(g.Key.serviceName, g.Key.instanceId), 825Resource = TelemetryTestHelper.CreateOtlpResource(g.Key.serviceName, g.Key.instanceId),

Commands\TelemetryLogsCommandTests.cs (2)

123Resource = TelemetryTestHelper.CreateOtlpResource(g.Key.serviceName, g.Key.instanceId),

Commands\TelemetrySpansCommandTests.cs (2)

123Resource = TelemetryTestHelper.CreateOtlpResource(g.Key.serviceName, g.Key.instanceId),

Commands\TelemetryTracesCommandTests.cs (2)

171Resource = TelemetryTestHelper.CreateOtlpResource(g.Key.serviceName, g.Key.instanceId),

OtelMetricsTests.cs (4)

119Assert.Contains(groups, x => x.Key == "messaging.receive.duration"); 120Assert.Contains(groups, x => x.Key == "messaging.receive.messages"); 121Assert.Contains(groups, x => x.Key == "messaging.publish.duration"); 122Assert.Contains(groups, x => x.Key == "messaging.publish.messages");

Components\Controls\ResourceDetails.razor.cs (2)

292.Where(r => string.Equals(r.DisplayName, resourceRelationships.Key, StringComparisons.ResourceName)) 322if (string.Equals(resourceRelationships.Key, Resource.DisplayName, StringComparisons.ResourceName))

Components\Pages\ConsoleLogs.razor.cs (1)

667resourceName = grouping.Key;

Model\Otlp\SpanWaterfallViewModel.cs (1)

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

Model\ResourceGraph\ResourceGraphMapper.cs (1)

25.Where(r => string.Equals(r.DisplayName, resourceRelationships.Key, StringComparisons.ResourceName))

Model\TelemetryExportService.cs (5)

243Scope = ConvertScope(scopeGroup.Key), 289Scope = ConvertScope(scopeGroup.Key), 348Scope = ConvertScope(scopeGroup.Key), 465Scope = ConvertScope(scopeGroup.Key), 479Scope = ConvertScope(scopeGroup.Key),

Otlp\Model\OtlpResource.cs (1)

281.ToDictionary(grouping => grouping.Key, grouping => grouping.ToList());

Controls\StructuredLogDetailsTests.cs (1)

71Assert.Fail($"Duplicate properties with key '{duplicate.Key}'.");

Dcp\DcpExecutor.cs (1)

1596var groupKey = group.Key;

DistributedApplicationBuilder.cs (1)

740.Select(g => g.Key))

Pipelines\DistributedApplicationPipeline.cs (2)

1037.OrderBy(g => g.Key) 1038.ToDictionary(g => g.Key, g => g.Select(kvp => kvp.Key).OrderBy(s => s, StringComparer.Ordinal).ToList());

ProjectResourceBuilderExtensions.cs (1)

533var schemeAsEndpointName = schemeGroup.Count() <= 1 ? schemeGroup.Key : null;

AzureResourcePreparer.cs (1)

259result[g.Key] = g.SelectMany(r => r.Roles);

ContainerAppContext.cs (1)

163Port = g.Key,

AtsGoCodeGeneratorTests.cs (1)

176.Select(g => g.Key)

AtsJavaCodeGeneratorTests.cs (1)

175.Select(g => g.Key)

AtsPythonCodeGeneratorTests.cs (1)

176.Select(g => g.Key)

AtsRustCodeGeneratorTests.cs (1)

176.Select(g => g.Key)

AtsTypeScriptCodeGeneratorTests.cs (1)

777.Select(g => g.Key)

AtsCapabilityScanner.cs (1)

864var methodName = g.Key.MethodName;

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

187terminal.AppendLine(artifactGroup.Key ? CliCommandStrings.OutOfProcessArtifactsProduced : CliCommandStrings.InProcessArtifactsProduced);

ToolManifest\ToolManifestEditor.cs (1)

242.Select(group => group.Key);

ToolPackage\LocalToolsResolverCache.cs (1)

39PackageId distinctPackageId = distinctPackageIdAndRestoredCommandMap.Key;

src\roslyn\src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

771dictionary.Add(grouping.Key, [.. grouping]);

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

153var poolInfo = group.Key.PoolName is not null ? $" (from {group.Key.PoolName})" : ""; 154sb.AppendLine($" {group.Key.Type}{poolInfo}: {group.Count()}");

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\IGroupingExtensions.cs (1)

15key = grouping.Key;

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

208var semanticModel = compilation.GetSemanticModel(group.Key);

StaticFileRegeneration\RegenerateThirdPartyNotices.cs (1)

121Log.LogError($"Unable to find exactly one TPN for {miscount.Key}");

ApiDescriptionGroupCollectionProvider.cs (1)

79.Select(g => new ApiDescriptionGroup(g.Key, g.ToArray()))

Routing\AttributeRoute.cs (3)

122group.Key.RouteTemplate, 123group.Key.RouteName, 124group.Key.Order);

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

153var poolInfo = group.Key.PoolName is not null ? $" (from {group.Key.PoolName})" : ""; 154sb.AppendLine($" {group.Key.Type}{poolInfo}: {group.Count()}");

Matching\ILEmitTrieFactory.cs (19)

111Array.Sort(groups, static (a, b) => a.Key.CompareTo(b.Key)); 140il.Emit(OpCodes.Ldc_I4, group.Key); 146EmitTable(il, group.ToArray(), 0, group.Key, locals, labels, methods); 160il.Emit(OpCodes.Ldc_I4, groups[mid].Key); 336Array.Sort(groups, static (a, b) => unchecked((long)a.Key).CompareTo(unchecked((long)b.Key))); 357il.Emit(OpCodes.Ldc_I8, unchecked((long)group.Key)); 375il.Emit(OpCodes.Ldc_I8, unchecked((long)groups[mid].Key)); 455var disableBinarySearch = groups.Any(group => groups.Any(otherGroup => otherGroup.Key != group.Key && (otherGroup.Key | 0x20) == (group.Key | 0x20))); 461Array.Sort(groups, static (a, b) => (a.Key | 0x20).CompareTo(b.Key | 0x20)); 481var comparisonLocal = group.Key >= 'a' && group.Key <= 'z' 488il.Emit(OpCodes.Ldc_I4, unchecked((int)(uint)group.Key)); 507il.Emit(OpCodes.Ldc_I4, unchecked(((int)(uint)groups[mid].Key | 0x20)));

src\msbuild\artifacts\.packages\microsoft.codeanalysis.collections\5.0.0-1.25277.114\contentFiles\cs\net9.0\Extensions\IEnumerableExtensions.cs (1)

809dictionary.Add(grouping.Key, [.. grouping]);

BuildCheck\BuildCheckTracingData.cs (1)

42.ToDictionary(g => g.Key, g => g.First().Value.TotalRuntime);

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

89EncodeString(builder, group.Key);

GetSDKReferenceFiles.cs (1)

1034referencesByDirectory.TryAdd(group.Key, group.ToList());

GitDataReader\GitRepository.cs (2)

296OrderBy(group => group.Key)) 298var name = group.Key;

CommandLine\ReportAnalyzerUtil.cs (4)

89consoleOutput.WriteLine(GetColumnEntry(executionTime, percentage, analyzerGroup.Key.FullName, culture)); 135.OrderBy(g => g.Key.FullName, StringComparer.OrdinalIgnoreCase); 139consoleOutput.WriteLine($" {group.Key.FullName}"); 172consoleOutput.WriteLine(GetColumnEntry(executionTime, percentage, generatorGroup.Key.FullName, culture));

DiagnosticAnalyzer\AnalysisResultBuilder.cs (1)

344var key = diagsByKey.Key;

DiagnosticAnalyzer\AnalyzerDriver.cs (3)

1492builder.Add((analyzerAndActions.Key, actionsByKind)); 1506builder.Add((analyzerAndActions.Key, analyzerAndActions.ToImmutableArray())); 1849var analyzer = groupedActions.Key;

MetadataReader\MetadataHelpers.cs (2)

825while (pair.Key.Length == namespaceNameLength) 847string childNamespaceName = ExtractSimpleNameOfChildNamespace(namespaceNameLength, pair.Key);

MetadataReader\PEModule.cs (4)

720int result = _nameComparer.Compare(left.Key, right.Key); 740result = string.CompareOrdinal(left.Key, right.Key);

src\roslyn\src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

771dictionary.Add(grouping.Key, [.. grouping]);

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

153var poolInfo = group.Key.PoolName is not null ? $" (from {group.Key.PoolName})" : ""; 154sb.AppendLine($" {group.Key.Type}{poolInfo}: {group.Count()}");

src\roslyn\src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

771dictionary.Add(grouping.Key, [.. grouping]);

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

153var poolInfo = group.Key.PoolName is not null ? $" (from {group.Key.PoolName})" : ""; 154sb.AppendLine($" {group.Key.Type}{poolInfo}: {group.Count()}");

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\IGroupingExtensions.cs (1)

15key = grouping.Key;

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

208var semanticModel = compilation.GetSemanticModel(group.Key);

src\roslyn\src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

771dictionary.Add(grouping.Key, [.. grouping]);

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

153var poolInfo = group.Key.PoolName is not null ? $" (from {group.Key.PoolName})" : ""; 154sb.AppendLine($" {group.Key.Type}{poolInfo}: {group.Count()}");

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\IGroupingExtensions.cs (1)

15key = grouping.Key;

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

43if (group.Key == true) 56var language = languageGroup.Key;

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

796var syntaxTree = group.Key;

src\roslyn\src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

771dictionary.Add(grouping.Key, [.. grouping]);

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

153var poolInfo = group.Key.PoolName is not null ? $" (from {group.Key.PoolName})" : ""; 154sb.AppendLine($" {group.Key.Type}{poolInfo}: {group.Count()}");

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\IGroupingExtensions.cs (1)

15key = grouping.Key;

src\roslyn\src\Analyzers\Core\CodeFixes\AddParameter\AddParameterService.cs (2)

105var document = documentLookup.Key; 175var documentsUpdated = locationsByDocument.Select(g => g.Key).ToSet();

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

62var fieldDeclaration = fieldDeclarators.Key;

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

171var document = group.Key;

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

80predicate: group => group.Key is not null, 81selector: group => (id: solution.GetRequiredDocument(group.Key!).Id, diagnostics: group.ToImmutableArray()));

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

279var memberDeclarations = GetDiagnosticsGroupedByMember(diagnostics, syntaxFacts, root).Select(g => g.Key); 324var containingMemberDeclaration = diagnosticsToFix.Key;

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

326var document = group.Key; 500var document = group.Key;

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

208var semanticModel = compilation.GetSemanticModel(group.Key);

BoundTree\LengthBasedStringSwitchData.cs (2)

156int stringLength = group.Key; 194char character = group.Key;

BoundTree\UnboundLambda.cs (1)

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

Lowering\IteratorRewriter\IteratorMethodToStateMachineRewriter.cs (1)

274EmitFinallyFrame(g.Key, state),

Symbols\AnonymousTypes\AnonymousTypeManager.Templates.cs (1)

657keySelector: grouping => grouping.Key,

Symbols\Metadata\PE\PENamespaceSymbol.cs (1)

294children.Add(PENamedTypeSymbol.Create(moduleSymbol, this, t, g.Key));

Symbols\Source\ConstantEvaluationHelpers.cs (1)

277SelectMany(static g => g.OrderByDescending((f1, f2) => g.Key.CompareSourceLocations(f1.ErrorLocation, f2.ErrorLocation))));

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

150var typeDeclaration = typeDeclarationGroup.Key; 170var rewrittenAncestor = ancestorGroup.Key;

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

437var parameter = group.Key;

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

107var container = group.Key;

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

533var syntaxTree = group.Key; 606var document = solution.GetDocument(group.Key); 622var document = solution.GetDocument(group.Key);

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

125var groupDocument = group.Key;

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

112var editor = await solutionEditor.GetDocumentEditorAsync(group.Key.Id, cancellationToken).ConfigureAwait(false);

Completion\CompletionProviders\AwaitCompletionProvider.cs (1)

128var tree = group.Key;

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

130AddOperatorGroup(context, opGroup.Key, opGroup);

ConvertPrimaryToRegularConstructor\ConvertPrimaryToRegularConstructorCodeRefactoringProvider.cs (2)

238var syntaxTree = grouping.Key; 368var syntaxTree = grouping.Key;

ImplementInterface\CSharpImplementExplicitlyCodeRefactoringProvider.cs (1)

63var document = group.Key;

InitializeParameter\CSharpInitializeMemberFromPrimaryConstructorParameterCodeRefactoringProvider.cs (1)

276var semanticModel = compilation.GetSemanticModel(group.Key);

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

150var typeDeclaration = typeDeclarationGroup.Key; 170var rewrittenAncestor = ancestorGroup.Key;

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

437var parameter = group.Key;

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

107var container = group.Key;

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

533var syntaxTree = group.Key; 606var document = solution.GetDocument(group.Key); 622var document = solution.GetDocument(group.Key);

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

125var groupDocument = group.Key;

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

112var editor = await solutionEditor.GetDocumentEditorAsync(group.Key.Id, cancellationToken).ConfigureAwait(false);

src\roslyn\src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

771dictionary.Add(grouping.Key, [.. grouping]);

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

153var poolInfo = group.Key.PoolName is not null ? $" (from {group.Key.PoolName})" : ""; 154sb.AppendLine($" {group.Key.Type}{poolInfo}: {group.Count()}");

AddImport\AbstractAddImportFeatureService.cs (1)

556document, diagnosticsForSourceSpan.Key, diagnosticsForSourceSpan.AsImmutable(),

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

76var oldProject = grouping.Key;

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

137var tree = removeSuppressionFixesForTree.Key;

CodeRefactorings\AddMissingImports\AbstractAddMissingImportsFeatureService.cs (1)

114.Select(changes => new TextSpan(changes.Key.Start, changes.Sum(change => change.NewText!.Length)));

CodeRefactorings\CodeRefactoringService.cs (1)

38.Select(grp => KeyValuePair.Create(grp.Key,

CodeRefactorings\SyncNamespace\AbstractChangeNamespaceService.cs (2)

493solutionWithChangedNamespace.GetRequiredDocument(refInOneDocument.Key), 503return (solutionWithFixedReferences, refLocationGroups.SelectAsArray(g => g.Key));

ConvertTupleToStruct\AbstractConvertTupleToStructCodeRefactoringProvider.cs (2)

340var project = group.Key; 533var document = solution.GetRequiredDocument(group.Key);

EditAndContinue\DebuggingSession.cs (1)

448builder.Add(item.Key, [.. item]);

EditAndContinue\EditSession.cs (2)

937partialTypeEdits.Key, 967mergedUpdateEditSyntaxMaps.Add(partialTypeEdits.Key, (mergedMatchingNodes, mergedRuntimeRudeEdits));

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)

66await ProcessProjectAsync(group.Key).ConfigureAwait(false);

ExtractMethod\SelectionResult.cs (2)

245var tokenMap = pairs.GroupBy(p => p.Item1, p => p.Item2).ToDictionary(g => g.Key, g => g.ToArray()); 258var tokenMap = pairs.GroupBy(p => p.Item1, p => p.Item2).ToDictionary(g => g.Key, g => g.ToArray());

InheritanceMargin\AbstractInheritanceMarginService_Helpers.cs (1)

235var groupSyntaxTree = group.Key;

NavigateTo\AbstractNavigateToSearchService.CachedDocumentSearch.cs (1)

150var project = group.Key;

NavigateTo\NavigateToSearcher.cs (1)

383var searchService = grouping.Key;

Navigation\NavigableItemFactory.cs (2)

48var generatedSourceLocations = candidateLocationGroups.SingleOrDefault(g => g.Key) ?? SpecializedCollections.EmptyEnumerable<Location>(); 49var nonGeneratedSourceLocations = candidateLocationGroups.SingleOrDefault(g => !g.Key) ?? SpecializedCollections.EmptyEnumerable<Location>();

Options\EditorConfig\EditorConfigFileGenerator.cs (2)

62foreach (var optionGrouping in options.GroupBy(o => o.Definition.Group).OrderBy(g => g.Key.Priority)) 64editorconfig.AppendLine($"# {optionGrouping.Key.Description}");

ReplaceMethodWithProperty\ReplaceMethodWithPropertyCodeRefactoringProvider.cs (1)

190var allReferenceDocuments = getReferencesByDocument.Concat(setReferencesByDocument).Select(g => g.Key).Distinct();

ReplacePropertyWithMethods\ReplacePropertyWithMethodsCodeRefactoringProvider.cs (1)

203updatedSolution, group.Key, group, propertyToBackingField,

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

43if (group.Key == true) 56var language = languageGroup.Key;

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

796var syntaxTree = group.Key;

src\roslyn\src\Analyzers\Core\CodeFixes\AddParameter\AddParameterService.cs (2)

105var document = documentLookup.Key; 175var documentsUpdated = locationsByDocument.Select(g => g.Key).ToSet();

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

62var fieldDeclaration = fieldDeclarators.Key;

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

171var document = group.Key;

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

80predicate: group => group.Key is not null, 81selector: group => (id: solution.GetRequiredDocument(group.Key!).Id, diagnostics: group.ToImmutableArray()));

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

279var memberDeclarations = GetDiagnosticsGroupedByMember(diagnostics, syntaxFacts, root).Select(g => g.Key); 324var containingMemberDeclaration = diagnosticsToFix.Key;

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

326var document = group.Key; 500var document = group.Key;

UnusedReferences\UnusedReferencesRemover.cs (1)

71.ToDictionary(group => group.Key, group => group.ToImmutableArray());

Language\Components\ComponentEventHandlerLoweringPass.cs (2)

132duplicate.Key, 151duplicate.Key,

src\roslyn\src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

771dictionary.Add(grouping.Key, [.. grouping]);

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

153var poolInfo = group.Key.PoolName is not null ? $" (from {group.Key.PoolName})" : ""; 154sb.AppendLine($" {group.Key.Type}{poolInfo}: {group.Count()}");

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\IGroupingExtensions.cs (1)

15key = grouping.Key;

CodeFixes\FixAllOccurrences\BatchFixAllProvider.cs (1)

209var docId = group.Key;

Diagnostics\Extensions.cs (1)

232AddDiagnosticsToResult(group.AsImmutable(), ref result, group.Key, additionalDocumentId: null,

Editing\SymbolEditor.cs (3)

135.ToImmutableDictionary(g => g.Key, g => ImmutableArray.CreateRange(g)); 464var docId = declGroup.Key; 479var doc = ChangedSolution.GetDocument(declGroup.Key);

FindSymbols\ReferenceLocationExtensions.cs (3)

21var projectGroups = documentGroups.GroupBy(g => g.Key.Project); 28var project = projectGroup.Key; 35var document = documentGroup.Key;

Log\StatisticResult.cs (1)

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

ReassignedVariable\AbstractReassignedVariableService.cs (1)

200var otherSemanticModel = GetSemanticModel(group.Key);

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

102.OrderBy(g => topologicallySortedProjects.IndexOf(g.Key)); 104_replacementTextValid = IsIdentifierValid_Worker(baseSolution, _replacementText, documentsGroupedByTopologicallySortedProjectId.Select(g => g.Key)); 146projectId: documentsByProject.Key, 789g => g.Key, 790g => GetSubSpansToRenameInStringAndCommentTextSpans(g.Key, g));

Rename\ConflictEngine\MutableConflictResolution.cs (1)

154g => g.Key, g => g.ToImmutableArray());

Rename\SymbolicRenameLocations.ReferenceProcessing.cs (1)

353var syntaxFactsLanguageService = solution.Services.GetLanguageServices(documentsGroupedByLanguage.Key).GetService<ISyntaxFactsService>();

src\roslyn\src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

771dictionary.Add(grouping.Key, [.. grouping]);

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

153var poolInfo = group.Key.PoolName is not null ? $" (from {group.Key.PoolName})" : ""; 154sb.AppendLine($" {group.Key.Type}{poolInfo}: {group.Count()}");

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\IGroupingExtensions.cs (1)

15key = grouping.Key;

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

208var semanticModel = compilation.GetSemanticModel(group.Key);

Workspace\Solution\SolutionCompilationState.cs (3)

860var projectId = g.Key; 1793var projectId = g.Key; 1817newCompilationState = newCompilationState.RemoveDocumentsFromSingleProject<T>(documentIdsInProject.Key, [.. documentIdsInProject]);

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

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

DataFrameGroupByTests.cs (4)

35var oddGroup = grouping.Where(gr => gr.Key == "odd").FirstOrDefault(); 39var evenGroup = grouping.Where(gr => gr.Key == "even").FirstOrDefault(); 58Assert.Equal("even", grouping.First().Key); 71var groupings = df.GroupBy<int>("Tens").Groupings.ToDictionary(g => g.Key, g => g.ToList());

ApiComparer.cs (1)

143if (processedMetadata.Contains(compatDifferenceGroup.Key))

CreateTrimDependencyGroups.cs (1)

74.Select(dependencyGrouping => new TaskItemPackageDependencyGroup(dependencyGrouping.Key, dependencyGrouping))

GenerateNuSpec.cs (3)

311dependenciesByFramework.Key, 317dependenciesById.Key, 342referencesByFramework.Key,

GenerateRuntimeDependencies.cs (3)

94string targetRuntimeId = runtimeGroup.Key; 112string targetPackageId = targetPackageGroup.Key; 118string dependencyId = dependencyGroup.Key;

GetSupportedPackagesFromPackageReports.cs (1)

36var fx = fxRIDGrouping.Key;

PackageIndex.cs (1)

840writer.WritePropertyName(metaPackage.Key);

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());

GenPartialFacadeSourceGenerator.cs (1)

44.Select(y => y.Key);

Build\FilePathExclusions.cs (1)

76log.LogDebug("Exclusion glob: '{Globs}' under project '{Directory}'", string.Join(";", globsPerDirectory), globsPerDirectory.Key);

Build\LoadedProjectGraph.cs (1)

16keySelector: static g => g.Key,

FileWatcher\FileWatcher.cs (1)

78select (g.Key, containingDirectories ? [] : g.Select(Path.GetFileName).ToImmutableHashSet(PathUtilities.OSSpecificPathComparer));

HotReload\CompilationHandler.cs (1)

1012keySelector: static group => group.Key,

Validators\BaselinePackageValidator.cs (3)

98IReadOnlyList<ContentItem>? latestRuntimeSpecificAssets = options.Package.FindBestRuntimeAssetForFrameworkAndRuntime(baselineTargetFramework, baselineRuntimeSpecificAssetsRidGroup.Key); 101log.LogError(new Suppression(DiagnosticIds.TargetFrameworkAndRidPairDropped) { Target = baselineTargetFramework.ToString() + "-" + baselineRuntimeSpecificAssetsRidGroup.Key }, 105baselineRuntimeSpecificAssetsRidGroup.Key));

src\GeneratePlatformManifestEntriesFromTemplate.cs (1)

32var files = Files.ToLookup(file => Path.GetFileName(file.ItemSpec)).ToDictionary(l => l.Key, l=> l.First());

VerbatimMultiPartHttpHandler.cs (1)

194.ToDictionary(g => g.Key, g => g.Count());

DependencyContextJsonReader.cs (2)

807ridGroup.Key, 819ridGroup.Key,

DependencyContextWriter.cs (1)

429WriteLibrary(libraryGroup.Key, libraryGroup.First(), jsonWriter);

Helpers\OptionsUtilities.cs (1)

56propertyGroup => propertyGroup.Key,

LoggerMessageGenerator.Parser.cs (1)

75SyntaxTree syntaxTree = group.Key;

ContextReceiver.cs (2)

47.SelectMany(declarations => declarations.Select(declaration => (symbol: compilation.GetSemanticModel(declarations.Key).GetDeclaredSymbol(declaration), declaration))) 52group => (INamedTypeSymbol)group.Key!, group => group.ToList(), comparer: SymbolEqualityComparer.Default);

ContextualOptionsGenerator.cs (2)

39.SelectMany(declarations => declarations.Select(declaration => (symbol: compilation.GetSemanticModel(declarations.Key).GetDeclaredSymbol(declaration), declaration))) 44group => (INamedTypeSymbol)group.Key!, group => group.ToList(), comparer: SymbolEqualityComparer.Default);

Parsing\Parser.cs (1)

53SyntaxTree syntaxTree = group.Key;

VtableIndexStubGenerator.cs (1)

164group.Key.WriteToWithUnsafeModifier(writer, group, static (writer, data) =>

ColumnInference\ColumnGroupingInference.cs (4)

76: GetName(g.Key.ItemType.GetRawKind().ToDataKind(), g.Key.Purpose, result); 79result.Add(new GroupingColumn(name, g.Key.ItemType.GetRawKind().ToDataKind(), g.Key.Purpose, ranges));

ColumnInference\TextFileContents.cs (2)

117if (mostCommon.Key <= 1) { return false; } 119result = new ColumnSplitResult(true, options.Separators.First(), options.AllowQuoting, options.ReadMultilines, options.AllowSparse, mostCommon.Key);

Utils\UserInputValidationUtil.cs (1)

304return groups.FirstOrDefault(g => g.Count() > 1)?.Key;

Metrics\FairlearnMetricCatalog.cs (2)

94.ToDictionary(group => group.Key, group => _context.Data.LoadFromEnumerable(group.Select(g => g.Item2))); 230groupMetric[kv.Key] = metrics;

ResultProcessor.cs (2)

174.ToDictionary(g => "/" + g.Key, g => string.Join(",", g)); 537GroupBy(kvp => kvp.Key, kvp => kvp.Value).ToDictionary(g => "/" + g.Key, g => string.Join(",", g));

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;

CheckForDuplicateFrameworkReferences.cs (1)

59Log.LogError(Strings.FrameworkReferenceDuplicateError, duplicateItemGroup.Key);

CheckForDuplicateItemMetadata.cs (1)

35.Select(g => g.Key)

CheckForDuplicateItems.cs (1)

46string duplicateItemsFormatted = string.Join("; ", duplicateItems.Select(d => $"'{d.Key}'"));

CollatePackageDownloads.cs (1)

30var packageDownloadItem = new TaskItem(g.Key);

DependencyContextBuilder.cs (5)

187_compileReferences.Add(group.Key, group.ToList()); 198_resolvedNuGetFiles.Add(group.Key, group.ToList()); 227var dependencyLibrary = new DependencyLibrary("runtimepack." + runtimePackGroup.Key, 692runtimeAssemblyGroups.Add(new RuntimeAssetGroup(runtimeIdentifierGroup.Key, 699nativeLibraryGroups.Add(new RuntimeAssetGroup(runtimeIdentifierGroup.Key,

UpgradeLegacyWasmStaticWebAssets.cs (1)

26.ToDictionary(g => g.Key, g => g.ToArray());

GenerateStaticWebAssetEndpointsManifest.cs (2)

233Log.LogMessage(MessageImportance.Low, "Skipping candidate asset '{0}' because it is not a '{1}' or 'All' asset.", group.Key, kind); 246yield return new TargetPathAssetPair(group.Key, asset);

GenerateStaticWebAssetsDevelopmentManifest.cs (2)

111Log.LogMessage(MessageImportance.Low, "Skipping candidate asset '{0}' because it is a 'Publish' asset.", group.Key); 124yield return new SegmentsAssetPair(group.Key, asset);

MergeStaticWebAssets.cs (1)

35.ToDictionary(g => g.Key, g => g.ToList());

ResolveFingerprintedStaticWebAssetEndpointsForAssets.cs (1)

33.ToDictionary(g => g.Key, g => g.ToArray(), OSPath.PathComparer);

UpdateExternallyDefinedStaticWebAssets.cs (1)

57.ToDictionary(e => e.Key, e => e.ToArray(), OSPath.PathComparer);

UpdateStaticWebAssetEndpoints.cs (2)

46.ToDictionary(e => e.Key, e => e.ToHashSet()); 49.ToDictionary(e => e.Key, e => e.ToHashSet());

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))

TabularOutput\TemplateGroupDisplay.cs (2)

118return string.Join(environment.NewLine, GetAuthorBasedGroups(templateGroup).Select(group => group.Key)); 248.OrderBy(group => group.Key, StringComparer.OrdinalIgnoreCase);

TemplatePackageCoordinator.cs (1)

291var provider = packagesGrouping.Key;

BuiltInManagedProvider\GlobalSettingsTemplatePackageProvider.cs (1)

87tasks.Add(packagesGroupedByInstaller.Key.GetLatestVersionAsync(packagesGroupedByInstaller, this, cancellationToken));

Installers\NuGet\NugetApiPackageManager.cs (1)

525g.Key,

Bootstrapper.cs (3)

305IReadOnlyList<CheckUpdateResult>[] results = await Task.WhenAll(requestsGroupedByProvider.Select(packages => packages.Key.GetLatestVersionsAsync(packages, cancellationToken))).ConfigureAwait(false); 327IReadOnlyList<UpdateResult>[] updateResults = await Task.WhenAll(requestsGroupedByProvider.Select(requests => requests.Key.UpdateAsync(requests, cancellationToken))).ConfigureAwait(false); 349IReadOnlyList<UninstallResult>[] uninstallResults = await Task.WhenAll(requestsGroupedByProvider.Select(packages => packages.Key.UninstallAsync(packages, cancellationToken))).ConfigureAwait(false);

EnumerableExtensions.cs (1)

41.Select(y => y.Key);

Client\InProcessProxyexecutionManager.cs (1)

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

Client\Parallel\ParallelProxyDiscoveryManager.cs (1)

216var testhostProviderInfo = group.Key;

Client\Parallel\ParallelProxyExecutionManager.cs (3)

250Dictionary<string, TestCase[]> sourceToTestCasesMap = testRunCriteria.Tests.GroupBy(t => t.Source).ToDictionary(k => k.Key, v => v.ToArray()); 258var testhostProviderInfo = group.Key; 316var testhostProviderInfo = group.Key;

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)

236.Select(testSessionArtifact => new TestArtifacts(testSessionArtifact.Key!, testSessionArtifact.Select(x => ParseArtifact(x.Artifact)).Where(x => x is not null).ToArray()!)) // Bang because null dataflow doesn't yet backport learning from the `Where` clause

Nuget.Frameworks\FrameworkNameProvider.cs (1)

1128.ToDictionary(g => g.Key, g => new HashSet<string>(g, StringComparer.OrdinalIgnoreCase));

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);

Commands\ConfigCommands\ConfigRunners.cs (1)

219logger.LogMinimal($" file: {configPathsGroup.Key}");

RestoreCommand\ProjectRestoreCommand.cs (3)

67_logger.LogVerbose(string.Format(CultureInfo.CurrentCulture, Strings.Log_RestoringPackages, pair.Key.DotNetFrameworkName)); 69frameworkToAlias?.TryGetValue(pair.Key, out targetAlias); 73pair.Key,

RestoreCommand\Utility\BuildAssetsUtils.cs (1)

783conditions: GetLanguageConditions(group.Key, allLanguages),

RestoreCommand\Utility\ToolRestoreUtility.cs (1)

105if (string.IsNullOrEmpty(toolIdGroup.Key))

ClientCertificate\ClientCertificateProvider.cs (1)

72string.Join(", ", $"'{groupsWithSamePackageSource.Select(g => g.Key)}'"));

Settings\Items\PackageSourceMappingSourceItem.cs (2)

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

FrameworkNameProvider.cs (1)

1140.ToDictionary(g => g.Key, g => new HashSet<string>(g, StringComparer.OrdinalIgnoreCase));

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);

Resolution\PrunePackageTree.cs (1)

69var packagesDict = packages.ToLookup(p => p.Id).ToDictionary(p => p.Key, p => p.ToArray());

Utility\FileSystemUtility.cs (1)

277from directory in GetDirectories(grouping.Key, altDirectorySeparator: false)

Utility\MSBuildNuGetProjectSystemUtility.cs (1)

233from directory in FileSystemUtility.GetDirectories(grouping.Key, altDirectorySeparator: false)

NuspecReader.cs (2)

227if (string.IsNullOrEmpty(group.Key)) 233foreach (var fwString in group.Key!.Split(CommaArray, StringSplitOptions.RemoveEmptyEntries))

PackageCreation\Authoring\ManifestMetadata.cs (2)

227var groupedReferenceSets = referenceSetGroups.Select(group => new PackageReferenceSet(group.Key, group.SelectMany(g => g.References))) 258var groupedDependencySets = dependencySetGroups.Select(group => new PackageDependencyGroup(group.Key, new HashSet<PackageDependency>(group.SelectMany(g => g.Packages))))

Rules\InvalidUndottedFrameworkRule.cs (2)

153if (!string.IsNullOrEmpty(group.Key)) 155foreach (var fwString in group.Key!.Split(CommaArray, StringSplitOptions.RemoveEmptyEntries))

Rules\ReferencesInNuspecMatchRefAssetsRule.cs (5)

73if (files.Key == "unsupported") 81if (nuspecReferences.TryGetValue(files.Key, out var currentReferences) || 103missingReferences.Add(new MissingReference("ref", files.Key, missingFiles)); 108missingReferences.Add(new MissingReference("nuspec", files.Key, missingNuspecReferences)); 185keys.Add(item.Key);

Rules\UpholdBuildConventionRule.cs (11)

74string expectedFileName = tfm.Key == string.Empty 75? buildFolder.Key + packageId + extension.Key 76: buildFolder.Key + tfm.Key + '/' + packageId + extension.Key; 79string packageFolder = tfm.Key == string.Empty ? buildFolder.Key : buildFolder.Key + tfm.Key + '/'; 80expectedFiles.Add(new ExpectedFile(packageFolder, extension.Key!, expectedFileName));

RuntimeModel\JsonRuntimeFormat.cs (1)

151var name = frameworkGroup.Key.GetShortFolderName();

PackageSpecWriter.cs (2)

507foreach (var dependency in downloadDependencies.GroupBy(dep => dep.Name).OrderBy(dep => dep.Key)) 512SetValue(writer, "name", dependency.Key);

SourceRepository.cs (1)

183cache.Add(group.Key, Sort(group));

PackageResolver.cs (3)

128groupsAdded.Add(group.Key); 134if (!context.RequiredPackageIds.Contains(group.Key, StringComparer.OrdinalIgnoreCase)) 136curSet.Add(new ResolverPackage(id: group.Key, version: null, dependencies: null, listed: true, absent: true));

src\roslyn\src\Dependencies\Collections\Extensions\IEnumerableExtensions.cs (1)

771dictionary.Add(grouping.Key, [.. grouping]);

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

153var poolInfo = group.Key.PoolName is not null ? $" (from {group.Key.PoolName})" : ""; 154sb.AppendLine($" {group.Key.Type}{poolInfo}: {group.Count()}");

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\IGroupingExtensions.cs (1)

15key = grouping.Key;

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

208var semanticModel = compilation.GetSemanticModel(group.Key);

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

112var editor = await solutionEditor.GetDocumentEditorAsync(group.Key.Id, cancellationToken).ConfigureAwait(false);

CalculateTemplateVersions.cs (2)

48.ToDictionary(g => g.Key, g => 53throw new InvalidOperationException("Could not find single item with UseVersionForTemplateInstallPath for templates with TemplateFrameworkVersion: " + g.Key);

shells\FishShellProvider.cs (1)

151WriteMultiValueSkipLoop(writer, group.Key);

System\Linq\Lookup.cs (1)

291return GetGrouping(item.Key, create: false) is { } grouping && grouping == item;

System\Linq\Parallel\Utils\Lookup.cs (3)

113if (_comparer.Equals(grouping.Key, default)) 121Debug.Assert(!_dict.ContainsKey(grouping.Key)); 123_dict.Add(grouping.Key, grouping);

System\Linq\ParallelEnumerable.cs (4)

1414.Select<IGrouping<TKey, TSource>, TResult>(delegate (IGrouping<TKey, TSource> grouping) { return resultSelector(grouping.Key, grouping); }); 1441delegate (IGrouping<TKey, TSource> grouping) { return resultSelector(grouping.Key, grouping); }); 1471.Select<IGrouping<TKey, TElement>, TResult>(delegate (IGrouping<TKey, TElement> grouping) { return resultSelector(grouping.Key, grouping); }); 1502.Select<IGrouping<TKey, TElement>, TResult>(delegate (IGrouping<TKey, TElement> grouping) { return resultSelector(grouping.Key, grouping); });

src\roslyn\src\Compilers\Server\VBCSCompiler\CompilationCache.cs (2)

693.OrderBy(g => g.Key, StringComparer.OrdinalIgnoreCase); 698sb.AppendLine($" {group.Key} ({group.Count()})");

Internal\ConsoleLogger.cs (2)

707var source = sd.Key; 768var sourceName = Path.GetFileName(sd.Key);

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

707var source = sd.Key; 768var sourceName = Path.GetFileName(sd.Key);