CompareTo

Implemented interface member:

163 references to CompareTo

CodeGenerator (2)

HttpUtilities\HttpUtilities.cs (2)

124distinctLengths.Sort((t1, t2) => -t1.CompareTo(t2)); 151methodsInfo.Sort((t1, t2) => t1.MaskLength.CompareTo(t2.MaskLength));

dotnet-svcutil-lib (1)

FrameworkFork\Microsoft.Xml\Xml\schema\DatatypeImplementation.cs (1)

3339return ((int)value1).CompareTo((int)value2);

GenerateDocumentationAndConfigFiles (2)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\NormalizedTextSpanCollection.cs (1)

599sorted.Sort(delegate (TextSpan s1, TextSpan s2) { return s1.Start.CompareTo(s2.Start); });

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (1)

926condDirectivesBuilder.Sort(static (n1, n2) => n1.SpanStart.CompareTo(n2.SpanStart));

illink (2)

Linker.Steps\UnreachableBlocksOptimizer.cs (1)

1555variables.Sort((a, b) => b.Index.CompareTo(a.Index));

Linker\MessageOrigin.cs (1)

149return ILOffset.CompareTo(other.ILOffset);

Metrics (2)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\NormalizedTextSpanCollection.cs (1)

599sorted.Sort(delegate (TextSpan s1, TextSpan s2) { return s1.Start.CompareTo(s2.Start); });

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (1)

926condDirectivesBuilder.Sort(static (n1, n2) => n1.SpanStart.CompareTo(n2.SpanStart));

Metrics.Legacy (2)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\NormalizedTextSpanCollection.cs (1)

599sorted.Sort(delegate (TextSpan s1, TextSpan s2) { return s1.Start.CompareTo(s2.Start); });

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (1)

926condDirectivesBuilder.Sort(static (n1, n2) => n1.SpanStart.CompareTo(n2.SpanStart));

Microsoft.AspNetCore.Components.Endpoints (1)

Builder\ResourcePreloadCollection.cs (1)

48group.Value.Sort((a, b) => a.PreloadOrder.CompareTo(b.PreloadOrder));

Microsoft.AspNetCore.Mvc.Core (2)

Filters\FilterDescriptorOrderComparer.cs (2)

17return x.Scope.CompareTo(y.Scope); 21return x.Order.CompareTo(y.Order);

Microsoft.AspNetCore.Razor.Runtime (1)

Runtime\TagHelpers\TagHelperRunner.cs (1)

65=> left.Order.CompareTo(right.Order);

Microsoft.AspNetCore.Routing (10)

Matching\AcceptsMatcherPolicy.cs (1)

272Array.Sort(ordered, static (left, right) => GetScore(left.mediaType).CompareTo(GetScore(right.mediaType)));

Matching\DfaMatcherBuilder.cs (1)

98return x.PrecedenceDigit.CompareTo(y.PrecedenceDigit);

Matching\EndpointComparer.cs (1)

119return routeEndpointX.Order.CompareTo(routeEndpointY.Order);

Matching\HostMatcherPolicy.cs (1)

299Array.Sort(ordered, static (left, right) => GetScore(left.host).CompareTo(GetScore(right.host)));

Matching\ILEmitTrieFactory.cs (5)

111Array.Sort(groups, static (a, b) => a.Key.CompareTo(b.Key)); 131groups.Sort(static (a, b) => b.Count().CompareTo(a.Count())); 351groups.Sort(static (a, b) => b.Count().CompareTo(a.Count())); 461Array.Sort(groups, static (a, b) => (a.Key | 0x20).CompareTo(b.Key | 0x20)); 476groups.Sort(static (a, b) => b.Count().CompareTo(a.Count()));

Tree\LinkGenerationDecisionTree.cs (1)

195return x.Match.Entry.Order.CompareTo(y.Match.Entry.Order);

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

Internal\SniOptionsSelector.cs (1)

234var lengthResult = y!.Length.CompareTo(x!.Length);

Microsoft.Cci.Extensions (3)

Comparers\ApiComparer.cs (3)

42return xKindOrder.CompareTo(yKindOrder); 54return x.Length.CompareTo(y.Length); 79var comparison = orderX.CompareTo(orderY);

Microsoft.CodeAnalysis (14)

CodeGen\DebugId.cs (2)

43=> Ordinal.CompareTo(other.Ordinal) is int result and not 0 ? result : Generation.CompareTo(other.Generation);

CodeGen\LocalScopeManager.cs (2)

884var result = x.StartOffset.CompareTo(y.StartOffset); 885return (result == 0) ? y.EndOffset.CompareTo(x.EndOffset) : result;

CommandLine\AnalyzerConfig.cs (1)

107(e1, e2) => e1.NormalizedDirectory.Length.CompareTo(e2.NormalizedDirectory.Length));

CommandLine\CommandLineParser.cs (1)

1438=> pathMap.Sort((x, y) => -x.Key.Length.CompareTo(y.Key.Length));

CommandLine\SarifV2ErrorLogger.cs (1)

509list.Sort((x, y) => x.Index.CompareTo(y.Index));

Emit\EditAndContinue\DeltaMetadataWriter.cs (3)

982int result = xOrdinal.CompareTo(yOrdinal); 995result = xOrdinal.CompareTo(yOrdinal); 1611=> rows.Sort((x, y) => GetRowId(x).CompareTo(GetRowId(y)));

Operations\ControlFlowGraphBuilder.RegionBuilder.cs (1)

335CaptureIds?.Sort((x, y) => x.Value.CompareTo(y.Value));

Syntax\LineDirectiveMap.LineMappingEntry.cs (1)

119=> UnmappedLine.CompareTo(other.UnmappedLine);

Text\LinePosition.cs (2)

138int result = _line.CompareTo(other._line); 139return (result != 0) ? result : _character.CompareTo(other.Character);

Microsoft.CodeAnalysis.Analyzers (2)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\NormalizedTextSpanCollection.cs (1)

599sorted.Sort(delegate (TextSpan s1, TextSpan s2) { return s1.Start.CompareTo(s2.Start); });

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (1)

926condDirectivesBuilder.Sort(static (n1, n2) => n1.SpanStart.CompareTo(n2.SpanStart));

Microsoft.CodeAnalysis.AnalyzerUtilities (2)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\NormalizedTextSpanCollection.cs (1)

599sorted.Sort(delegate (TextSpan s1, TextSpan s2) { return s1.Start.CompareTo(s2.Start); });

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (1)

926condDirectivesBuilder.Sort(static (n1, n2) => n1.SpanStart.CompareTo(n2.SpanStart));

Microsoft.CodeAnalysis.BannedApiAnalyzers (2)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\NormalizedTextSpanCollection.cs (1)

599sorted.Sort(delegate (TextSpan s1, TextSpan s2) { return s1.Start.CompareTo(s2.Start); });

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (1)

926condDirectivesBuilder.Sort(static (n1, n2) => n1.SpanStart.CompareTo(n2.SpanStart));

Microsoft.CodeAnalysis.CodeStyle (2)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\NormalizedTextSpanCollection.cs (1)

599sorted.Sort(delegate (TextSpan s1, TextSpan s2) { return s1.Start.CompareTo(s2.Start); });

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (1)

926condDirectivesBuilder.Sort(static (n1, n2) => n1.SpanStart.CompareTo(n2.SpanStart));

Microsoft.CodeAnalysis.CodeStyle.Fixes (1)

src\Analyzers\Core\CodeFixes\AddExplicitCast\InheritanceDistanceComparer.cs (1)

52return xDist.CompareTo(yDist);

Microsoft.CodeAnalysis.CSharp (3)

FlowAnalysis\NullableWalker.SnapshotManager.cs (1)

33private static readonly Func<(int position, Snapshot snapshot), int, int> BinarySearchComparer = (current, target) => current.position.CompareTo(target);

Symbols\Source\SourceMemberContainerSymbol.cs (1)

1255int index = initializers.BinarySearch(position, (initializer, pos) => initializer.Syntax.Span.Start.CompareTo(pos));

Syntax\NullableContextStateMap.cs (1)

183return x.Position.CompareTo(y.Position);

Microsoft.CodeAnalysis.CSharp.Features (1)

Structure\Providers\CompilationUnitStructureProvider.cs (1)

30externsAndUsings.Sort((node1, node2) => node1.SpanStart.CompareTo(node2.SpanStart));

Microsoft.CodeAnalysis.CSharp.Symbol.UnitTests (3)

Symbols\AnonymousTypesSemanticsTests.cs (1)

2124intervals.Sort((x, y) => x.Start.CompareTo(y.Start));

Symbols\CompilationCreationTests.cs (2)

51Assert.Equal(Math.Sign(compilation.CompareSyntaxTreeOrdering(expectedSyntaxTrees[i], expectedSyntaxTrees[j])), Math.Sign(i.CompareTo(j))); 60Assert.Equal(Math.Sign(compilation.CompareSourceLocations(types[i].Locations[0], types[j].Locations[0])), Math.Sign(i.CompareTo(j)));

Microsoft.CodeAnalysis.EditorFeatures (3)

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

554var comparison = x.FilterTextUsed.GetCaseInsensitivePrefixLength(pattern).CompareTo(y.FilterTextUsed.GetCaseInsensitivePrefixLength(pattern)); 559comparison = x.FilterTextUsed.GetCaseSensitivePrefixLength(pattern).CompareTo(y.FilterTextUsed.GetCaseSensitivePrefixLength(pattern)); 569comparison = GetPriority(xItem).CompareTo(GetPriority(yItem));

Microsoft.CodeAnalysis.Features (8)

ChangeSignature\AbstractChangeSignatureService.cs (1)

500argumentsToPermute.Sort((a1, a2) => { return parameterToIndexMap[argumentToParameterMap[a1]].CompareTo(parameterToIndexMap[argumentToParameterMap[a2]]); });

EditAndContinue\AbstractEditAndContinueAnalyzer.cs (1)

2318return (result != 0) ? result : x.oldStartLine.CompareTo(y.oldStartLine);

EditAndContinue\ActiveStatementsMap.cs (1)

250Debug.Assert(builder.IsSorted(Comparer<UnmappedActiveStatement>.Create((x, y) => x.UnmappedSpan.Start.CompareTo(y.UnmappedSpan.End))));

EditAndContinue\DocumentAnalysisResults.cs (1)

157(x, y) => x.OldLine.CompareTo(y.OldLine)))));

EditAndContinue\MemberBody.cs (1)

62startPositionComparer: (x, y) => x.UnmappedSpan.Start.CompareTo(y));

PdbSourceDocument\SourceLinkMap.cs (1)

105list.Sort((left, right) => -left.FilePath.Path.Length.CompareTo(right.FilePath.Path.Length));

src\Analyzers\Core\CodeFixes\AddExplicitCast\InheritanceDistanceComparer.cs (1)

52return xDist.CompareTo(yDist);

Structure\Syntax\AbstractBlockStructureProvider.cs (1)

19private static readonly IComparer<BlockSpan> s_blockSpanComparer = Comparer<BlockSpan>.Create(static (x, y) => y.TextSpan.Start.CompareTo(x.TextSpan.Start));

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

EditAndContinue\ActiveStatementsDescription.cs (1)

153activeStatements.Sort((x, y) => x.Statement.Id.Ordinal.CompareTo(y.Statement.Id.Ordinal));

Microsoft.CodeAnalysis.Features.UnitTests (1)

EditAndContinue\ActiveStatementsMapTests.cs (1)

60Assert.Equal(new Range(5, 6), ActiveStatementsMap.GetSpansStartingInSpan(span.Start, span.End, array, startPositionComparer: (x, y) => x.Start.CompareTo(y)));

Microsoft.CodeAnalysis.LanguageServer.Protocol (2)

Features\UnifiedSuggestions\UnifiedSuggestedActionSetComparer.cs (1)

63return distanceX.CompareTo(distanceY);

Protocol\SemanticTokens\SemanticTokensEdit.cs (1)

51=> other is null ? -1 : this.Start.CompareTo(other.Start);

Microsoft.CodeAnalysis.PerformanceSensitiveAnalyzers (2)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\NormalizedTextSpanCollection.cs (1)

599sorted.Sort(delegate (TextSpan s1, TextSpan s2) { return s1.Start.CompareTo(s2.Start); });

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (1)

926condDirectivesBuilder.Sort(static (n1, n2) => n1.SpanStart.CompareTo(n2.SpanStart));

Microsoft.CodeAnalysis.PublicApiAnalyzers (2)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\NormalizedTextSpanCollection.cs (1)

599sorted.Sort(delegate (TextSpan s1, TextSpan s2) { return s1.Start.CompareTo(s2.Start); });

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (1)

926condDirectivesBuilder.Sort(static (n1, n2) => n1.SpanStart.CompareTo(n2.SpanStart));

Microsoft.CodeAnalysis.ResxSourceGenerator (2)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\NormalizedTextSpanCollection.cs (1)

599sorted.Sort(delegate (TextSpan s1, TextSpan s2) { return s1.Start.CompareTo(s2.Start); });

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (1)

926condDirectivesBuilder.Sort(static (n1, n2) => n1.SpanStart.CompareTo(n2.SpanStart));

Microsoft.CodeAnalysis.Test.Utilities (2)

Diagnostics\DiagnosticDescription.cs (2)

658int lineDiff = x.Value.Line.CompareTo(y.Value.Line); 664return x.Value.Character.CompareTo(y.Value.Character);

Microsoft.CodeAnalysis.UnitTests (1)

Collections\TemporaryArrayTests.cs (1)

230array.Sort((x, y) => x.CompareTo(y));

Microsoft.CodeAnalysis.VisualBasic.Symbol.UnitTests (2)

SymbolsTests\CompilationCreationTests.vb (2)

2223Assert.Equal(Math.Sign(compilation.CompareSyntaxTreeOrdering(expectedSyntaxTrees(i), expectedSyntaxTrees(j))), Math.Sign(i.CompareTo(j))) 2230Assert.Equal(Math.Sign(compilation.CompareSourceLocations(types(i).Locations(0), types(j).Locations(0))), Math.Sign(i.CompareTo(j)))

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

TestSyntaxNodes.vb (2)

935Dim i = span1.Start.CompareTo(span2.Start) 937Return err1.Code.CompareTo(err2.Code)

Microsoft.CodeAnalysis.Workspaces (4)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\NormalizedTextSpanCollection.cs (1)

599sorted.Sort(delegate (TextSpan s1, TextSpan s2) { return s1.Start.CompareTo(s2.Start); });

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (1)

926condDirectivesBuilder.Sort(static (n1, n2) => n1.SpanStart.CompareTo(n2.SpanStart));

Workspace\Solution\SolutionCompilationState.RootedSymbolSet.cs (2)

89secondarySymbols.Sort(static (x, y) => x.hashCode.CompareTo(y.hashCode)); 123var index = secondarySymbols.BinarySearch(symbolHash, static (item, symbolHash) => item.hashCode.CompareTo(symbolHash));

Microsoft.DotNet.XUnitAssert.Tests (5)

EqualityAssertsTests.cs (5)

4396 return Value.CompareTo(intObj); 4398 return Value.CompareTo(multiObj.Value); 4413 public int CompareTo(ComparableBaseClass? other) => Value.CompareTo(other!.Value); 4518 public int CompareTo(IntWrapper? other) => Value.CompareTo(other!.Value); 4530 int IComparable<IntWrapper>.CompareTo(IntWrapper? other) => Value.CompareTo(other!.Value);

Microsoft.Extensions.AI.Evaluation.Reporting (1)

Utilities\IterationNameComparer.cs (1)

18return firstInteger.CompareTo(secondInteger);

Microsoft.Extensions.DependencyInjection (3)

ServiceLookup\CallSiteChain.cs (1)

52ordered.Sort((a, b) => a.Value.Order.CompareTo(b.Value.Order));

ServiceLookup\CallSiteFactory.cs (2)

356callSitesByIndex.Sort((a, b) => a.Key.CompareTo(b.Key)); 597(a, b) => b.GetParameters().Length.CompareTo(a.GetParameters().Length));

Microsoft.Interop.SourceGeneration (2)

BoundGenerators.cs (2)

120managedParamMarshallers.Sort(static (m1, m2) => m1.TypeInfo.ManagedIndex.CompareTo(m2.TypeInfo.ManagedIndex)); 121nativeParamMarshallers.Sort(static (m1, m2) => m1.TypeInfo.NativeIndex.CompareTo(m2.TypeInfo.NativeIndex));

Microsoft.Maui.Controls (3)

Menu\MenuBarTracker.cs (1)

68 public int Compare(MenuBarItem x, MenuBarItem y) => x.Priority.CompareTo(y.Priority);

Toolbar\ToolbarTracker.cs (1)

22 public int Compare(ToolbarItem x, ToolbarItem y) => x.Priority.CompareTo(y.Priority);

WebView\WebView.cs (1)

315 uniqueMatches.Sort((x, y) => y.Length.CompareTo(x.Length));

Microsoft.ML.Data (6)

DataLoadSave\Database\DatabaseLoader.cs (1)

425Array.Sort(order, (x, y) => segs[x].Min.CompareTo(segs[y].Min));

DataLoadSave\Text\TextLoader.cs (2)

641Array.Sort(order, (x, y) => segs[x].Min.CompareTo(segs[y].Min)); 869segsAll.Sort((s1, s2) => s1.Min.CompareTo(s2.Min));

Evaluators\RankingEvaluator.cs (1)

1072return i.CompareTo(j);

Transforms\NormalizeColumnDbl.cs (1)

542int comparison = belowMedianHeap.Count().CompareTo(aboveMedianHeap.Count());

Transforms\NormalizeColumnSng.cs (1)

702int comparison = belowMedianHeap.Count().CompareTo(aboveMedianHeap.Count());

Microsoft.ML.FastTree (3)

Training\DcgPermutationComparer.cs (3)

73return i.CompareTo(j); 101return i.CompareTo(j); 113return -i.CompareTo(j);

Microsoft.ML.Tokenizers (5)

Model\CodeGenTokenizer.cs (2)

1821return Score.CompareTo(other.Score); 1824return Left.CompareTo(other.Left);

Model\Merge.cs (2)

29return Rank.CompareTo(other.Rank); 32return Pos.CompareTo(other.Pos);

Model\SentencePieceBpeModel.cs (1)

1244return other.Left.CompareTo(Left);

PresentationFramework (4)

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

166int comp = this.Page.CompareTo(fixedNode.Page); 180return thisIndex.CompareTo(fixedNodeIndex); 202return childPath[i].CompareTo(_path[i + 1]);

System\Windows\Documents\FlowPosition.cs (1)

750comp = this._offset.CompareTo(flow._offset);

Roslyn.Diagnostics.Analyzers (2)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\NormalizedTextSpanCollection.cs (1)

599sorted.Sort(delegate (TextSpan s1, TextSpan s2) { return s1.Start.CompareTo(s2.Start); });

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (1)

926condDirectivesBuilder.Sort(static (n1, n2) => n1.SpanStart.CompareTo(n2.SpanStart));

Roslyn.Test.PdbUtilities (1)

Reader\PdbValidation.cs (1)

665expectedTags.Sort((x, y) => x.StartIndex.CompareTo(y.StartIndex));

System.Data.Common (5)

System\Data\Common\Int32Storage.cs (1)

196return valueNo1.CompareTo((int)value);

System\Data\Filter\BinaryNode.cs (2)

180return Convert.ToInt32(vLeft, FormatProvider).CompareTo(Convert.ToInt32(vRight, FormatProvider)); 187return Convert.ToInt32(vLeft, FormatProvider).CompareTo(Convert.ToInt32(vRight, FormatProvider));

System\Data\Selection.cs (2)

331return _table.Rows.IndexOf(row1).CompareTo(_table.Rows.IndexOf(row2)); 381diff = ((int)row1.GetRecordState(record1)).CompareTo((int)row2.GetRecordState(record2));

System.IO.Packaging (1)

System\IO\Packaging\ZipPackagePartPiece.cs (1)

200result = PieceNumber.CompareTo(other.PieceNumber);

System.Linq.Parallel (1)

System\Linq\Parallel\Utils\Util.cs (1)

68return x.CompareTo(y);

System.Private.CoreLib (6)

src\libraries\System.Private.CoreLib\src\System\Enum.cs (1)

1309return Unsafe.As<byte, int>(ref pThisValue).CompareTo(Unsafe.As<byte, int>(ref pTargetValue));

src\libraries\System.Private.CoreLib\src\System\Globalization\IcuLocaleData.cs (1)

3721int order = array_value.CompareTo(culture);

src\libraries\System.Private.CoreLib\src\System\MemoryExtensions.cs (1)

3544return span.Length.CompareTo(other.Length);

src\libraries\System.Private.CoreLib\src\System\Numerics\TotalOrderIeee754Comparer.cs (1)

168return xSignificandBits.CompareTo(ySignificandBits);

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\StringSearchValues.cs (1)

67normalizedValues.Sort(static (a, b) => a.Length.CompareTo(b.Length));

src\libraries\System.Private.CoreLib\src\System\SpanHelpers.T.cs (1)

1302return firstLength.CompareTo(secondLength);

System.Private.Xml (4)

System\Xml\Schema\DataTypeImplementation.cs (1)

3275return ((int)value1).CompareTo((int)value2);

System\Xml\Xsl\Xslt\Compiler.cs (3)

378int result = _moduleOrder[x.FileName].CompareTo(_moduleOrder[y.FileName]); 382result = x.Line.CompareTo(y.Line); 386result = x.Column.CompareTo(y.Column);

System.Reflection.Emit (2)

System\Reflection\Emit\ModuleBuilderImpl.cs (2)

188int primary = CodedIndex.TypeOrMethodDef(x._parentHandle).CompareTo(CodedIndex.TypeOrMethodDef(y._parentHandle)); 192return x.GenericParameterPosition.CompareTo(y.GenericParameterPosition);

System.Reflection.Metadata (1)

System\Reflection\Metadata\Ecma335\MetadataBuilder.Heaps.cs (1)

602return y.Length.CompareTo(x.Length);

System.Security.Cryptography.Xml (1)

System\Security\Cryptography\Xml\SignedXml.cs (1)

878return iLevelA.CompareTo(iLevelB);

System.Text.RegularExpressions (7)

System\Text\RegularExpressions\RegexFindOptimizations.cs (1)

347fixedDistanceSets.Sort((s1, s2) => s1.Distance.CompareTo(s2.Distance));

System\Text\RegularExpressions\RegexPrefixAnalyzer.cs (4)

832return s1CharsLength.CompareTo(s2CharsLength); 856int c = Math.Max(s1CharsLength, s1RangeLength).CompareTo(Math.Max(s2CharsLength, s2RangeLength)); 882return s1RangeLength.CompareTo(s2RangeLength); 886return s1.Distance.CompareTo(s2.Distance);

System\Text\RegularExpressions\Symbolic\BDD.cs (1)

539Ordinal.CompareTo(other.Ordinal);

System\Text\RegularExpressions\Symbolic\BitVector.cs (1)

194Length != other.Length ? Length.CompareTo(other.Length) :

System.Text.RegularExpressions.Generator (5)

src\libraries\System.Text.RegularExpressions\src\System\Text\RegularExpressions\RegexFindOptimizations.cs (1)

347fixedDistanceSets.Sort((s1, s2) => s1.Distance.CompareTo(s2.Distance));

src\libraries\System.Text.RegularExpressions\src\System\Text\RegularExpressions\RegexPrefixAnalyzer.cs (4)

Test.Utilities (2)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\NormalizedTextSpanCollection.cs (1)

599sorted.Sort(delegate (TextSpan s1, TextSpan s2) { return s1.Start.CompareTo(s2.Start); });

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (1)

926condDirectivesBuilder.Sort(static (n1, n2) => n1.SpanStart.CompareTo(n2.SpanStart));

Text.Analyzers (2)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Collections\NormalizedTextSpanCollection.cs (1)

599sorted.Sort(delegate (TextSpan s1, TextSpan s2) { return s1.Start.CompareTo(s2.Start); });

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\SyntaxNodeExtensions.cs (1)

926condDirectivesBuilder.Sort(static (n1, n2) => n1.SpanStart.CompareTo(n2.SpanStart));