Count

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.cs (2)

101if (statementIndex + 1 < state.OutermostBlockStatements.Count && 148if (statementIndex + 1 < state.OutermostBlockStatements.Count)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\ParsedDocument.cs (2)

82if (textChanges.Count > 1 || 83textChanges.Count == 1 && textChanges[0].Span != new TextSpan(0, oldDocument.Text.Length))

Microsoft.CodeAnalysis.CSharp (11)

BoundTree\UnboundLambda.cs (2)

1420var nx = x.Arguments?.Count ?? 0; 1421var ny = y.Arguments?.Count ?? 0;

Compiler\MethodCompiler.cs (2)

1231if (capturedParameters.Count != 0) 1235var initializers = ArrayBuilder<BoundStatement>.GetInstance(capturedParameters.Count);

Lowering\LocalRewriter\LocalRewriter_Conversion.cs (1)

145var builder = ArrayBuilder<BoundExpression>.GetInstance(bytes.Count + 1);

Symbols\Source\SourceMemberContainerSymbol.cs (1)

4256var members = ArrayBuilder<Symbol>.GetInstance(membersSoFar.Count + 1);

Symbols\Synthesized\Records\SynthesizedPrimaryConstructor.cs (3)

115if (capturedParameters.Count == 0) 214int count = oldSet.Count; 215Debug.Assert(count == value.Count);

Syntax\CSharpSyntaxTree.cs (2)

541if (changes.Count == 0 && newText == oldText) 564if (workingChanges.Count == 1 && workingChanges[0].Span == new TextSpan(0, this.Length) && workingChanges[0].NewLength == newText.Length)

Microsoft.CodeAnalysis.CSharp.CodeStyle (2)

src\Analyzers\CSharp\Analyzers\UseSimpleUsingStatement\UseSimpleUsingStatementDiagnosticAnalyzer.cs (2)

239while (index + 1 < statements.Count && statements[index + 1] is LocalFunctionStatementSyntax) 243if (index == statements.Count - 1)

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

src\Analyzers\CSharp\CodeFixes\UseLocalFunction\CSharpUseLocalFunctionCodeFixProvider.cs (2)

69var references = new List<ExpressionSyntax>(diagnostic.AdditionalLocations.Count - 2); 71for (var i = 2; i < diagnostic.AdditionalLocations.Count; i++)

src\Analyzers\CSharp\CodeFixes\UseSimpleUsingStatement\UseSimpleUsingStatementCodeFixProvider.cs (1)

92for (var i = 0; i < list.Count; i++)

Microsoft.CodeAnalysis.CSharp.EditorFeatures.UnitTests (2)

CodeActions\PreviewTests.cs (1)

76var removedReference = _oldDocument.Project.MetadataReferences[_oldDocument.Project.MetadataReferences.Count - 1];

Workspaces\WorkspaceTests_EditorFeatures.cs (1)

1057Assert.Equal(1, project.AdditionalDocumentIds.Count);

Microsoft.CodeAnalysis.CSharp.Features (10)

AddImport\CSharpAddImportFeatureService.cs (1)

397CreateNameSyntax(namespaceParts, namespaceParts.Count - 1));

src\Analyzers\CSharp\Analyzers\UseSimpleUsingStatement\UseSimpleUsingStatementDiagnosticAnalyzer.cs (2)

239while (index + 1 < statements.Count && statements[index + 1] is LocalFunctionStatementSyntax) 243if (index == statements.Count - 1)

src\Analyzers\CSharp\CodeFixes\InlineDeclaration\CSharpInlineDeclarationCodeFixProvider.cs (1)

159for (var i = declarationIndex + 1; i < statements.Count; i++)

src\Analyzers\CSharp\CodeFixes\UseLocalFunction\CSharpUseLocalFunctionCodeFixProvider.cs (2)

69var references = new List<ExpressionSyntax>(diagnostic.AdditionalLocations.Count - 2); 71for (var i = 2; i < diagnostic.AdditionalLocations.Count; i++)

src\Analyzers\CSharp\CodeFixes\UseSimpleUsingStatement\UseSimpleUsingStatementCodeFixProvider.cs (3)

73if (originalBlockStatements.Count == currentBlockStatements.Count) 92for (var i = 0; i < list.Count; i++)

Wrapping\SeparatedSyntaxList\CSharpParameterWrapper.cs (1)

63var firstToken = attributes?.Count > 0

Microsoft.CodeAnalysis.CSharp.Syntax.UnitTests (2)

Parsing\LocalFunctionParsingTests.cs (2)

1293Assert.Equal(0, file.SyntaxTree.Options.Features.Count); 1345Assert.Equal(0, file.SyntaxTree.Options.Features.Count);

Microsoft.CodeAnalysis.CSharp.Workspaces (10)

CodeGeneration\CSharpSyntaxGenerator.cs (10)

1035if (index >= 0 && index < existingAttributes.Count) 1039else if (existingAttributes.Count > 0) 1041return this.InsertNodesAfter(declaration, existingAttributes[existingAttributes.Count - 1], WithRequiredTargetSpecifier(newAttributes, declaration)); 1070if (index >= 0 && index < existingAttributes.Count) 1074else if (existingAttributes.Count > 0) 1076return this.InsertNodesAfter(d, existingAttributes[existingAttributes.Count - 1], newAttributes); 1352if (index >= 0 && index < existingMembers.Count) 1356else if (existingMembers.Count > 0) 1358return this.InsertNodesAfter(declaration, existingMembers[existingMembers.Count - 1], newMembers); 2911var count = subDecls.Count;

Microsoft.CodeAnalysis.CSharp.Workspaces.UnitTests (65)

CodeGeneration\SyntaxGeneratorTests.cs (65)

Microsoft.CodeAnalysis.Debugging.Package (6)

CustomDebugInfoEncoder.cs (6)

Microsoft.CodeAnalysis.EditorFeatures (12)

IntelliSense\AsyncCompletion\ItemManager.CompletionListUpdater.cs (9)

343Debug.Assert(matchResults.Count > 0); 370for (var i = 1; i < matchResults.Count; ++i) 395for (selectedItemIndex = 0; selectedItemIndex < matchResults.Count; ++selectedItemIndex) 401Debug.Assert(selectedItemIndex < matchResults.Count); 490for (var i = 0; i < items.Count; ++i) 682Debug.Assert(filteredMatchResults.Count > 0); 687for (int i = 1, n = filteredMatchResults.Count; i < n; i++) 865inferiorItemIndex = matches.Count; 881while (++inferiorItemIndex < matches.Count)

Structure\StructureTag.cs (3)

81Hash.Combine(this.SubHeadings?.Count ?? 0, this.GuideLineSpan.GetHashCode())))))))); 103if (this.SubHeadings.Count != other.SubHeadings.Count) 106for (int i = 0, n = this.SubHeadings.Count; i < n; i++)

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

Completion\AbstractCompletionProviderTests.cs (1)

202Assert.Equal(items.Count, 0);

Microsoft.CodeAnalysis.EditorFeatures.UnitTests (12)

Preview\PreviewWorkspaceTests.cs (5)

61Assert.Equal(0, previewWorkspace.CurrentSolution.ProjectIds.Count); 76Assert.Equal(1, previewWorkspace.CurrentSolution.Projects.First().MetadataReferences.Count); 77Assert.Equal(1, previewWorkspace.CurrentSolution.Projects.First().DocumentIds.Count); 89Assert.Equal(0, previewWorkspace.CurrentSolution.Projects.First().MetadataReferences.Count); 90Assert.Equal(0, previewWorkspace.CurrentSolution.Projects.First().DocumentIds.Count);

Tagging\TagSpanIntervalTreeTests.cs (7)

87Assert.Equal(50, GetIntersectingSpans(tree, new SnapshotSpan(buffer.CurrentSnapshot, 150, 50)).Count); 90Assert.Equal(26, GetIntersectingSpans(tree, new SnapshotSpan(buffer.CurrentSnapshot, 175, 25)).Count); 101Assert.Equal(1, GetIntersectingSpans(tree, new SnapshotSpan(buffer.CurrentSnapshot, 0, 1)).Count); 102Assert.Equal(1, GetIntersectingSpans(tree, new SnapshotSpan(buffer.CurrentSnapshot, 50, 1)).Count); 105Assert.Equal(2, GetIntersectingSpans(tree, new SnapshotSpan(buffer.CurrentSnapshot, 100, 1)).Count); 119Assert.Equal(51, GetIntersectingSpans(tree, new SnapshotSpan(buffer.CurrentSnapshot, 0, 1)).Count); 133Assert.Equal(51, GetIntersectingSpans(tree, new SnapshotSpan(buffer.CurrentSnapshot, 99, 1)).Count);

Microsoft.CodeAnalysis.EditorFeatures.Wpf (1)

NavigateTo\NavigateToItemProvider.cs (1)

102if (kinds == null || kinds.Count == 0)

Microsoft.CodeAnalysis.EditorFeatures2.UnitTests (2)

IntelliSense\CompletionServiceTests.vb (1)

43Assert.True(list.ItemsList.Count = 1, "Completion list contained more than one item")

IntelliSense\CompletionServiceTests_Exclusivitiy.vb (1)

48Assert.True(list.ItemsList.Count = 2, "Completion List does not contain exactly two items.")

Microsoft.CodeAnalysis.ExpressionEvaluator.ResultProvider.Utilities (1)

ResultProviderTestBase.cs (1)

353int n = actual.Count;

Microsoft.CodeAnalysis.Features (53)

AddImport\AbstractAddImportFeatureService.cs (2)

145var projectToAssembly = new ConcurrentDictionary<Project, AsyncLazy<IAssemblySymbol>>(concurrencyLevel: 2, capacity: project.Solution.ProjectIds.Count); 146var referenceToCompilation = new ConcurrentDictionary<PortableExecutableReference, Compilation>(concurrencyLevel: 2, capacity: project.Solution.Projects.Sum(p => p.MetadataReferences.Count));

CodeRefactorings\SyncNamespace\AbstractChangeNamespaceService.cs (1)

591if (refLocations.Count > 0)

Completion\CompletionList.cs (1)

188internal bool IsEmpty => ItemsList.Count == 0 && SuggestionModeItem is null;

Completion\Providers\AbstractAggregateEmbeddedLanguageCompletionProvider.cs (2)

96var count = context.Items.Count; 99if (context.Items.Count > count)

Completion\Providers\AbstractInternalsVisibleToCompletionProvider.cs (1)

164if (context.Items.Count > 0)

EditAndContinue\AbstractEditAndContinueAnalyzer.cs (1)

2508if (editScript.Edits.Length == 0 && triviaEdits.Count == 0)

EditAndContinue\DeclarationBodyMap.cs (2)

29Contract.ThrowIfFalse(forwardMatch.Count == reverseMatch.Count);

EditAndContinue\EditSession.cs (5)

687using var _0 = ArrayBuilder<SemanticEdit>.GetInstance(edits.Count, out var mergedEditsBuilder); 689using var _2 = ArrayBuilder<(ISymbol? oldSymbol, ISymbol? newSymbol)>.GetInstance(edits.Count, out var resolvedSymbols); 724for (var i = 0; i < edits.Count; i++) 748if (edits.Count == mergedEditsBuilder.Count) 789for (var i = 0; i < edits.Count; i++)

EditAndContinue\Utilities\BidirectionalMap.cs (7)

21Contract.ThrowIfFalse(forward.Count == reverse.Count); 28var forward = new Dictionary<T, T>(Forward.Count + 1); 29var reverse = new Dictionary<T, T>(Reverse.Count + 1); 44if (map.Forward.Count == 0) 49var count = Forward.Count + map.Forward.Count;

EmbeddedLanguages\DateAndTime\DateAndTimeEmbeddedCompletionProvider.cs (1)

120var sortText = context.Items.Count.ToString("0000");

EmbeddedLanguages\RegularExpressions\LanguageServices\RegexEmbeddedCompletionProvider.cs (1)

112var sortText = context.Items.Count.ToString("0000");

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

624count += project.DocumentIds.Count;

NavigateTo\RoslynNavigateToItem.cs (4)

251var activeDiff = activeFolders.Count - commonCount; 252var itemDiff = itemFolders.Count - commonCount; 263var maxCommon = Math.Min(activeFolders.Count, itemFolders.Count);

SplitOrMergeIfStatements\AbstractMergeIfStatementsCodeRefactoringProvider.cs (3)

95while (statements.Count == 1 && blockFacts.IsScopeBlock(statements[0])) 117blockFacts.GetExecutableBlockStatements(parent).Count == statements.Count)

SplitOrMergeIfStatements\Consecutive\AbstractMergeConsecutiveIfStatementsCodeRefactoringProvider.cs (2)

206if (insideStatements.Count == 0) 220var controlFlow = semanticModel.AnalyzeControlFlow(insideStatements[0], insideStatements[insideStatements.Count - 1]);

SplitOrMergeIfStatements\Consecutive\AbstractSplitIntoConsecutiveIfStatementsCodeRefactoringProvider.cs (2)

137if (insideStatements.Count == 0) 152var controlFlow = semanticModel.AnalyzeControlFlow(insideStatements[0], insideStatements[insideStatements.Count - 1]);

SplitOrMergeIfStatements\Nested\AbstractMergeNestedIfStatementsCodeRefactoringProvider.cs (6)

102if (statements.Count > 0 && statements[0] == statement) 105if (rootStatements.Count > 0 && ifGenerator.IsIfOrElseIf(rootStatements[0].Parent)) 133if (statements.Count > 0 && ifGenerator.IsIfOrElseIf(statements[0])) 176if (statements.Count == 1) 216if (!remainingStatements.SequenceEqual(remainingOuterStatements.Take(statements.Count - 1), syntaxFacts.AreEquivalent)) 222var controlFlow = semanticModel.AnalyzeControlFlow(statements[0], statements[statements.Count - 1]);

src\Analyzers\Core\Analyzers\FileHeaders\AbstractFileHeaderHelper.cs (1)

138for (var index = 0; index < triviaList.Count; index++)

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

120var insertionIndex = newParameterIndex ?? existingParameters.Count; 141if (method.MethodKind == MethodKind.ReducedExtension && insertionIndex < existingParameters.Count)

src\Analyzers\Core\CodeFixes\RemoveAsyncModifier\AbstractRemoveAsyncModifierCodeFixProvider.cs (2)

169if (statements.Count > 0) 171return semanticModel.AnalyzeControlFlow(statements[0], statements[statements.Count - 1]);

src\Dependencies\CodeAnalysis.Debugging\CustomDebugInfoEncoder.cs (6)

Microsoft.CodeAnalysis.LanguageServer.Protocol (9)

Features\Diagnostics\EngineV2\DiagnosticIncrementalAnalyzer.InProcOrRemoteHostAnalyzerRunner.cs (1)

174var count = documentAnalysisScope != null ? 1 : project.DocumentIds.Count + 1;

Features\Diagnostics\EngineV2\DiagnosticIncrementalAnalyzer.StateManager.ProjectStates.cs (1)

77if (project.AnalyzerReferences.Count == 0)

Handler\Completion\CompletionHandler.cs (3)

211if (completionListMaxSize < 0 || completionListMaxSize >= completionList.ItemsList.Count) 258? completionList.ItemsList.Count > newCompletionList.ItemsList.Count

Handler\Completion\CompletionResultFactory.cs (1)

46if (list.ItemsList.Count == 0)

Protocol\Converters\SumConverter.cs (3)

199if (applicableUnionTypeInfos.Count > 0) 209for (var i = 0; i < applicableUnionTypeInfos.Count; i++) 226for (var i = 0; i < applicableUnionTypeInfos.Count; i++)

Microsoft.CodeAnalysis.Remote.ServiceHub (3)

Host\RemoteWorkspace.cs (1)

275using var _ = ArrayBuilder<ProjectInfo>.GetInstance(solutionInfo.Projects.Count, out var projectInfos);

Host\RemoteWorkspace.SolutionCreator.cs (1)

130Debug.Assert(solution.ProjectIds.Count == newVersions.Map.Count);

Services\DiagnosticAnalyzer\DiagnosticComputer.cs (1)

392unitCount += _project.DocumentIds.Count;

Microsoft.CodeAnalysis.Test.Utilities (1)

Diagnostics\DiagnosticDescription.cs (1)

171if (args == null || args.Count == 0)

Microsoft.CodeAnalysis.UnitTests (42)

Collections\ImmutableDictionaryTestBase.cs (7)

46Assert.Equal(2, map.Count); 49Assert.Equal(2, map.Count); 66Assert.Equal(2, map.Count); 74Assert.Equal(3, map.Count); 84Assert.Equal(3, map.Count); 93Assert.Equal(2, map.Count); 241Assert.Equal(0, empty.Count);

Collections\ImmutableDictionaryTestBase.nonnetstandard.cs (6)

93Assert.Equal(100, map.Count); 149Assert.Equal(10, map.Count); 163Assert.Equal(10, map.Count); 180Assert.Equal(inputs.Length, map.Count); 191Assert.Equal(0, map.Count); 203Assert.Equal(1, halfRemoved.Count);

Collections\ImmutableSegmentedListTest.cs (4)

376Assert.Equal(9, list2.Count); 380Assert.Equal(8, list2.Count); 384Assert.Equal(7, list2.Count); 388Assert.Equal(5, list2.Count);

Collections\ImmutableSetTest.cs (12)

226Assert.Equal(1, set.Count); 269Assert.Equal(expectedValues.Length, set.Count); 289Assert.Equal(0, emptySet.Count); //, "Empty set should have a Count of 0"); 394int initialCount = set.Count; 400Assert.Equal(initialCount - removedCount, set.Count); 401Assert.Equal(initialCount - removedCount - 1, nextSet.Count); 408Assert.Equal(initialCount - removedCount, set.Count); 490int initialCount = set.Count; 494Assert.Equal(initialCount + uniqueValues.Count, enumerateAddSet.Count); 505Assert.True(nextSet.Count > 0); 506Assert.Equal(initialCount + addedCount, set.Count); 512Assert.Equal(expectedCount, nextSet.Count);

Collections\ImmutableSetTest.nonnetstandard.cs (1)

139Assert.True(set.Intersect(Enumerable.Empty<T>()).Count == 0);

Collections\SegmentedArrayTests.cs (2)

61Assert.Equal(0, ((IReadOnlyCollection<IntPtr>)data).Count); 133Assert.Equal(length, ((IReadOnlyCollection<IntPtr>)data).Count);

Text\TextChangeTests.cs (10)

77Assert.Equal(1, changes.Count); 662Assert.Equal(1, changes.Count); 718Assert.Equal(1, changes.Count); 732Assert.Equal(1, changes.Count); 746Assert.Equal(1, changes.Count); 852Assert.Equal(1, changes.Count); 866Assert.Equal(2, changes.Count); 882Assert.Equal(2, changes.Count); 899Assert.Equal(1, changes.Count); 917Assert.Equal(1, changes.Count);

Microsoft.CodeAnalysis.VisualBasic (1)

Binding\Binder_XmlLiterals.vb (1)

1431Debug.Assert(namespaces.Count > 0)

Microsoft.CodeAnalysis.VisualBasic.CommandLine.UnitTests (3)

CommandLineArgumentsTests.vb (2)

230Assert.Equal(1, dict.Count) 264Assert.Equal(1, dict.Count)

CommandLineTests.vb (1)

7758Assert.Equal(2, args.ParseOptions.Features.Count)

Microsoft.CodeAnalysis.VisualBasic.Features (1)

Wrapping\SeparatedSyntaxList\VisualBasicParameterWrapper.vb (1)

54Dim firstToken = If(attributes?.Count > 0,

Microsoft.CodeAnalysis.VisualBasic.Semantic.UnitTests (1)

SourceGeneration\GeneratorDriverTests.vb (1)

816Assert.Equal(4, diagnostic.Arguments.Count)

Microsoft.CodeAnalysis.VisualBasic.Workspaces.UnitTests (73)

CodeGeneration\SyntaxGeneratorTests.vb (73)

Microsoft.CodeAnalysis.Workspaces (70)

CodeFixesAndRefactorings\FixAllLogger.cs (2)

83m[DocumentCount] = fixAllState.Project.DocumentIds.Count; 87m[DocumentCount] = fixAllState.Solution.Projects.Sum(p => p.DocumentIds.Count);

Diagnostics\DiagnosticData.cs (2)

256if (diagnostic.AdditionalLocations.Count == 0) 261using var _ = ArrayBuilder<DiagnosticDataLocation>.GetInstance(diagnostic.AdditionalLocations.Count, out var builder);

Differencing\MapBasedLongestCommonSubsequence.cs (2)

17foreach (var edit in GetEdits(oldNodes, oldNodes.Count, newNodes, newNodes.Count))

Differencing\Match.LongestCommonSubsequence.cs (4)

31foreach (var pair in GetMatchingPairs(oldNodes, oldNodes.Count, newNodes, newNodes.Count)) 41foreach (var edit in GetEdits(oldNodes, oldNodes.Count, newNodes, newNodes.Count))

Editing\SyntaxGenerator.cs (10)

1030attributeArguments: args.Count > 0 ? args : null); 1105=> this.InsertAttributes(declaration, this.GetAttributes(declaration).Count, attributes); 1133=> this.InsertReturnAttributes(declaration, this.GetReturnAttributes(declaration).Count, attributes); 1155=> this.InsertAttributeArguments(attributeDeclaration, this.GetAttributeArguments(attributeDeclaration).Count, attributeArguments); 1177=> this.InsertNamespaceImports(declaration, this.GetNamespaceImports(declaration).Count, imports); 1205=> this.InsertMembers(declaration, this.GetMembers(declaration).Count, members); 1274=> this.InsertParameters(declaration, this.GetParameters(declaration).Count, parameters); 1290=> this.InsertSwitchSections(switchStatement, this.GetSwitchSections(switchStatement).Count, switchSections); 1332=> this.InsertAccessors(declaration, this.GetAccessors(declaration).Count, accessors); 1517for (int i = 0, count = list.Count; i < count; i++)

FindSymbols\FindReferences\DependentTypeFinder.cs (1)

464var order = new Dictionary<ProjectId, int>(capacity: solution.ProjectIds.Count);

FindSymbols\FindReferences\Finders\AbstractReferenceFinder.cs (1)

93if (scope != null && scope.Count == 1)

Serialization\AbstractOptionsSerializationService.cs (1)

198writer.WriteInt32(options.Features.Count);

Serialization\SerializerService_Reference.cs (3)

94if (portable is ISupportTemporaryStorage { StorageHandles: { Count: > 0 } handles } && 356Contract.ThrowIfTrue(handles.Count == 0); 361writer.WriteInt32(handles.Count);

Shared\Extensions\SourceTextExtensions.cs (2)

64if (ranges.Count == 0) 70if (ranges.Count == 1)

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

src\Compilers\Core\Portable\Text\TextChangeRangeExtensions.cs (2)

18if (changesInNextVersion.Count == 0) 27var newChange = changesInNextVersion.Count == 1

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\INamespaceOrTypeSymbolExtensions.cs (4)

44for (var i = 0; i < Math.Min(names1.Count, names2.Count); i++) 71return names1.Count - names2.Count;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Formatting\AbstractSyntaxFormatting.cs (1)

45if (spansToFormat.Count == 0)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\CommonFormattingHelpers.cs (3)

49Contract.ThrowIfFalse(spans.Count > 0); 51if (spans.Count == 1) 61for (var i = 1; i < spans.Count; i++)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\IReadOnlyListExtensions.cs (2)

23=> list[list.Count - 1]; 27for (var index = startIndex; index < list.Count; index++)

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

112var length = list.Count;

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

92var result = new FixedSizeArrayBuilder<TResult>(tasks.Count);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\AddParameterEditor.cs (4)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.cs (2)

101if (statementIndex + 1 < state.OutermostBlockStatements.Count && 148if (statementIndex + 1 < state.OutermostBlockStatements.Count)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\ParsedDocument.cs (2)

82if (textChanges.Count > 1 || 83textChanges.Count == 1 && textChanges[0].Span != new TextSpan(0, oldDocument.Text.Length))

Workspace\ProjectSystem\ProjectSystemProject.cs (1)

1385if (w.CurrentSolution.ProjectIds.Count == 1)

Workspace\ProjectSystem\ProjectSystemProjectFactory.cs (2)

148if (oldSolution.ProjectIds.Count == 0) 171return oldSolution.ProjectIds.Count == 0

Workspace\Solution\ChecksumCollection.cs (1)

97Contract.ThrowIfFalse(values.Count == checksums.Children.Length);

Workspace\Solution\ProjectDependencyGraph.cs (1)

144else if (projectReferences.Count == 0)

Workspace\Solution\ProjectDependencyGraph_AddProjectReference.cs (1)

19if (projectReferences.Count == 0)

Workspace\Solution\SolutionState.cs (5)

154Contract.ThrowIfFalse(ProjectStates.Count == ProjectIds.Count); 375using var _1 = ArrayBuilder<ProjectId>.GetInstance(ProjectIds.Count + projectStates.Count, out var newProjectIdsBuilder); 729if (projectReferences.Count == 0) 838if (metadataReferences.Count == 0) 1205if (analyzerReferences.Count == 0)

Workspace\Solution\StateChecksums.cs (1)

590var checksums = new FixedSizeArrayBuilder<Checksum>(references.Count);

Workspace\Workspace.cs (1)

746using var _ = ArrayBuilder<ProjectInfo>.GetInstance(projects.Count, out var builder);

Microsoft.CodeAnalysis.Workspaces.MSBuild (2)

MSBuild\MSBuildProjectLoader.Worker.cs (1)

438var results = new FixedSizeArrayBuilder<DocumentInfo>(documentFileInfos.Count);

MSBuild\MSBuildWorkspace.cs (1)

464var relativePath = (info.Folders != null && info.Folders.Count > 0)

Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost (8)

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

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

14for (int i = 0; i < list.Count; i++)

Microsoft.CodeAnalysis.Workspaces.MSBuild.UnitTests (14)

NetCoreTests.cs (8)

VisualStudioMSBuildWorkspaceTests.cs (6)

2327Assert.Equal(1, proj.AnalyzerReferences.Count); 2726Assert.Equal(2, solution.ProjectIds.Count); 2752Assert.Equal(3, solution.ProjectIds.Count); 3026Assert.Equal(2, proj.DocumentIds.Count); 3044Assert.Equal(2, project.DocumentIds.Count); 3290Assert.Equal(0, workspace.CurrentSolution.ProjectIds.Count);

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

Workspaces\TestWorkspace_XmlCreation.cs (1)

122if (parseOptions.Features == null || parseOptions.Features.Count == 0)

Microsoft.CodeAnalysis.Workspaces.UnitTests (32)

CommandLineProject\CommandLineProjectTests.cs (7)

28Assert.Equal(0, docInfo.Folders.Count); 59Assert.Equal(0, docInfo.Folders.Count); 70Assert.Equal(1, docInfo.Folders.Count); 82Assert.Equal(0, docInfo.Folders.Count); 93Assert.Equal(1, docInfo.Folders.Count); 105Assert.Equal(0, docInfo.Folders.Count); 116Assert.Equal(0, docInfo.Folders.Count);

CommandLineProject\CommandLineProjectWorkspaceTests.cs (3)

39Assert.Equal(0, gooDoc.Folders.Count); 67Assert.Equal(0, gooDoc.Folders.Count); 71Assert.Equal(1, barDoc.Folders.Count);

SolutionTests\SolutionTests.cs (14)

2992Assert.Equal(1, actualAnalyzerReferences.Count); 3018Assert.Equal(2, actualAnalyzerReferences.Count); 3024Assert.Equal(1, actualAnalyzerReferences.Count); 3030Assert.Equal(2, actualAnalyzerReferences.Count); 4969Assert.Equal(2, solution.ProjectIds.Count); 4993Assert.Equal(2, solution.ProjectIds.Count); 5021Assert.Equal(2, solution.ProjectIds.Count); 5052Assert.Equal(3, solution.ProjectIds.Count); 5083Assert.Equal(3, solution.ProjectIds.Count); 5115Assert.Equal(3, solution.ProjectIds.Count); 5167Assert.Equal(3, solution.ProjectIds.Count); 5183Assert.Equal(1, solution.ProjectIds.Count); 5212Assert.Equal(3, solution.ProjectIds.Count); 5227Assert.Equal(1, solution.ProjectIds.Count);

WorkspaceTests\AdhocWorkspaceTests.cs (7)

97Assert.Equal(sinfo.Projects.Count, solution.ProjectIds.Count); 129Assert.Equal(2, solution.ProjectIds.Count); 448Assert.Equal(0, originalDoc.Folders.Count); 468Assert.Equal(2, appliedDoc.Folders.Count); 547Assert.Equal(0, originalDoc.Folders.Count); 564Assert.Equal(2, appliedDoc.Folders.Count);

WorkspaceTests\WorkspaceTests.cs (1)

56Assert.Equal(0, originalDoc.Folders.Count);

Microsoft.Data.Analysis (17)

DataFrame.BinaryOperations.cs (14)

DataFrame.Join.Extrensions.cs (3)

19while (i < sortedList1.Count && j < sortedList2.Count) 23while (j < sortedList2.Count)

Microsoft.Data.Analysis.Tests (6)

ArrayComparer.cs (5)

67Assert.Equal(expectedArray.Fields.Count, array.Fields.Count); 69for (int i = 0; i < array.Fields.Count; i++) 161if (s2 == null || s1 == null || s1.HasMetadata != s2.HasMetadata || s1.FieldsList.Count != s2.FieldsList.Count)

DataFrameTests.cs (1)

952Assert.Equal(columns.Count, df.Columns.Count);

Microsoft.DotNet.Arcade.Sdk (1)

src\GenerateResxSource.cs (1)

523public bool HasArguments => _arguments.Count > 0;

Microsoft.DotNet.NuGetRepack.Tasks (2)

src\NuGetVersionUpdater.cs (2)

377if (exceptions.Count == 1) 382if (exceptions.Count > 1)

Microsoft.Extensions.AI (6)

ChatCompletion\FunctionInvokingChatClient.cs (1)

495int functionCount = functionCallContents.Count;

src\Shared\EmptyCollections\EmptyCollectionExtensions.cs (4)

src\Shared\Throw\Throw.cs (1)

274if (readOnlyCollection.Count == 0)

Microsoft.Extensions.AI.Abstractions (5)

src\Shared\EmptyCollections\EmptyCollectionExtensions.cs (4)

src\Shared\Throw\Throw.cs (1)

274if (readOnlyCollection.Count == 0)

Microsoft.Extensions.AI.AzureAIInference (7)

AzureAIInferenceChatClient.cs (2)

107if (response.ToolCalls is { Count: > 0 } toolCalls) 382if (parameters is { Count: > 0 })

src\Shared\EmptyCollections\EmptyCollectionExtensions.cs (4)

src\Shared\Throw\Throw.cs (1)

274if (readOnlyCollection.Count == 0)

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

src\Shared\Throw\Throw.cs (1)

274if (readOnlyCollection.Count == 0)

Microsoft.Extensions.AI.Ollama (5)

src\Shared\EmptyCollections\EmptyCollectionExtensions.cs (4)

src\Shared\Throw\Throw.cs (1)

274if (readOnlyCollection.Count == 0)

Microsoft.Extensions.AI.OpenAI (11)

OpenAIModelMapper.ChatCompletion.cs (3)

123if (openAICompletion.ContentTokenLogProbabilities is { Count: > 0 } contentTokenLogProbs) 133if (openAICompletion.RefusalTokenLogProbabilities is { Count: > 0 } refusalTokenLogProbs) 404if (parameters is { Count: > 0 })

OpenAIModelMappers.StreamingChatCompletion.cs (3)

100if (chatCompletionUpdate.ContentTokenLogProbabilities is { Count: > 0 } contentTokenLogProbs) 105if (chatCompletionUpdate.RefusalTokenLogProbabilities is { Count: > 0 } refusalTokenLogProbs) 134if (chatCompletionUpdate.ToolCallUpdates is { Count: > 0 } toolCallUpdates)

src\Shared\EmptyCollections\EmptyCollectionExtensions.cs (4)

src\Shared\Throw\Throw.cs (1)

274if (readOnlyCollection.Count == 0)

Microsoft.Extensions.AmbientMetadata.Application (1)

src\Shared\Throw\Throw.cs (1)

274if (readOnlyCollection.Count == 0)

Microsoft.Extensions.AsyncState (1)

src\Shared\Throw\Throw.cs (1)

274if (readOnlyCollection.Count == 0)

Microsoft.Extensions.Caching.Hybrid (1)

src\Shared\Throw\Throw.cs (1)

274if (readOnlyCollection.Count == 0)

Microsoft.Extensions.Compliance.Abstractions (1)

src\Shared\Throw\Throw.cs (1)

274if (readOnlyCollection.Count == 0)

Microsoft.Extensions.Compliance.Redaction (1)

src\Shared\Throw\Throw.cs (1)

274if (readOnlyCollection.Count == 0)

Microsoft.Extensions.Compliance.Testing (1)

src\Shared\Throw\Throw.cs (1)

274if (readOnlyCollection.Count == 0)

Microsoft.Extensions.Compliance.Testing.Tests (2)

FakeRedactorTests.cs (1)

90Assert.Equal(fakeRedactorProvider.Collector.AllRedactorRequests.Count, iterations.Length);

RedactionFakesAcceptanceTests.cs (1)

212Assert.Equal(2, collector.AllRedactedData.Count);

Microsoft.Extensions.DependencyInjection.AutoActivation (1)

src\Shared\Throw\Throw.cs (1)

274if (readOnlyCollection.Count == 0)

Microsoft.Extensions.DependencyModel (4)

DependencyContextWriter.cs (4)

135int count = libraries.Count; 198if (dependencies.Count == 0) 213int count = resourceAssemblies.Count; 322if (group.RuntimeFiles.Count != 0)

Microsoft.Extensions.Diagnostics.ExceptionSummarization (2)

ExceptionSummarizer.cs (1)

90if (descriptionIndex >= exceptionSummaryProvider.Descriptions.Count || descriptionIndex < 0)

src\Shared\Throw\Throw.cs (1)

274if (readOnlyCollection.Count == 0)

Microsoft.Extensions.Diagnostics.HealthChecks (1)

DefaultHealthCheckService.cs (1)

259if (entry.Data.Count > 0 && logger.IsEnabled(LogLevel.Debug))

Microsoft.Extensions.Diagnostics.HealthChecks.Common (1)

src\Shared\Throw\Throw.cs (1)

274if (readOnlyCollection.Count == 0)

Microsoft.Extensions.Diagnostics.Probes (1)

src\Shared\Throw\Throw.cs (1)

274if (readOnlyCollection.Count == 0)

Microsoft.Extensions.Diagnostics.ResourceMonitoring (1)

src\Shared\Throw\Throw.cs (1)

274if (readOnlyCollection.Count == 0)

Microsoft.Extensions.Diagnostics.ResourceMonitoring.Tests (1)

Windows\WindowsSnapshotProviderTests.cs (1)

68Assert.Equal(2, logRecords.Count);

Microsoft.Extensions.Diagnostics.Testing (3)

Metrics\CollectedMeasurement.cs (2)

100public bool MatchesTags(params KeyValuePair<string, object?>[] tags) => ContainsTags(tags) && (Tags.Count == tags.Length); 107public bool MatchesTags(params string[] tags) => ContainsTags(Throw.IfNull(tags)) && (Tags.Count == tags.Length);

src\Shared\Throw\Throw.cs (1)

274if (readOnlyCollection.Count == 0)

Microsoft.Extensions.Diagnostics.Testing.Tests (14)

Logging\FakeLoggerProviderTests.cs (1)

48Assert.Equal(2, records.Count);

Logging\FakeLoggerTests.cs (2)

33Assert.Equal(2, records.Count); 282Assert.Equal(2, logger.LatestRecord.Scopes.Count);

Metrics\MeasurementExtensionsTests.cs (4)

31Assert.Equal(2, filtered[1].Tags.Count); 56Assert.Equal(2, filtered[1].Tags.Count); 81Assert.Equal(2, filtered[1].Tags.Count); 109Assert.Equal(2, filtered[1].Tags.Count);

Metrics\MetricCollectorTests.cs (7)

73Assert.Equal(2, collector.GetMeasurementSnapshot().Count); 118Assert.Equal(2, collector.GetMeasurementSnapshot().Count); 165Assert.Equal(2, collector.GetMeasurementSnapshot().Count); 226Assert.Equal(2, collector.GetMeasurementSnapshot().Count); 399Assert.Equal(3, snap.Count); 400Assert.Equal(3, collector.GetMeasurementSnapshot().Count); 415Assert.Equal(3, snap.Count);

Microsoft.Extensions.FileProviders.Embedded (2)

Manifest\ManifestDirectory.cs (2)

89var list = new List<ManifestEntry>(Children.Count); 90for (var i = 0; i < Children.Count; i++)

Microsoft.Extensions.Hosting.Testing (1)

src\Shared\Throw\Throw.cs (1)

274if (readOnlyCollection.Count == 0)

Microsoft.Extensions.Http (1)

HttpMessageHandlerBuilder.cs (1)

92for (int i = additionalHandlersList.Count - 1; i >= 0; i--)

Microsoft.Extensions.Http.Diagnostics (9)

Logging\Internal\HttpHeadersRedactor.cs (5)

99if (input.Count == 0) 106if (input.Count == 1) 118for (int i = 1; i < input.Count; i++) 134for (int i = 0; i < input.Count; i++) 142if (i < input.Count - 1)

src\Shared\EmptyCollections\EmptyCollectionExtensions.cs (4)

Microsoft.Extensions.Http.Diagnostics.Tests (4)

Logging\HttpClientLoggerTest.cs (4)

337Assert.Equal(2, logRecords.Count); 740Assert.Equal(2, logRecords.Count); 778Assert.Equal(2, logRecords.Count); 823Assert.Equal(2, logRecords.Count);

Microsoft.Extensions.Http.Resilience (1)

src\Shared\Throw\Throw.cs (1)

274if (readOnlyCollection.Count == 0)

Microsoft.Extensions.Logging.Console (1)

JsonConsoleFormatter.cs (1)

35bufferedRecord.Attributes.Count > 0, null, bufferedRecord.Attributes, bufferedRecord.Timestamp);

Microsoft.Extensions.Logging.EventSource (2)

EventSourceLogger.cs (2)

244var arguments = new KeyValuePair<string, string?>[keyValuePairs.Count]; 245for (int i = 0; i < keyValuePairs.Count; i++)

Microsoft.Extensions.Logging.Generators (1)

LoggerMessageGenerator.Roslyn3.11.cs (1)

34if (logClasses.Count > 0)

Microsoft.Extensions.ObjectPool.DependencyInjection (1)

src\Shared\Throw\Throw.cs (1)

274if (readOnlyCollection.Count == 0)

Microsoft.Extensions.Options.Contextual (1)

src\Shared\Throw\Throw.cs (1)

274if (readOnlyCollection.Count == 0)

Microsoft.Extensions.Options.SourceGeneration (1)

Generator.cs (1)

51if (validatorTypes.Count > 0)

Microsoft.Extensions.Primitives (3)

CompositeChangeToken.cs (3)

39for (int i = 0; i < ChangeTokens.Count; i++) 71for (int i = 0; i < ChangeTokens.Count; i++) 105for (int i = 0; i < ChangeTokens.Count; i++)

Microsoft.Extensions.Resilience (1)

src\Shared\Throw\Throw.cs (1)

274if (readOnlyCollection.Count == 0)

Microsoft.Extensions.ServiceDiscovery (5)

Configuration\ConfigurationServiceEndpointProvider.cs (1)

43_includeAllSchemes = serviceDiscoveryOptions.Value.AllowAllSchemes && query.IncludedSchemes.Count == 0;

LoadBalancing\RoundRobinServiceEndpointSelector.cs (2)

23if (_endpoints is not { Count: > 0 } collection) 28return collection[(int)(Interlocked.Increment(ref _next) % collection.Count)];

ServiceDiscoveryOptions.cs (1)

35if (schemes.Count > 0)

ServiceEndpointWatcher.Log.cs (1)

25ResolutionSucceededCore(logger, endpointSource.Endpoints.Count, serviceName, string.Join(", ", endpointSource.Endpoints.Select(GetEndpointString)));

Microsoft.Extensions.ServiceDiscovery.Dns.Tests (3)

DnsServiceEndpointResolverTests.cs (3)

25Assert.True(initialResult.Endpoints.Count > 0); 29Assert.True(initialResult.Endpoints.Count > 0); 33Assert.True(initialResult.Endpoints.Count > 0);

Microsoft.Extensions.ServiceDiscovery.Yarp (1)

ServiceDiscoveryDestinationResolver.cs (1)

27var tasks = new List<Task<(List<(string Name, DestinationConfig Config)>, IChangeToken ChangeToken)>>(destinations.Count);

Microsoft.Extensions.Telemetry (2)

Logging\ExtendedLogger.LegacyTagJoiner.cs (1)

46_incomingTagCount = _incomingTags.Count;

src\Shared\Throw\Throw.cs (1)

274if (readOnlyCollection.Count == 0)

Microsoft.Extensions.Telemetry.Abstractions (1)

src\Shared\Throw\Throw.cs (1)

274if (readOnlyCollection.Count == 0)

Microsoft.Extensions.Telemetry.Abstractions.Tests (6)

Latency\LatencyRegistryExtensionsTests.cs (3)

80Assert.True(lcro.CheckpointNames.Count == 1); 81Assert.True(lcro.MeasureNames.Count == 2); 82Assert.True(lcro.TagNames.Count == 3);

Logging\LoggerMessageStateTests.cs (3)

141Assert.Equal(1, list.Count); 151Assert.Equal(1, list.Count); 157Assert.Equal(1, list.Count);

Microsoft.Extensions.Telemetry.PerformanceTests (1)

BenchLogger.cs (1)

41int count = l.Count;

Microsoft.Extensions.TimeProvider.Testing (1)

src\Shared\Throw\Throw.cs (1)

274if (readOnlyCollection.Count == 0)

Microsoft.Gen.ComplianceReports (1)

ComplianceReportsGenerator.cs (1)

73if (classifiedTypes.Count == 0)

Microsoft.Gen.ComplianceReports.Unit.Tests (4)

src\Shared\EmptyCollections\EmptyCollectionExtensions.cs (4)

Microsoft.Gen.ContextualOptions.Unit.Tests (4)

src\Shared\EmptyCollections\EmptyCollectionExtensions.cs (4)

Microsoft.Gen.Logging (1)

LoggingGenerator.cs (1)

44if (logTypes.Count > 0)

Microsoft.Gen.Logging.Generated.Tests (9)

LoggerMessageAttributeTests.cs (1)

160Assert.Equal(expectedState.Length, collector.LatestRecord.StructuredState!.Count);

LogMethodTests.cs (3)

91Assert.Equal(3, collector.LatestRecord.StructuredState!.Count); 99Assert.Equal(3, collector.LatestRecord.StructuredState!.Count); 942Assert.Equal(expected, rol.Count);

LogPropertiesTests.cs (3)

63Assert.Equal(2, state.Count); 80Assert.Equal(2, state.Count); 120Assert.Equal(21, state.Count);

TagProviderTests.cs (2)

167Assert.Equal(2, state.Count); 193Assert.Equal(2, state.Count);

Microsoft.Gen.Logging.Unit.Tests (6)

ParserTests.cs (2)

748else if (d.Count > 0) 750Assert.Fail($"Expected no diagnostics, got {d.Count} diagnostics");

src\Shared\EmptyCollections\EmptyCollectionExtensions.cs (4)

Microsoft.Gen.MetadataExtractor (8)

MetadataReportsGenerator.cs (2)

124if (meteringClasses.Count == 0) 151if (classifiedTypes.Count == 0)

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

73if (classifiedTypes.Count == 0)

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

36if (metricClasses.Count > 0)

src\Generators\Microsoft.Gen.MetricsReports\MetricDefinitionEmitter.cs (3)

23if (metricClasses == null || metricClasses.Count == 0) 30for (int i = 0; i < metricClasses.Count; i++) 36if (i < metricClasses.Count - 1)

src\Generators\Microsoft.Gen.MetricsReports\MetricsReportsGenerator.cs (1)

70if (meteringClasses.Count == 0)

Microsoft.Gen.MetadataExtractor.Unit.Tests (4)

src\Shared\EmptyCollections\EmptyCollectionExtensions.cs (4)

Microsoft.Gen.Metrics (1)

MetricsGenerator.cs (1)

36if (metricClasses.Count > 0)

Microsoft.Gen.Metrics.Generated.Tests (2)

MetricTests.cs (2)

171Assert.Equal(2, measurements.Count); 195Assert.Equal(2, measurements.Count);

Microsoft.Gen.Metrics.Unit.Tests (4)

src\Shared\EmptyCollections\EmptyCollectionExtensions.cs (4)

Microsoft.Gen.MetricsReports (4)

MetricDefinitionEmitter.cs (3)

23if (metricClasses == null || metricClasses.Count == 0) 30for (int i = 0; i < metricClasses.Count; i++) 36if (i < metricClasses.Count - 1)

MetricsReportsGenerator.cs (1)

70if (meteringClasses.Count == 0)

Microsoft.Gen.MetricsReports.Unit.Tests (4)

src\Shared\EmptyCollections\EmptyCollectionExtensions.cs (4)

Microsoft.Interop.LibraryImportGenerator (1)

Analyzers\AddDisableRuntimeMarshallingAttributeFixer.cs (1)

75&& document.Folders.Count == 1

Microsoft.Maui (3)

Layouts\GridLayoutManager.cs (2)

157 int count = rowDefinitions.Count; 178 int count = columnDefinitions.Count;

VisualDiagnostics\VisualDiagnosticsOverlay.cs (1)

109 if (WindowElements.Count == 0)

Microsoft.Maui.Controls (98)

Application\Application.cs (4)

95 if (Windows.Count == 0) 121 if (Windows.Count == 1) 537 if (Windows.Count > 1) 542 if (Windows.Count > 0)

ContentPresenter.cs (1)

43 for (var i = 0; i < LogicalChildrenInternal.Count; i++)

Element\Element.cs (3)

706 for (var i = 0; i < children.Count; i++) 812 for (var i = 0; i < children.Count; i++) 1086 int ICollection<Element>.Count => _inner.Count;

LegacyLayouts\Layout.cs (3)

436 var oldBounds = new Rect[LogicalChildrenInternal.Count]; 465 for (var i = 0; i < LogicalChildrenInternal.Count; i++) 548 int count = children.Count;

LegacyLayouts\StackLayout.cs (5)

70 for (var i = 0; i < LogicalChildrenInternal.Count; i++) 157 for (var i = 0; i < LogicalChildrenInternal.Count; i++) 193 for (var i = 0; i < LogicalChildrenInternal.Count; i++) 424 for (var i = 0; i < LogicalChildrenInternal.Count; i++) 452 for (var i = 0; i < LogicalChildrenInternal.Count; i++)

NavigationPage\NavigationPage.cs (9)

467 CurrentPage = (Page)newStack[newStack.Count - 1]; 480 for (int i = 0; i < newStack.Count; i++) 500 while (InternalChildren.Count > newStack.Count) 694 var visiblePage = Navigation.NavigationStack[NavigationStack.Count - 1]; 783 var currentPage = NavigationStack[NavigationStack.Count - 1]; 784 var newCurrentPage = NavigationStack[NavigationStack.Count - 2]; 813 if (NavigationStack.Count == 1) 823 var lastIndex = NavigationStack.Count - 1; 828 lastIndex = NavigationStack.Count - 1;

NavigationPage\NavigationPageToolbar.cs (5)

147 if (navPage.Navigation.NavigationStack.Count == 0) 150 if (navPage.Navigation.NavigationStack.Count > 1) 212 if (stack.Count == 0) 218 if (stack.Count > 1) 219 previousPage = stack[stack.Count - 1];

Platform\ModalNavigationManager\ModalNavigationManager.cs (1)

290 if (ModalStack.Count == 0)

ReadOnlyCastingList.cs (1)

60 get { return _readonlyList.Count; }

ReadOnlyListAdapter.cs (1)

33 get { return _collection.Count; }

Region.cs (3)

75 for (int i = 0; i < Regions.Count; i++) 103 Rect[] rectangles = new Rect[Regions.Count]; 104 for (int i = 0; i < Regions.Count; i++)

Routing.cs (2)

46 var navigationStackCount = section.Navigation.NavigationStack.Count; 51 var navigationModalStackCount = section.Navigation.ModalStack.Count;

Shell\BaseShellItem.cs (4)

174 if (Navigation.ModalStack.Count > 0) 176 Navigation.ModalStack[Navigation.ModalStack.Count - 1] 181 else if (Navigation.NavigationStack.Count > 1) 183 Navigation.NavigationStack[Navigation.NavigationStack.Count - 1]

Shell\RouteRequestBuilder.cs (1)

204 var nextMatch = matchedSegments.Count;

Shell\Shell.cs (6)

956 if (Application.Current is null || Application.Current.Windows.Count == 0) 959 if (Application.Current.Windows.Count == 1) 1536 if (currentContent != null && currentContent.Stack.Count > 1) 1942 currentPage = navStack[navStack.Count - 1] ?? 2107 if (ModalStack.Count == 0 && !_shell.CurrentItem.CurrentItem.IsPoppingModalStack) 2129 if (ModalStack.Count == 0)

Shell\ShellElementCollection.cs (1)

215 return (sgi.ShellElementCollection.VisibleItemsReadOnly.Count > 0) ||

Shell\ShellNavigationManager.cs (14)

157 if (!modalStackPreBuilt && currentShellSection?.Navigation.ModalStack.Count > 0) 167 for (int i = currentShellSection.Stack.Count - 1; i >= 1; i--) 185 nextActiveSection?.Navigation?.NavigationStack?.Count > 1) 491 (modalStack?.Count > 0 ? modalStack[modalStack.Count - 1] : null) ?? 492 (navStack?.Count > 0 ? navStack[navStack.Count - 1] : null); 521 bool stackAtRoot = sectionStack == null || sectionStack.Count <= 1; 545 for (int i = 1; i < sectionStack.Count; i++) 552 if (modalStack != null && modalStack.Count > 0) 554 for (int i = 0; i < modalStack.Count; i++) 560 for (int j = 1; j < topPage.Navigation.NavigationStack.Count; j++) 587 for (int i = 0; i < modalStack.Count; i++) 590 for (int j = 1; j < modalStack[i].Navigation.NavigationStack.Count; j++)

Shell\ShellSection.cs (18)

Shell\ShellUriHandler.cs (1)

451 if (routeRequestBuilder.FullSegments.Count <= i || currentSeg != routeRequestBuilder.FullSegments[i])

ShellToolbar.cs (6)

73 if (stack.Count == 0) 82 if (stack.Count > 1) 83 previousPage = stack[stack.Count - 1]; 93 _drawerToggleVisible = stack.Count <= 1; 94 BackButtonVisible = backButtonVisible && stack.Count > 1; 181 else if (_shell.Navigation?.NavigationStack?.Count <= 1)

TemplatedView\TemplatedView.cs (1)

33 for (var i = 0; i < LogicalChildrenInternal.Count; i++)

TemplateUtilities.cs (1)

93 for (var i = 0; i < children.Count; i++)

ViewExtensions.cs (2)

511 if (modalStack.Count > 0) 513 var currentPage = modalStack[modalStack.Count - 1];

VisualElement\VisualElement.cs (1)

1346 for (var i = 0; i < LogicalChildrenInternal.Count; i++)

Window\Window.cs (4)

427 if (Navigation.ModalStack.Count == 0) 433 if (Navigation.ModalStack.Count == 0) 678 if (Navigation.ModalStack.Count > 0) 680 return Navigation.ModalStack[Navigation.ModalStack.Count - 1].SendBackButtonPressed();

Microsoft.Maui.Controls.Build.Tasks (1)

CompiledMarkupExtensions\ArrayExtension.cs (1)

22 var n = items.Count;

Microsoft.Maui.Graphics (5)

Text\AttributedTextExtensions.cs (4)

91 if (text.Runs == null || text.Runs.Count == 0) 95 if (!(startIndexForSearch < text.Runs.Count)) 149 } while (index < text.Runs.Count); 164 if (text.Runs?.Count > 0)

Text\XmlAttributedTextWriter.cs (1)

43 if (attributedText.Runs != null && attributedText.Runs.Count > 0)

Microsoft.ML.AutoML (8)

ColumnInference\PurposeInference.cs (4)

146if (imagePathCount < data.Count - 1) 148Double avgLength = 1.0 * sumLength / data.Count; 149Double cardinalityRatio = 1.0 * seen.Count / data.Count; 150Double avgSpaces = 1.0 * sumSpaces / data.Count;

Experiment\MetricsAgents\RankingMetricsAgent.cs (2)

42return metrics.NormalizedDiscountedCumulativeGains[Math.Min(metrics.NormalizedDiscountedCumulativeGains.Count, (int)_dcgTruncationLevel) - 1]; 44return metrics.DiscountedCumulativeGains[Math.Min(metrics.DiscountedCumulativeGains.Count, (int)_dcgTruncationLevel) - 1];

Sweepers\SmacSweeper.cs (1)

331for (var treeId = 0; treeId < forest.TrainedTreeEnsemble.Trees.Count; treeId++)

Tuner\SmacTuner.cs (1)

323for (var treeId = 0; treeId < forest.TrainedTreeEnsemble.Trees.Count; treeId++)

Microsoft.ML.AutoML.Tests (2)

AutoFitTests.cs (2)

455Assert.Equal(10, bestRun.ValidationMetrics.DiscountedCumulativeGains.Count); 456Assert.Equal(10, bestRun.ValidationMetrics.NormalizedDiscountedCumulativeGains.Count);

Microsoft.ML.Core (14)

Data\AnnotationUtils.cs (1)

304if (list?.Count != 1 || !schema.Schema[list[0].Index].HasSlotNames(vectorSize))

Data\ProgressReporter.cs (7)

133Contracts.Assert(entry.Header.MetricNames.Count == 0 && entry.Header.UnitNames.Count == 0); 233Contracts.Assert(entry.Header.MetricNames.Count == 0 && entry.Header.UnitNames.Count == 0); 559Progress = new Double?[header.UnitNames.Count]; 560ProgressLim = new Double?[header.UnitNames.Count]; 561Metrics = new Double?[header.MetricNames.Count];

Data\RoleMappedSchema.cs (3)

172if (cols.Count == 1) 244=> _map.TryGetValue(role.Value, out var cols) && cols.Count == 1; 250=> _map.TryGetValue(role.Value, out var cols) && cols.Count > 1;

Environment\ConsoleEnvironment.cs (2)

273for (int i = 0; i < ev.ProgressEntry.Header.UnitNames.Count; i++) 286for (int i = 0; i < ev.ProgressEntry.Header.MetricNames.Count; i++)

Utilities\Utils.cs (1)

87return x == null ? 0 : x.Count;

Microsoft.ML.Data (13)

DataView\RowToRowMapperTransform.cs (2)

176Contracts.Assert(0 <= col && col < _bindings.AddedColumnIndices.Count); 177return 0 <= col && col < _bindings.AddedColumnIndices.Count && active[_bindings.AddedColumnIndices[col]];

Evaluators\BinaryClassifierEvaluator.cs (3)

145host.CheckParam(prob.Count == 1, nameof(schema), "Cannot have multiple probability columns"); 162Host.Assert(prob == null || prob.Count == 1); 633Host.Assert(prob == null || prob.Count == 1);

Evaluators\EvaluatorUtils.cs (2)

1594int numLabels = confusionMatrix?.Counts == null ? 0 : confusionMatrix.Counts.Count; 1610rowDigitLen = Math.Max(confusionMatrix.PredictedClassesIndicators.Count - 1, 0).ToString().Length;

Evaluators\Metrics\ConfusionMatrix.cs (2)

116_host.CheckParam(predictedClassIndicatorIndex > -1 && predictedClassIndicatorIndex < Counts.Count, 118_host.CheckParam(actualClassIndicatorIndex > -1 && actualClassIndicatorIndex < Counts.Count,

Transforms\ColumnBindingsBase.cs (2)

754Contracts.Assert(index < AddedColumnIndices.Count); 778Contracts.Assert(-AddedColumnIndices.Count <= src && src < InputSchema.Count);

Transforms\ColumnConcatenatingTransformer.cs (2)

446int[] sources = new int[_parent._columns[iinfo].Sources.Count]; 463for (int i = 0; i < _parent._columns[iinfo].Sources.Count; i++)

Microsoft.ML.FastTree (2)

Utils\RegressionTreeBaseUtils.cs (2)

41for (int i = 0; i < trees.Count; i++) 122for (int i = 0; i < quantileTrees.Count; i++)

Microsoft.ML.GenAI.Core (1)

Trainer\CausalLMDataset.cs (1)

86var enumerable = Enumerable.Range(0, labelIds.Count)

Microsoft.ML.IntegrationTests (16)

Explainability.cs (1)

105Assert.Equal(HousingRegression.Features.Length, weights.Count);

IntrospectiveTraining.cs (14)

52Assert.Equal(3, treeCollection.Trees.Count); 53Assert.Equal(3, treeCollection.TreeWeights.Count); 59Assert.Equal(tree.SplitGains.Count, tree.NumberOfNodes); 60Assert.Equal(tree.NumericalSplitThresholds.Count, tree.NumberOfNodes); 96Assert.Equal(3, treeCollection.Trees.Count); 97Assert.Equal(3, treeCollection.TreeWeights.Count); 103Assert.Equal(tree.SplitGains.Count, tree.NumberOfNodes); 104Assert.Equal(tree.NumericalSplitThresholds.Count, tree.NumberOfNodes); 160Assert.Equal(shapeFunctionBins.Count, shapeFunctionValues.Count); 161Common.AssertFiniteNumbers(shapeFunctionBins as IList<double>, shapeFunctionBins.Count - 1); 198Assert.Equal(numTopics, ldaDetails.ItemScoresPerTopic.Count); 200Assert.Equal(numTopics, ldaDetails.WordScoresPerTopic.Count); 245Assert.Equal(numFeatures, weights.Count);

Validation.cs (1)

51Assert.Equal(5, cvResult.Count);

Microsoft.ML.Maml (2)

HelpCommand.cs (2)

314if (names.Count <= 1) 318for (int i = 1; i < names.Count; i++)

Microsoft.ML.OnnxTransformer (1)

OnnxTransform.cs (1)

698Contracts.Assert(outputCache.OutputOnnxValues.Count > 0);

Microsoft.ML.PerformanceTests (1)

Harness\Metrics.cs (1)

55if (results.Count != 1)

Microsoft.ML.Samples (4)

Dynamic\Trainers\BinaryClassification\Gam.cs (1)

77for (int j = 0; j < binUpperBounds.Count; j++)

Dynamic\Trainers\BinaryClassification\GamWithOptions.cs (1)

85for (int j = 0; j < binUpperBounds.Count; j++)

Dynamic\Trainers\Regression\GamAdvanced.cs (1)

77for (int j = 0; j < binUpperBounds.Count; j++)

Dynamic\Trainers\Regression\GamWithOptionsAdvanced.cs (1)

85for (int j = 0; j < binUpperBounds.Count; j++)

Microsoft.ML.StandardTrainers (2)

FactorizationMachine\FieldAwareFactorizationMachineModelParameters.cs (1)

374for (int i = 0; i < FeatureColumns.Count; i++)

Optimizer\LearningRateScheduler.cs (1)

112for (int i = 0; i < _lrSchedule.Count; i++)

Microsoft.ML.Tests (14)

PermutationFeatureImportanceTests.cs (6)

579for (int i = 0; i < pfi[0].PerClassLogLoss.Count; i++) 656for (int i = 0; i < pfi[0].PerClassLogLoss.Count; i++) 721for (int i = 0; i < pfi[0].DiscountedCumulativeGains.Count; i++) 726for (int i = 0; i < pfi[0].NormalizedDiscountedCumulativeGains.Count; i++) 792for (int i = 0; i < pfi[0].DiscountedCumulativeGains.Count; i++) 797for (int i = 0; i < pfi[0].NormalizedDiscountedCumulativeGains.Count; i++)

Scenarios\IrisPlantClassificationTests.cs (1)

95Assert.Equal(3, metrics.PerClassLogLoss.Count);

Scenarios\IrisPlantClassificationWithStringLabelTests.cs (1)

98Assert.Equal(3, metrics.PerClassLogLoss.Count);

ScenariosWithDirectInstantiation\IrisPlantClassificationTests.cs (1)

100Assert.Equal(3, metrics.PerClassLogLoss.Count);

TrainerEstimators\MatrixFactorizationTests.cs (5)

93Assert.Equal(leftMatrix.Count, model.Model.NumberOfRows * model.Model.ApproximationRank); 94Assert.Equal(rightMatrix.Count, model.Model.NumberOfColumns * model.Model.ApproximationRank); 102Assert.Equal(0.468956589698792, leftMatrix[leftMatrix.Count - 1], 0.0001); 104Assert.Equal(0.503888845443726, rightMatrix[rightMatrix.Count - 1], 0.0001); 828for (int i = 0; i < leftFactorMatrix.Count; ++i)

Microsoft.ML.TimeSeries (30)

Deseasonality.cs (1)

120for (int i = 0; i < _stl.Residual.Count; ++i)

STL\FastLoess.cs (2)

46if (yValues.Count < MinTimeSeriesLength) 51_length = _y.Count;

STL\InnerStl.cs (6)

122if (yValues.Count < MinTimeSeriesLength) 125int length = yValues.Count; 181for (int i = 0; i < y.Count; i++) 258for (int i = 0; i < y.Count; i++) 313List<double> results = new List<double>(s.Count); 320for (int i = length; i < s.Count; ++i)

STL\LeastSquares.cs (7)

31if (x.Count == 0 || y.Count == 0) 33if (x.Count != y.Count) 37_length = _x.Count; 48Contracts.CheckParam(weights.Count == _length, nameof(weights)); 49if (weights.Count != _length)

STL\LocalRegression.cs (4)

41if (x.Count <= 1 || x.Count != y.Count) 48_length = _x.Count;

STL\Loess.cs (5)

52if (xValues.Count < MinTimeSeriesLength || yValues.Count < MinTimeSeriesLength) 55if (xValues.Count != yValues.Count) 60_length = xValues.Count;

STL\MathsTools.cs (3)

35double[] left = new double[values.Count]; 36double[] right = new double[values.Count]; 37int numsCount = nums.Count;

STL\PolynomialModel.cs (2)

41for (int i = 1; i < Coeffs.Count; i++) 64Contracts.CheckParam(coeffs.Count == 2, nameof(coeffs), "must contain exact 2 elements.");

Microsoft.ML.Tokenizers (15)

Model\CodeGenTokenizer.cs (2)

1593if (tokensToAdd.Count > 0) 1598for (int i = 1; i < tokensToAdd.Count; i++)

Model\EnglishRobertaTokenizer.cs (7)

836List<int> list = new List<int>(ids.Count); 858List<int> list = new List<int>(ids.Count); 880List<int> list = new List<int>(ranks.Count); 915for (int i = 0; i < tokens.Count; i++) 921List<EncodedToken> list = new List<EncodedToken>(tokens.Count); 927for (int j = i; j < tokens.Count; j++) 1065if (word.Count <= 1)

Model\SentencePieceTokenizer.cs (1)

78if (specialTokens is not null && specialTokens.Count > 0)

PreTokenizer\RegexPreTokenizer.cs (1)

36if (specialTokens is { Count: > 0 })

Tokenizer.cs (4)

46var ids = new int[results.Tokens.Count]; 184=> EncodeToTokens(text, textSpan, settings).Tokens.Count; 237tokenCount = Math.Min(maxTokenCount, tokens.Tokens.Count); 253var token = tokens.Tokens[tokens.Tokens.Count - tokenCount];

Microsoft.ML.Tokenizers.Tests (109)

BertTokenizerTests.cs (23)

BpeTests.cs (6)

261Assert.Equal(expectedTokens.Length, encoding.Count); 262Assert.Equal(offsets.Length, encoding.Count); 263Assert.Equal(ids.Length, encoding.Count); 264Assert.Equal(ids.Length, idsList.Count); 274for (int i = 0; i < encoding.Count; i++) 379Assert.Equal(12, encoding.Count);

CodeGenTests.cs (38)

LlamaTests.cs (12)

360Assert.True(bpe.Vocabulary.Count > 0); 673Assert.Equal(tokenCount, encodedTokens.Count); 689for (int i = 1; i <= encodedTokens.Count; i++) 697accumulatedStringFromEnd = (encodedTokens.Count == i ? DummyPrefix : (i % 2 == 0 ? $"{DummyPrefix}Hello" : specialTokens[specialTokens.Length - 1 - (i / 2)])) + accumulatedStringFromEnd; 849Assert.True(idsConsumed < ids.Count); 854Assert.Equal(ids.Count, idsConsumed); 863Assert.True(idsConsumed < ids.Count); 868Assert.Equal(ids.Count, idsConsumed); 888Assert.True(idsConsumed < ids.Count); 893Assert.Equal(ids.Count, idsConsumed); 902Assert.True(idsConsumed < ids.Count); 912Assert.Equal(ids.Count, idsConsumed);

PreTokenizerTests.cs (2)

67Assert.True(encoding.Count >= splitParts.Length, $"Expected to have {encoding.Count} >= {splitParts.Length}");

TiktokenTests.cs (19)

TokenizerTests.cs (9)

135for (int i = 1; i <= fullIdsList.Count; i++) 144Assert.Equal(fullIdsList.Take(partialIdsList.Count), partialIdsList); 165Assert.Equal(tokenCount1, prefixIds.Count); 166Assert.Equal(prefixIds, fullIdsList.Take(prefixIds.Count)); 178if (i < fullIdsList.Count) 188Assert.Equal(tokenCount2, suffixIds.Count); 189Assert.Equal(suffixIds, fullIdsList.Skip(fullIdsList.Count - suffixIds.Count)); 192if (i == fullIdsList.Count)

Microsoft.ML.TorchSharp (10)

NasBert\NerTrainer.cs (5)

172if (target.Length != encoding.Count) 175var targetEditor = VBufferEditor.Create(ref target, encoding.Count); 177for (var i = 0; i < encoding.Count; i++) 387for (var i = 0; i < encoding.Count; i++) 401for (var i = 1; i < encoding.Count; i++)

Roberta\QATrainer.cs (5)

420var targetList = new List<int> { mapping[answerIndex] + 2 + questionTokenId.Count, mapping[answerEnd] + 2 + questionTokenId.Count }; 445for (var (i, j, tid) = (0, 0, 0); i < text.Length && tid < tokens.Count;) 866contextLength = contextTokenId.Count; 867questionLength = questionTokenId.Count;

Microsoft.ML.Transforms (17)

ExpressionTransformer.cs (2)

117for (int isrc = 0; isrc < inputColumnNames.Count; isrc++) 137for (int isrc = 0; isrc < inputColumnNames.Count; isrc++)

MetricStatistics.cs (6)

58Contracts.Assert(src.Count == dest.Count); 60for (int i = 0; i < dest.Count; i++) 271PerClassLogLoss = MetricsStatisticsUtils.InitializeArray(metrics.PerClassLogLoss.Count); 303DiscountedCumulativeGains = MetricsStatisticsUtils.InitializeArray(metrics.DiscountedCumulativeGains.Count); 306NormalizedDiscountedCumulativeGains = MetricsStatisticsUtils.InitializeArray(metrics.NormalizedDiscountedCumulativeGains.Count);

PermutationFeatureImportanceExtensions.cs (4)

643Contracts.Assert(a.Count == b.Count); 645var delta = new double[a.Count]; 646for (int i = 0; i < a.Count; i++)

Text\NgramTransform.cs (5)

327for (int i = 0; i < lims.Count; i++) 341env.Assert(lims.Count > 0); 342env.Assert(lims.Count == Utils.Size(counts)); 345int ngramLength = lims.Count; 351env.Assert(lim <= lims.Count);

Microsoft.VisualStudio.LanguageServices (11)

CodeCleanup\AbstractCodeCleanUpFixer.cs (1)

201progressTracker.AddItems(projects.Sum(static p => p.DocumentIds.Count));

Diagnostics\VisualStudioDiagnosticAnalyzerService.cs (1)

333var totalProjectCount = project != null ? (1 + otherProjectsForMultiTfmProject.Length) : solution.ProjectIds.Count;

EditorConfigSettings\SettingsEditorPane.SearchFilter.cs (2)

50var cachedColumnValues = new string[_visibleColumns.Count + 1]; 90for (var i = 0; i < _visibleColumns.Count; i++)

EditorConfigSettings\SettingsEditorPane.SearchTask.cs (1)

48resultCount += (uint)results.FilteredAndSortedEntries.Count;

FindReferences\Contexts\AbstractTableDataSourceFindUsagesContext.cs (2)

143Debug.Assert(_findReferencesWindow.Manager.Sources.Count == 0); 653Debug.Assert(_findReferencesWindow.Manager.Sources.Count == 1);

GenerateType\GenerateTypeDialogViewModel.cs (2)

378this.SelectedProject.Documents.Where(n => n.Name != null && n.Folders.Count > 0 && n.Name == this.FileName && this.Folders.SequenceEqual(n.Folders)).Any()) || 816if (document.Folders.Count == 0)

PreviewPane\PreviewPane.xaml.cs (2)

157if (previewItems == null || previewItems.Count == 0) 163if (previewItems.Count > MaxItems)

MinimalSample (1)

Program.cs (1)

37return $"{result} | /inner filter! Tags: {(tags.Count == 0 ? "(null)" : string.Join(", ", tags))}";

MSBuild (4)

CollectionHelpers.cs (2)

60if (a.Count != b.Count)

ErrorUtilities.cs (2)

511if (parameter.Count == 0) 522if (parameter?.Count == 0)

PresentationBuildTasks (1)

src\Microsoft.DotNet.Wpf\src\Shared\MS\Internal\Xaml\Parser\SpecialBracketCharacters.cs (1)

37if (attributeList is not null && attributeList.Count > 0)

PresentationCore (6)

System\Windows\BinaryFormat\ArrayRecord.cs (1)

49if (arrayInfo.Length != arrayObjects.Count)

System\Windows\BinaryFormat\ClassInfo.cs (1)

35writer.Write(MemberNames.Count);

System\Windows\BinaryFormat\ClassRecord.cs (1)

30for (int i = 0; i < ClassInfo.MemberNames.Count; i++)

System\Windows\BinaryFormat\Record.cs (2)

80for (int i = 0; i < values.Count; i++) 96for (int i = 0; i < objects.Count; i++)

System\Windows\Nrbf\SerializationRecordExtensions.cs (1)

360ArgumentOutOfRangeException.ThrowIfLessThan(readOnlyList.Count, count, nameof(count));

PresentationFramework (25)

MS\Internal\WindowsRuntime\Generated\WinRT\Projections\IReadOnlyList.cs (6)

131EnsureIndexInt32(index, _list.Count); 144public uint Size => (uint)_list.Count; 149int max = _list.Count; 174if (startIndex == _list.Count) 177EnsureIndexInt32(startIndex, _list.Count); 184uint itemCount = Math.Min((uint)items.Length, (uint)_list.Count - startIndex);

src\Microsoft.DotNet.Wpf\src\Shared\MS\Internal\Xaml\Parser\SpecialBracketCharacters.cs (1)

37if (attributeList is not null && attributeList.Count > 0)

System\Windows\Documents\NLGSpellerInterop.cs (6)

230segmentCount += sentence.Segments.Count; 235for (int i = 0; continueIteration && (i < sentence.Segments.Count); i++ ) 723for (int i = 0; result && (i < SubSegments.Count); i++) 845Invariant.Assert(_segments.Count == sentenceSegmentCount); 875if (Segments.Count > 0) 877ITextRange textRange = Segments[Segments.Count - 1].TextRange;

System\Windows\Documents\Speller.cs (3)

897if (textSegment.SubSegments.Count == 0) 900if(textSegment.Suggestions.Count > 0) 951if (textSegment.SubSegments.Count == 0)

System\Windows\Documents\WinRTSpellerInterop.cs (5)

383segmentCount += sentence.Segments.Count; 387for (int i = 0; continueIteration && (i < sentence.Segments.Count); i++) 1014for (int i = 0; result && (i < SubSegments.Count); i++) 1071if (Segments.Count > 0) 1073ITextRange textRange = Segments[Segments.Count - 1].TextRange;

System\Windows\Documents\WinRTSpellerInteropExtensions.cs (4)

61if (tokens.Count == 0) 69for (int i = 0; i < tokens.Count; i++) 111if (tokens.Count > 0 && 113spellChecker.HasErrors(tokens[tokens.Count - 1].Text) &&

Roslyn.Test.PdbUtilities (1)

EditAndContinue\EditAndContinueTest.cs (1)

152for (int generation = 0; generation < exceptions.Count; generation++)

Roslyn.VisualStudio.Next.UnitTests (5)

Services\ServiceHubServicesTests.cs (5)

1480for (var i = 0; i < projectIds.Count; i++) 1487for (var j = 0; j < documentIds.Count; j++) 1585for (var i = 0; i < projectIds.Count; i++) 1597for (var j = 0; j < documentIdsInProject.Count; j++) 1726var projectName = $"Project{solution.ProjectIds.Count}";

Sample (2)

Program.cs (2)

58forms.MapPost("/form-files", (IFormFileCollection files) => Results.Ok(files.Count)); 59forms.MapPost("/form-file-multiple", (IFormFile resume, IFormFileCollection files) => Results.Ok(files.Count + resume.FileName));

SemanticSearch.BuildTask (1)

GenerateFilteredReferenceAssembliesTask.cs (1)

182for (var i = 0; i < lines.Count; i++)

Shared (5)

EmptyCollections\EmptyCollectionExtensions.cs (4)

Throw\Throw.cs (1)

274if (readOnlyCollection.Count == 0)

Swaggatherer (4)

Template.cs (4)

19for (var i = 0; i < entries.Count; i++) 45for (var i = 0; i < entries.Count; i++) 60for (var i = 0; i < entries.Count; i++) 135entries.Count);

System.Collections.Concurrent (1)

System\Collections\Concurrent\ConcurrentDictionary.cs (1)

289IReadOnlyCollection<KeyValuePair<TKey, TValue>> rc => Math.Max(DefaultCapacity, rc.Count),

System.Collections.Immutable (20)

System\Collections\Frozen\EmptyFrozenSet.cs (1)

45other is IReadOnlyCollection<T> s ? s.Count == 0 : // TODO https://github.com/dotnet/runtime/issues/42254: Remove if/when Any includes this check

System\Collections\Frozen\FrozenSetInternalBase.cs (2)

92return _thisSet.Count <= otherAsSet.Count && IsSubsetOfSetWithCompatibleComparer(otherAsSet); 152return _thisSet.Count == otherAsSet.Count && ContainsAllElements(otherAsSet);

System\Collections\Immutable\ImmutableEnumerableDebuggerProxy.cs (1)

50??= _dictionary.Select(kv => new DebugViewDictionaryItem<TKey, TValue>(kv)).ToArray(_dictionary.Count);

System\Collections\Immutable\ImmutableExtensions.Minimal.cs (1)

49count = readOnlyCollection.Count;

System\Collections\Immutable\ImmutableList.cs (10)

149return list.IndexOf(item, 0, list.Count, EqualityComparer<T>.Default); 170return list.IndexOf(item, 0, list.Count, equalityComparer); 195return list.IndexOf(item, startIndex, list.Count - startIndex, EqualityComparer<T>.Default); 243if (list.Count == 0) 249return list.LastIndexOf(item, list.Count - 1, list.Count, EqualityComparer<T>.Default); 270if (list.Count == 0) 276return list.LastIndexOf(item, list.Count - 1, list.Count, equalityComparer); 301if (list.Count == 0 && startIndex == 0)

System\Collections\Immutable\ImmutableList_1.cs (2)

1183if (list.Count == 0) 1188Node root = Node.NodeTreeFromList(list, 0, list.Count);

System\Collections\Immutable\ImmutableList_1.Node.cs (1)

1562return NodeTreeFromList(list, 0, list.Count);

System\Collections\Immutable\ImmutableSortedDictionary_2.Node.cs (1)

236return NodeTreeFromList(list, 0, list.Count);

System\Collections\Immutable\KeysOrValuesCollectionAccessor.cs (1)

55get { return _dictionary.Count; }

System.Formats.Nrbf (3)

System\Formats\Nrbf\ArrayRectangularPrimitiveRecord.cs (2)

54for (int i = 0; i < _values.Count; i++) 77Debug.Assert(numElementsWritten == (uint)_values.Count, "We should have traversed the entirety of the source values collection.");

System\Formats\Nrbf\ClassRecord.cs (1)

38internal int ExpectedValuesCount => MemberTypeInfo.Infos.Count;

System.Linq.Expressions (41)

System\Dynamic\Utils\ExpressionUtils.cs (3)

256return current.Count == 0; 272return current.Count == 0; 289int count = current.Count;

System\Linq\Expressions\BlockExpression.cs (5)

471Debug.Assert(expressions.Count != 0); 481Debug.Assert(index >= 0 && index < _expressions.Count); 486internal override int ExpressionCount => _expressions.Count; 618internal override int ExpressionCount => _body.Count; 1090return expressions.Count switch

System\Linq\Expressions\Compiler\CompilerScope.cs (1)

102Definitions = new Dictionary<ParameterExpression, VariableStorageKind>(variables.Count);

System\Linq\Expressions\DebugViewWriter.cs (1)

262if (open == '{' || expressions.Count > 1)

System\Linq\Expressions\DynamicExpression.cs (2)

507int IArgumentProvider.ArgumentCount => _arguments.Count; 854switch (argumentList.Count)

System\Linq\Expressions\Expression.cs (1)

242for (int i = 0, n = items.Count; i < n; i++)

System\Linq\Expressions\IndexExpression.cs (3)

31Debug.Assert(instance.Type.GetArrayRank() == arguments.Count); 110public int ArgumentCount => _arguments.Count; 123Debug.Assert(arguments == null || arguments.Length == _arguments.Count);

System\Linq\Expressions\Interpreter\InstructionList.cs (1)

122for (int i = 0, n = instructions.Count; i < n; i++)

System\Linq\Expressions\InvocationExpression.cs (3)

142public override int ArgumentCount => _arguments.Count; 147Debug.Assert(arguments == null || arguments.Length == _arguments.Count); 715switch (argumentList.Count)

System\Linq\Expressions\LambdaExpression.cs (3)

311return parameters.Count switch 573internal override int ParameterCount => _parameters.Count; 585Debug.Assert(parameters == null || parameters.Length == _parameters.Count);

System\Linq\Expressions\MethodCallExpression.cs (17)

System\Linq\Expressions\NewExpression.cs (1)

61public int ArgumentCount => _arguments.Count;

System.Net.Http (2)

System\Net\Http\DiagnosticsHandler.cs (2)

34if (autoRedirect && _propagator.Fields is IReadOnlyCollection<string> fields && fields.Count > 0) 36var fieldDescriptors = new List<HeaderDescriptor>(fields.Count);

System.Private.CoreLib (6)

src\libraries\System.Private.CoreLib\src\System\IO\RandomAccess.Unix.cs (6)

63MemoryHandle[] handles = new MemoryHandle[buffers.Count]; 64Span<Interop.Sys.IOVector> vectors = buffers.Count <= IovStackThreshold ? stackalloc Interop.Sys.IOVector[IovStackThreshold] : new Interop.Sys.IOVector[buffers.Count]; 69int buffersCount = buffers.Count; 80result = Interop.Sys.PReadV(handle, pinnedVectors, buffers.Count, fileOffset); 163int buffersCount = buffers.Count;

System.Private.Windows.Core (17)

System\Collections\Generic\CollectionExtensions.cs (1)

18ArgumentOutOfRangeException.ThrowIfLessThan(readOnlyList.Count, count, nameof(count));

System\IO\BinaryReaderExtensions.cs (2)

202if (values.Count == 0) 271for (int i = 0; i < values.Count; i++)

System\IO\BinaryWriterExtensions.cs (2)

33for (int i = 0; i < memberTypeInfo.Count; i++) 38for (int i = 0; i < memberTypeInfo.Count; i++)

System\Private\Windows\BinaryFormat\Serializer\ArrayRecord.cs (1)

64if (arrayInfo.Length != arrayObjects.Count)

System\Private\Windows\BinaryFormat\Serializer\ArraySingleObject.cs (1)

23: base(new ArrayInfo(objectId, arrayObjects.Count), arrayObjects)

System\Private\Windows\BinaryFormat\Serializer\ArraySinglePrimitive.cs (1)

29: base(new ArrayInfo(objectId, arrayObjects.Count), arrayObjects)

System\Private\Windows\BinaryFormat\Serializer\ArraySingleString.cs (1)

23: base(new ArrayInfo(objectId, arrayObjects.Count), new StringListAdapter(arrayObjects, recordMap))

System\Private\Windows\BinaryFormat\Serializer\ArraySingleString.StringListAdapter.cs (2)

30int IReadOnlyCollection<string?>.Count => _recordList.Count; 38for (int i = 0; i < _recordList.Count; i++)

System\Private\Windows\BinaryFormat\Serializer\ClassInfo.cs (1)

33writer.Write(MemberNames.Count);

System\Private\Windows\BinaryFormat\Serializer\ClassRecord.cs (2)

33for (int i = 0; i < ClassInfo.MemberNames.Count; i++) 64for (int i = 0; i < memberTypeInfo.Count; i++)

System\Private\Windows\BinaryFormat\Serializer\Record.cs (1)

91for (int i = 0; i < objects.Count; i++)

System\Private\Windows\Ole\DataFormatsCore.cs (2)

57for (int i = 0; i < formats.Count; i++) 120for (int i = 0; i < formats.Count; i++)

System.Reflection.Metadata (8)

System\Reflection\Metadata\Ecma335\MetadataAggregator.cs (8)

71if (baseTableRowCounts.Count != MetadataTokens.TableCount) 81if (baseHeapSizes.Count != MetadataTokens.HeapCount) 87if (deltaReaders == null || deltaReaders.Count == 0) 92for (int i = 0; i < deltaReaders.Count; i++) 139int generationCount = 1 + deltaReaders.Count; 151for (int r = 0; r < deltaReaders.Count; r++) 171var rowCounts = GetBaseRowCounts(baseRowCounts, generations: 1 + deltaReaders.Count); 173for (int generation = 1; generation <= deltaReaders.Count; generation++)

System.Windows.Forms (17)

System\Windows\Forms\Controls\ListBoxes\ListBox.AccessibleObject.cs (1)

149if (index >= entries.Count)

System\Windows\Forms\Controls\ListView\ListView.ListViewAccessibleObject.cs (7)

100return index < visibleGroups.Count ? visibleGroups[index].AccessibilityObject : null; 113int count = owningListView.GroupsDisplayed ? GetVisibleGroups().Count : owningListView.Items.Count; 142for (int i = 0; i < visibleGroups.Count; i++) 216return visibleGroups.Count == 0 ? null : visibleGroups[visibleGroups.Count - 1].AccessibilityObject; 275&& listViewGroupAccessibleObject.GetVisibleItems().Count > 0) 297for (int i = 0; i < visibleGroups.Count; i++)

System\Windows\Forms\Controls\ListView\ListViewGroup.ListViewGroupAccessibleObject.cs (6)

144private bool IsEmpty => GetVisibleItems().Count == 0; 247return visibleItems.Count > 0 ? visibleItems[visibleItems.Count - 1].AccessibilityObject : null; 262if (index >= visibleItems.Count) 278for (int i = 0; i < visibleItems.Count; i++) 296return GetVisibleItems().Count;

System\Windows\Forms\Controls\PropertyGrid\GridItemCollection.cs (3)

25public int Count => _entries.Count; 54if (_entries.Count > 0) 56for (int i = 0; i < _entries.Count; i++)

System.Windows.Forms.Design (3)

System\Windows\Forms\Design\DesignerUtils.cs (2)

765List<IComponent> newObjects = new(objects.Count); 778Debug.Assert(newObjects.Count == objects.Count, "Why is the count of the copied objects not the same?");

System\Windows\Forms\Design\ToolStripDesigner.cs (1)

1896for (int i = 0; i < components.Count; i++)

System.Xaml (2)

src\Microsoft.DotNet.Wpf\src\Shared\MS\Internal\Xaml\Parser\SpecialBracketCharacters.cs (1)

37if (attributeList is not null && attributeList.Count > 0)

System\Xaml\XamlSchemaContext.cs (1)

597SpecialBracketCharacters splBracketCharacters = markupExtensionBracketCharactersList is not null && markupExtensionBracketCharactersList.Count > 0

Templates.Blazor.WebAssembly.Auth.Tests (1)

src\Shared\E2ETesting\BrowserAssertFailedException.cs (1)

32if (logs.Count > 0)

Templates.Blazor.WebAssembly.Tests (1)

src\Shared\E2ETesting\BrowserAssertFailedException.cs (1)

32if (logs.Count > 0)

Templates.Mvc.Tests (1)

src\Shared\E2ETesting\BrowserAssertFailedException.cs (1)

32if (logs.Count > 0)

Templates.Tests (1)

src\Shared\E2ETesting\BrowserAssertFailedException.cs (1)

32if (logs.Count > 0)

xunit.assert (1)

Sdk\Exceptions\AllException.cs (1)

55 errors.Count,

xunit.console (1)

common\AssemblyResolution\DependencyContextAssemblyCache.cs (1)

67.Where(lib => lib.RuntimeAssemblyGroups?.Count > 0)