Key

Collections\Grouping.cs (1)

18public TKey Key { get; }

GroupBy.cs (1)

89public TKey Key => _key;

System\Linq\Grouping.cs (1)

397public TKey Key => _key;

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

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

DiagnosticAnalyzerRunner.cs (2)

138Console.WriteLine($" {solution.GetProject(projectGroup.Key).Name}"); 297group => group.Key,

Otlp\Model\OtlpApplication.cs (1)

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

Controls\StructuredLogDetailsTests.cs (1)

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

Dcp\ApplicationExecutor.cs (1)

1257tasks.Add(CreateResourceExecutablesAsyncCore(group.Key, group, cancellationToken));

DistributedApplicationBuilder.cs (1)

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

AzureContainerAppsInfrastructure.cs (1)

348Port = g.Key,

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

321case {byLength.Key}:{AppendSwitchSection(byLength.Key, byLength.OrderBy(h => h, KnownHeaderComparer.Instance).ToList())} 454if ({byFirstTerm.Key.Replace(firstTermVarExpression, firstTermVar)}) 973case {byLength.Key}: 1018case {byLength.Key}: 1049case {byLength.Key}: 1097case {byLength.Key}: 1324{AppendSwitch(loop.Headers.GroupBy(x => x.Name.Length).OrderBy(x => x.Key))} 1507Name = g.Key, 1508Header = headers.SingleOrDefault(knownHeader => string.Equals(knownHeader.Name, g.Key, StringComparison.OrdinalIgnoreCase)), 1528Name = g.Key, 1529Header = headers.SingleOrDefault(knownHeader => string.Equals(knownHeader.Name, g.Key, StringComparison.OrdinalIgnoreCase)),

NavigateToBenchmarks.cs (1)

228var service = grouping.Key;

Http2\Http2TestBase.cs (1)

985.ToDictionary(g => g.Key, g => new StringValues(g.Select(values => values.Value).ToArray()));

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

715.ToDictionary(g => g.Key, g => new StringValues(g.Select(values => values.Value).ToArray()));

StaticFileRegeneration\RegenerateThirdPartyNotices.cs (1)

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

IOperationClassWriter.cs (2)

105var @namespace = grouping.Key ?? "Operations"; 317.ToDictionary(g => g.Key, g => g.Select(k => (entryName: k.entry, k.node)));

Routing\RouteTableFactoryTests.cs (1)

1143.ToDictionary(group => group.Key, group => group.Select(g => g.Template).ToArray());

Internal\XmlComments\GrpcXmlCommentsDocumentFilter.cs (1)

33.Select(group => new KeyValuePair<string, ActionDescriptor>(group.Key, group.First()));

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

CompilationFailedExceptionFactory.cs (2)

34var filePath = group.Key; 60var sourceFilePath = group.Key;

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\Http\Routing\test\UnitTests\Matching\RouteMatcherBuilder.cs (2)

36.OrderBy(g => g.Key.Order) 37.ThenBy(g => g.Key.InboundPrecedence);

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

43.OrderBy(g => g.Key.Order) 44.ThenBy(g => g.Key.InboundPrecedence);

Matching\DfaMatcherBuilderTest.cs (3)

3606.Select(g => new PolicyNodeEdge(g.Key, g.ToArray())) 3648.Select(g => new PolicyNodeEdge(g.Key, g.ToArray())) 3673.Select(g => new PolicyNodeEdge(g.Key, g.ToArray()))

Matching\RouteMatcherBuilder.cs (2)

36.OrderBy(g => g.Key.Order) 37.ThenBy(g => g.Key.InboundPrecedence);

Matching\TreeRouterMatcherBuilder.cs (2)

43.OrderBy(g => g.Key.Order) 44.ThenBy(g => g.Key.InboundPrecedence);

Http2\Http2HPackEncoderTests.cs (1)

664.ToDictionary(g => g.Key, g => new StringValues(g.Select(gg => gg.Value).ToArray()));

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

321case {byLength.Key}:{AppendSwitchSection(byLength.Key, byLength.OrderBy(h => h, KnownHeaderComparer.Instance).ToList())} 454if ({byFirstTerm.Key.Replace(firstTermVarExpression, firstTermVar)}) 973case {byLength.Key}: 1018case {byLength.Key}: 1049case {byLength.Key}: 1097case {byLength.Key}: 1324{AppendSwitch(loop.Headers.GroupBy(x => x.Name.Length).OrderBy(x => x.Key))}

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

715.ToDictionary(g => g.Key, g => new StringValues(g.Select(values => values.Value).ToArray()));

GenerateMSBuildEditorConfig.cs (1)

89EncodeString(builder, group.Key);

GetSDKReferenceFiles.cs (1)

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

Hash_Tests.cs (1)

99.Select(g => g.Key);

Mappings\AttributesMapping.cs (2)

49if (!_attributes.TryGetValue(attrGroup.Key, out mapping)) 52_attributes.Add(attrGroup.Key, mapping);

CommandLine\ReportAnalyzerUtil.cs (2)

88consoleOutput.WriteLine(GetColumnEntry(executionTime, percentage, analyzerGroup.Key.FullName, culture)); 135consoleOutput.WriteLine(GetColumnEntry(executionTime, percentage, generatorGroup.Key.FullName, culture));

DiagnosticAnalyzer\AnalysisResultBuilder.cs (1)

343var key = diagsByKey.Key;

DiagnosticAnalyzer\AnalyzerDriver.cs (3)

1477builder.Add((analyzerAndActions.Key, actionsByKind)); 1491builder.Add((analyzerAndActions.Key, analyzerAndActions.ToImmutableArray())); 1834var analyzer = groupedActions.Key;

InternalUtilities\EnumerableExtensions.cs (1)

767dictionary.Add(grouping.Key, items);

MetadataReader\MetadataHelpers.cs (2)

807while (pair.Key.Length == namespaceNameLength) 829string childNamespaceName = ExtractSimpleNameOfChildNamespace(namespaceNameLength, pair.Key);

MetadataReader\PEModule.cs (4)

705int result = _nameComparer.Compare(left.Key, right.Key); 725result = string.CompareOrdinal(left.Key, right.Key);

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

48if (group.Key == true) 61var language = languageGroup.Key;

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

619var syntaxTree = group.Key;

src\Compilers\Core\Portable\InternalUtilities\EnumerableExtensions.cs (1)

767dictionary.Add(grouping.Key, items);

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

15key = grouping.Key;

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

64var fieldDeclaration = fieldDeclarators.Key;

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

173var document = group.Key;

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

79.Where(group => group.Key is not null)

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

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

BoundTree\LengthBasedStringSwitchData.cs (1)

194char character = group.Key;

Lowering\IteratorRewriter\IteratorMethodToStateMachineRewriter.cs (1)

267EmitFinallyFrame(g.Key, state),

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

288children.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\Analyzers\CSharp\CodeFixes\UsePrimaryConstructor\CSharpUsePrimaryConstructorCodeFixProvider.cs (1)

492var syntaxTree = group.Key;

CodeGen\CodeGenAsyncLocalsTests.cs (1)

968Assert.Equal(1, spillFieldsByType.Single(x => TypeSymbol.Equals(x.Key, comp.GetSpecialType(SpecialType.System_Int32), TypeCompareKind.ConsiderEverything2)).Count());

InitializeParameter\CSharpInitializeMemberFromPrimaryConstructorParameterCodeRefactoringProvider.cs (1)

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

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

492var syntaxTree = group.Key;

CompilationTestUtils.cs (1)

467var methodSyntax = annotations.Key;

DiagnosticTestUtilities.cs (1)

191var actualGroup = actualCodes.SingleOrDefault(x => x.Key == expectedGroup.Key);

CodeActions\CodeChangeProviderMetadataTests.cs (2)

68if (string.IsNullOrEmpty(namedGroup.Key)) 79failureMessage.AppendLine($"'{namedGroup.Key}' is used by the following providers: {providerNames}");

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)

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

EditAndContinue\DebuggingSession.cs (1)

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

EditAndContinue\EditAndContinueService.cs (1)

188let project = solution.GetRequiredProject(projectDocumentIds.Key)

ExternalAccess\VSTypeScript\VSTypeScriptNavigateToSearchService.cs (1)

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

ExtractMethod\MethodExtractor.cs (1)

196var tokenMap = annotations.GroupBy(p => p.Item1, p => p.Item2).ToDictionary(g => g.Key, g => g.ToArray());

ExtractMethod\SelectionResult.cs (2)

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

NavigateTo\AbstractNavigateToSearchService.CachedDocumentSearch.cs (1)

137var project = group.Key;

NavigateTo\NavigateToSearcher.cs (1)

382var searchService = grouping.Key;

ReplaceMethodWithProperty\ReplaceMethodWithPropertyCodeRefactoringProvider.cs (1)

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

ReplacePropertyWithMethods\ReplacePropertyWithMethodsCodeRefactoringProvider.cs (1)

210updatedSolution, group.Key, group, propertyToBackingField,

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

48if (group.Key == true)

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

64var fieldDeclaration = fieldDeclarators.Key;

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

173var document = group.Key;

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

79.Where(group => group.Key is not null)

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

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

HostWorkspace\ProjectDependencyHelper.cs (1)

112.ToImmutableDictionary(g => g.Key, g => g.ToImmutableArray(), StringComparer.OrdinalIgnoreCase);

Features\UnifiedSuggestions\UnifiedSuggestedActionsSource.cs (1)

395var priority = group.Key;

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

119throw new InvalidOperationException($"Language specific handlers for {methodGroup.Key} have mis-matched number of parameters:{Environment.NewLine}{string.Join(Environment.NewLine, methodGroup)}"); 124throw new InvalidOperationException($"Language specific handlers for {methodGroup.Key} have mis-matched number of returns:{Environment.NewLine}{string.Join(Environment.NewLine, methodGroup)}"); 127var delegatingEntryPoint = CreateDelegatingEntryPoint(methodGroup.Key); 128var methodAttribute = new JsonRpcMethodAttribute(methodGroup.Key)

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

123genericMethodMap.Add(methodGroup.Key, languages.ToFrozenDictionary());

CachingLookupTests.cs (2)

123foreach (string k in look1.Select(g => g.Key)) 143foreach (string k in look2.Select(g => g.Key))

Collections\List\CollectionAsserts.cs (8)

85Assert.Equal(e.Where(kv => kv.Key != null).ToDictionary(g => g.Key!, g => g.Count()), a.Where(kv => kv.Key != null).ToDictionary(g => g.Key!, g => g.Count())); 104Assert.Equal(e.Where(kv => kv.Key != null).ToDictionary(g => g.Key!, g => g.Count()), a.Where(kv => kv.Key != null).ToDictionary(g => g.Key!, g => g.Count()));

CodeFixes\FixAllOccurrences\BatchFixAllProvider.cs (1)

210var docId = group.Key;

Diagnostics\Extensions.cs (1)

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

Editing\SymbolEditor.cs (3)

135.ToImmutableDictionary(g => g.Key, g => ImmutableArray.CreateRange(g)); 469var docId = declGroup.Key; 484var 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 (3)

106.OrderBy(g => topologicallySortedProjects.IndexOf(g.Key)); 108_replacementTextValid = IsIdentifierValid_Worker(baseSolution, _replacementText, documentsGroupedByTopologicallySortedProjectId.Select(g => g.Key)); 149projectId: documentsByProject.Key,

Rename\ConflictEngine\MutableConflictResolution.cs (1)

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

Rename\SymbolicRenameLocations.ReferenceProcessing.cs (1)

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

src\Compilers\Core\Portable\InternalUtilities\EnumerableExtensions.cs (1)

767dictionary.Add(grouping.Key, items);

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

15key = grouping.Key;

Workspace\Solution\SolutionCompilationState.cs (2)

806var projectId = g.Key; 1674newCompilationState = 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()}");

src\Compilers\Core\Portable\InternalUtilities\EnumerableExtensions.cs (1)

767dictionary.Add(grouping.Key, items);

AbstractLanguageServer.cs (4)

119throw new InvalidOperationException($"Language specific handlers for {methodGroup.Key} have mis-matched number of parameters:{Environment.NewLine}{string.Join(Environment.NewLine, methodGroup)}"); 124throw new InvalidOperationException($"Language specific handlers for {methodGroup.Key} have mis-matched number of returns:{Environment.NewLine}{string.Join(Environment.NewLine, methodGroup)}"); 127var delegatingEntryPoint = CreateDelegatingEntryPoint(methodGroup.Key); 128var methodAttribute = new JsonRpcMethodAttribute(methodGroup.Key)

RequestExecutionQueue.cs (1)

123genericMethodMap.Add(methodGroup.Key, languages.ToFrozenDictionary());

DataFrameGroupByTests.cs (4)

29var oddGroup = grouping.Where(gr => gr.Key == "odd").FirstOrDefault(); 33var evenGroup = grouping.Where(gr => gr.Key == "even").FirstOrDefault(); 52Assert.Equal("even", grouping.First().Key); 65var groupings = df.GroupBy<int>("Tens").Groupings.ToDictionary(g => g.Key, g => g.ToList());

src\GenerateJsonObjectString.cs (1)

56result.Append(group.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)

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

GenPartialFacadeSourceGenerator.cs (1)

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

src\GeneratePlatformManifestEntriesFromTemplate.cs (1)

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

src\SignTool.cs (1)

84var certificate = osxFileGroup.Key;

Modeler\ServiceClientModelFactory.cs (1)

127.Select(g => CreateMethodGroupModel(g.Key, g))

Automation\PullRequestCreator.cs (1)

195.Select(g => $"{g.Count()}{g.Key}")

DependencyContextJsonReader.cs (2)

795ridGroup.Key, 807ridGroup.Key,

DependencyContextWriter.cs (1)

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

Helpers\OptionsUtilities.cs (1)

56propertyGroup => propertyGroup.Key,

BlobLoggerProvider.cs (1)

63var key = eventGroup.Key;

FileLoggerProvider.cs (1)

45var fullName = GetFullName(group.Key);

LoggerMessageGenerator.Parser.cs (1)

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

438ContainingSyntaxContext containingSyntax = vtableMethods.Key.AddContainingSyntax(NativeTypeContainingSyntax);

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

TableDataSource\Suppression\VisualStudioSuppressionFixService.cs (1)

491var projectId = group.Key;

MinimizeUtil.cs (2)

200var destFileName = Path.GetRelativePath(group.Key, tuple.FilePath.RelativePath); 246var destFilePath = Path.GetRelativePath(group.Key, tuple.FilePath.RelativePath);

AssemblyScheduler.cs (2)

323.Select(group => new TypeInfo(GetName(group.Key), group.Key, group.Select(test => new TestMethodInfo(GetName(test), test, TimeSpan.Zero)).ToImmutableArray()))

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

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

401ridGroup.Key, 413ridGroup.Key,