Ordinal

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

778public ConcurrentDictionary<string, bool> ResourceHealthStatusesToVisibility { get; } = new(StringComparer.Ordinal);

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

275var traceCache = new Dictionary<string, OtlpTrace>(StringComparer.Ordinal);

src\Shared\StringComparers.cs (12)

Dashboard\DashboardLifecycleHook.cs (1)

362var loggerCache = new ConcurrentDictionary<string, ILogger>(StringComparer.Ordinal);

src\Shared\StringComparers.cs (12)

src\Shared\StringComparers.cs (12)

src\Shared\StringComparers.cs (12)

src\Shared\StringComparers.cs (12)

src\Shared\StringComparers.cs (12)

src\Shared\StringComparers.cs (12)

src\Shared\StringComparers.cs (12)

src\Shared\StringComparers.cs (12)

src\Shared\StringComparers.cs (12)

src\Shared\StringComparers.cs (12)

src\Shared\StringComparers.cs (12)

src\Aspire.AppHost.Sdk\Aspire.RuntimeIdentifier.Tool\NuGetUtils.cs (2)

32HashSet<string> availableRids = new(availableRuntimeIdentifiers, StringComparer.Ordinal); 33HashSet<string>? excludedRids = runtimeIdentifiersToExclude switch { null => null, _ => new HashSet<string>(runtimeIdentifiersToExclude, StringComparer.Ordinal) };

src\Shared\StringComparers.cs (12)

Utils\StringComparersTests.cs (7)

17var comparers = typeof(StringComparers).GetProperties(flags).OrderBy(c => c.Name, StringComparer.Ordinal).ToList(); 18var comparisons = typeof(StringComparisons).GetProperties(flags).OrderBy(c => c.Name, StringComparer.Ordinal).ToList(); 53var extraComparers = comparerNames.Except(comparisonNames, StringComparer.Ordinal).ToList(); 54var extraComparisons = comparisonNames.Except(comparerNames, StringComparer.Ordinal).ToList(); 74Assert.Equal(comparer.Name, comparison.Name, StringComparer.Ordinal); 106yield return (StringComparer.Ordinal, nameof(StringComparer.Ordinal));

NuGetUtils.cs (2)

32HashSet<string> availableRids = new(availableRuntimeIdentifiers, StringComparer.Ordinal); 33HashSet<string>? excludedRids = runtimeIdentifiersToExclude switch { null => null, _ => new HashSet<string>(runtimeIdentifiersToExclude, StringComparer.Ordinal) };

ConfigSchemaEmitter.cs (1)

749obj.OrderBy(p => p.Key, StringComparer.Ordinal) :

FrameworkFork\Microsoft.CodeDom\Microsoft\CSharpCodeProvider.cs (1)

3323importList = new SortedList(StringComparer.Ordinal);

FrameworkFork\System.Runtime.Serialization\System\Runtime\Serialization\CodeExporter.cs (2)

53_clrNamespaces = new Dictionary<string, string>(StringComparer.Ordinal); 1427Dictionary<string, object> fragments = new Dictionary<string, object>(StringComparer.Ordinal);

FrameworkFork\System.Runtime.Serialization\System\Runtime\Serialization\ContractCodeDomInfo.cs (1)

42_memberNames = new Dictionary<string, object>(StringComparer.Ordinal);

FrameworkFork\System.ServiceModel\System\ServiceModel\Description\UniqueCodeIdentifierScope.cs (1)

23_names = new SortedList<string, string>(StringComparer.Ordinal);

Linker\LinkContext.cs (2)

210 _parameters = new Dictionary<string, string> (StringComparer.Ordinal); 216 FeatureSettings = new Dictionary<string, bool> (StringComparer.Ordinal);

CreateRuntimeRootDescriptorFile.cs (1)

98 readonly HashSet<string> defineConstants = new HashSet<string> (StringComparer.Ordinal);

IOperationClassWriter.cs (2)

493var newProps = new HashSet<string>(StringComparer.Ordinal); 961var newProps = new HashSet<string>(StringComparer.Ordinal);

Program.cs (1)

24private readonly ConcurrentDictionary<string, Task<string>> _tokens = new ConcurrentDictionary<string, Task<string>>(StringComparer.Ordinal);

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (1)

488ImmutableHashSet.Create(StringComparer.Ordinal, "Add", "AddOrUpdate", "GetOrAdd", "TryAdd", "TryUpdate");

src\RoslynAnalyzers\Utilities\Compiler\SymbolByDisplayStringComparer.cs (1)

54return StringComparer.Ordinal.Compare(

src\RoslynAnalyzers\Utilities\Compiler\WellKnownTypeProvider.cs (2)

30_fullNameToTypeMap = new ConcurrentDictionary<string, INamedTypeSymbol?>(StringComparer.Ordinal); 80new(StringComparer.Ordinal);

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (1)

488ImmutableHashSet.Create(StringComparer.Ordinal, "Add", "AddOrUpdate", "GetOrAdd", "TryAdd", "TryUpdate");

src\RoslynAnalyzers\Utilities\Compiler\SymbolByDisplayStringComparer.cs (1)

54return StringComparer.Ordinal.Compare(

src\RoslynAnalyzers\Utilities\Compiler\WellKnownTypeProvider.cs (2)

30_fullNameToTypeMap = new ConcurrentDictionary<string, INamedTypeSymbol?>(StringComparer.Ordinal); 80new(StringComparer.Ordinal);

InternalReferencedInPublicDocAnalyzerTests.cs (1)

472Assert.Equal(detectedTexts[i], text, StringComparer.Ordinal);

TestSource.cs (1)

15= new Dictionary<string, DiagnosticLocation>(StringComparer.Ordinal);

Internal\DefaultAntiforgeryTokenGenerator.cs (1)

158comparer = StringComparer.Ordinal;

AuthenticationOptions.cs (1)

25public IDictionary<string, AuthenticationSchemeBuilder> SchemeMap { get; } = new Dictionary<string, AuthenticationSchemeBuilder>(StringComparer.Ordinal);

AuthenticationProperties.cs (4)

44Items = items ?? new Dictionary<string, string?>(StringComparer.Ordinal); 45Parameters = parameters ?? new Dictionary<string, object?>(StringComparer.Ordinal); 54new Dictionary<string, string?>(Items, StringComparer.Ordinal), 55new Dictionary<string, object?>(Parameters, StringComparer.Ordinal));

AuthenticationHandlerProvider.cs (1)

29private readonly Dictionary<string, IAuthenticationHandler> _handlerMap = new Dictionary<string, IAuthenticationHandler>(StringComparer.Ordinal);

AuthenticationSchemeProvider.cs (1)

21: this(options, new Dictionary<string, AuthenticationScheme>(StringComparer.Ordinal))

ClaimsAuthorizationRequirement.cs (1)

72&& requirement.AllowedValues!.Contains(claim.Value, StringComparer.Ordinal))

BrowserManager.cs (1)

19private readonly Dictionary<string, IBrowser> _launchBrowsers = new(StringComparer.Ordinal);

PersistentState\ComponentStatePersistenceManager.cs (1)

19private readonly Dictionary<string, byte[]> _currentState = new(StringComparer.Ordinal);

Reflection\ComponentProperties.cs (1)

249propertyNames.Sort(StringComparer.Ordinal);

Reflection\MemberAssignment.cs (1)

17var dictionary = new Dictionary<string, object>(StringComparer.Ordinal);

Rendering\EndpointHtmlRenderer.EventDispatch.cs (1)

21private readonly Dictionary<string, HashSet<(int ComponentId, int FrameIndex)>> _namedSubmitEventsByScopeQualifiedName = new(StringComparer.Ordinal);

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

78else if (StringComparer.Ordinal.Compare(@interface.FullName, bestMatch.FullName) < 0)

Builder\TestFileProvider\TestFileProvider.cs (2)

11new Dictionary<string, IFileInfo>(StringComparer.Ordinal); 16new Dictionary<string, TestFileChangeToken>(StringComparer.Ordinal);

FieldIdentifier.cs (1)

75var fieldHash = StringComparer.Ordinal.GetHashCode(FieldName);

EditContextTest.cs (1)

350return StringComparer.Ordinal.GetHashCode(Property);

FieldIdentifierTest.cs (1)

301return StringComparer.Ordinal.GetHashCode(Property);

ProtectedBrowserStorage\ProtectedBrowserStorage.cs (1)

20= new ConcurrentDictionary<string, IDataProtector>(StringComparer.Ordinal);

src\SignalR\common\Protocols.MessagePack\src\Protocol\MessagePackHubProtocolWorker.cs (1)

246var headers = new Dictionary<string, string>(StringComparer.Ordinal);

Circuits\CircuitIdFactoryTest.cs (1)

35Assert.Equal(100, secrets.Distinct(StringComparer.Ordinal).Count());

JSComponents\JSComponentConfigurationStore.cs (3)

24private readonly Dictionary<string, Type> _jsComponentTypesByIdentifier = new(StringComparer.Ordinal); 25internal Dictionary<string, JSComponentParameter[]> JSComponentParametersByIdentifier { get; } = new(StringComparer.Ordinal); 26internal Dictionary<string, List<string>> JSComponentIdentifiersByInitializer { get; } = new(StringComparer.Ordinal);

HotReload\MetadataUpdateHandlerInvoker.cs (1)

215var visited = new HashSet<string>(StringComparer.Ordinal);

Http\WebAssemblyHttpRequestMessageExtensions.cs (1)

126fetchOptions = new Dictionary<string, object>(StringComparer.Ordinal);

src\Shared\StaticWebAssets\ManifestStaticWebAssetFileProvider.cs (1)

311OperatingSystem.IsWindows() ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;

Infrastructure\ElementNode.cs (3)

15_attributes = new Dictionary<string, object>(StringComparer.Ordinal); 16_properties = new Dictionary<string, object>(StringComparer.Ordinal); 17_events = new Dictionary<string, ElementEventDescriptor>(StringComparer.Ordinal);

Infrastructure\CorsOptions.cs (1)

16= new Dictionary<string, (CorsPolicy, Task<CorsPolicy>)>(StringComparer.Ordinal);

Infrastructure\CorsPolicy.cs (1)

177return Origins.Contains(origin, StringComparer.Ordinal);

XmlEncryption\XmlKeyDecryptionOptions.cs (1)

16private readonly Dictionary<string, List<X509Certificate2>> _certs = new Dictionary<string, List<X509Certificate2>>(StringComparer.Ordinal);

Logging\HttpLoggingRedactionInterceptor.cs (1)

54_parametersToRedactMap = optionsValue.RouteParameterDataClasses.ToFrozenDictionary(StringComparer.Ordinal);

Logging\IncomingHttpRouteUtility.cs (1)

63return _parametersToRedactCache.GetOrAdd(httpRoute, static (_, paramsToRedact) => paramsToRedact.ToFrozenDictionary(StringComparer.Ordinal), parametersToRedact);

Logging\IncomingHttpRouteUtilityTests.cs (4)

57var sensitiveParameters = routeUtility.GetSensitiveParameters(httpRoute, mockHttpRequest.Object, new Dictionary<string, DataClassification>(StringComparer.Ordinal)); 95var sensitiveParameters = routeUtility.GetSensitiveParameters(httpRoute, mockHttpRequest.Object, new Dictionary<string, DataClassification>(StringComparer.Ordinal)); 135var sensitiveParameters = routeUtility.GetSensitiveParameters(httpRoute, mockHttpRequest.Object, new Dictionary<string, DataClassification>(StringComparer.Ordinal)); 267var sensitiveParameters = routeUtility.GetSensitiveParameters(httpRoute, mockHttpRequest.Object, new Dictionary<string, DataClassification>(StringComparer.Ordinal));

src\Grpc\JsonTranscoding\src\Shared\AuthContextHelpers.cs (1)

32var properties = new Dictionary<string, List<AuthProperty>>(StringComparer.Ordinal);

src\Grpc\JsonTranscoding\src\Shared\Server\MethodOptions.cs (1)

111var resolvedCompressionProviders = new Dictionary<string, ICompressionProvider>(StringComparer.Ordinal);

src\Grpc\JsonTranscoding\src\Shared\ServiceDescriptorHelpers.cs (1)

391var routeParameterDescriptors = new Dictionary<string, RouteParameter>(StringComparer.Ordinal);

ConverterTests\JsonElementComparer.cs (3)

77var xProperties = xPropertiesUnsorted.OrderBy(p => p.Name, StringComparer.Ordinal); 78var yProperties = yPropertiesUnsorted.OrderBy(p => p.Name, StringComparer.Ordinal); 142foreach (var property in obj.EnumerateObject().OrderBy(p => p.Name, StringComparer.Ordinal))

src\Grpc\JsonTranscoding\src\Shared\ServiceDescriptorHelpers.cs (1)

391var routeParameterDescriptors = new Dictionary<string, RouteParameter>(StringComparer.Ordinal);

src\Shared\StaticWebAssets\ManifestStaticWebAssetFileProvider.cs (1)

311OperatingSystem.IsWindows() ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;

Builder\ApplicationBuilder.cs (2)

44Properties = new Dictionary<string, object?>(StringComparer.Ordinal); 63Properties = new CopyOnWriteDictionary<string, object?>(builder.Properties, StringComparer.Ordinal);

ProblemDetails\HttpValidationProblemDetails.cs (2)

18: this(new Dictionary<string, string[]>(StringComparer.Ordinal)) 36: this(new Dictionary<string, string[]>(errors ?? throw new ArgumentNullException(nameof(errors)), StringComparer.Ordinal))

ProblemDetails\ProblemDetails.cs (1)

70public IDictionary<string, object?> Extensions { get; set; } = new Dictionary<string, object?>(StringComparer.Ordinal);

Internal\HttpConnectionManager.cs (1)

23new ConcurrentDictionary<string, HttpConnectionContext>(StringComparer.Ordinal);

HttpConnection.cs (1)

395else if (!transport.TransferFormats!.Contains(transferFormatString, StringComparer.Ordinal))

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

78else if (StringComparer.Ordinal.Compare(@interface.FullName, bestMatch.FullName) < 0)

ValidatableTypesBenchmark.cs (1)

46ValidationErrors = new Dictionary<string, string[]>(StringComparer.Ordinal)

RequestDelegateGeneratorSources.cs (1)

633foreach (string verb in verbs.OrderBy(p => p, StringComparer.Ordinal))

StaticRouteHandlerModel\EndpointHttpMethodComparer.cs (1)

12private static readonly IEqualityComparer<string> OrdinalComparer = StringComparer.Ordinal;

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

78else if (StringComparer.Ordinal.Compare(@interface.FullName, bestMatch.FullName) < 0)

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

78else if (StringComparer.Ordinal.Compare(@interface.FullName, bestMatch.FullName) < 0)

Internal\DictionaryAdapterTest.cs (8)

Internal\DictionaryAdapterTest.cs (8)

ModelBinding\CompositeBindingSource.cs (1)

56var id = string.Join('&', bindingSources.Select(s => s.Id).OrderBy(s => s, StringComparer.Ordinal));

ModelBinding\Metadata\ModelMetadataIdentity.cs (1)

204hash.Add(Name, StringComparer.Ordinal);

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

78else if (StringComparer.Ordinal.Compare(@interface.FullName, bestMatch.FullName) < 0)

ApplicationParts\ApplicationPartManager.cs (2)

83.OrderBy(assembly => assembly.FullName, StringComparer.Ordinal) 97.OrderBy(assembly => assembly.FullName, StringComparer.Ordinal);

BindAttribute.cs (2)

70return Include.Contains(modelMetadata.ParameterName, StringComparer.Ordinal); 73return Include.Contains(modelMetadata.PropertyName, StringComparer.Ordinal);

Infrastructure\StringArrayComparer.cs (1)

8public static readonly StringArrayComparer Ordinal = new StringArrayComparer(StringComparer.Ordinal);

ModelBinding\Binders\DictionaryModelBinder.cs (1)

161var keyMappings = new Dictionary<string, TKey>(StringComparer.Ordinal);

ValidationProblemDetails.cs (1)

37var errorDictionary = new Dictionary<string, string[]>(StringComparer.Ordinal);

ApplicationModels\ControllerActionDescriptorProviderTests.cs (2)

1417.OrderBy(l => l, StringComparer.Ordinal) 1423.OrderBy(l => l, StringComparer.Ordinal)

ApplicationModels\DefaultApplicationModelProviderTest.cs (3)

932methodConstraint.HttpMethods.OrderBy(m => m, StringComparer.Ordinal)); 1089Assert.Equal(new[] { "GET", "POST" }, methodConstraint.HttpMethods.OrderBy(key => key, StringComparer.Ordinal)); 1093Assert.Equal(new[] { "GET", "POST" }, methodConstraint.HttpMethods.OrderBy(key => key, StringComparer.Ordinal));

Controllers\ControllerBinderDelegateProviderTest.cs (22)

ModelBinding\Binders\DateTimeModelBinderTest.cs (2)

72Assert.Equal("The value '2020-08-not-a-date' is not valid.", error.ErrorMessage, StringComparer.Ordinal); 128Assert.Equal(message, error.ErrorMessage, StringComparer.Ordinal);

ModelBinding\Binders\DictionaryModelBinderTest.cs (4)

101var dictionaryWithOne = new Dictionary<string, string>(StringComparer.Ordinal) 105var dictionaryWithThree = new Dictionary<string, string>(StringComparer.Ordinal) 196var dictionary = new Dictionary<string, string>(StringComparer.Ordinal) 233var dictionary = new Dictionary<string, string>(StringComparer.Ordinal)

ModelBinding\Binders\FloatingPointTypeModelBinderTestOfT.cs (5)

95Assert.Equal("The value '12_5' is not valid.", error.ErrorMessage, StringComparer.Ordinal); 119Assert.Equal("The value ' 12' is not valid.", error.ErrorMessage, StringComparer.Ordinal); 143Assert.Equal("The value '12.5' is not valid.", error.ErrorMessage, StringComparer.Ordinal); 167Assert.Equal("The value '32,000' is not valid.", error.ErrorMessage, StringComparer.Ordinal); 209Assert.Equal(message, error.ErrorMessage, StringComparer.Ordinal);

ModelBinding\Binders\SimpleTypeModelBinderTest.cs (2)

130Assert.Equal("The value '' is invalid.", error.ErrorMessage, StringComparer.Ordinal); 376Assert.Equal("The value '12,5' is not valid.", error.ErrorMessage, StringComparer.Ordinal);

ModelBinding\Binders\TryParseTypeModelBinderTest.cs (4)

79Assert.Equal("The value '' is invalid.", error.ErrorMessage, StringComparer.Ordinal); 302Assert.Equal("The value '12-5' is not valid.", error.ErrorMessage, StringComparer.Ordinal); 407Assert.Equal($"The value '{flagsEnumValue}' is not valid.", error.ErrorMessage, StringComparer.Ordinal); 457Assert.Equal($"The value '{value}' is not valid.", error.ErrorMessage, StringComparer.Ordinal);

ModelBinding\CompositeValueProviderTest.cs (1)

70var dictionary = new Dictionary<string, string>(StringComparer.Ordinal)

ModelBinding\ModelBinderFactoryTest.cs (1)

361Assert.Equal(expectedInfo.BinderModelName, context.BindingInfo.BinderModelName, StringComparer.Ordinal);

ResponseCacheAttributeTest.cs (2)

358expected.Split(',').Select(p => p.Trim()).OrderBy(item => item, StringComparer.Ordinal), 359actual.Split(',').Select(p => p.Trim()).OrderBy(item => item, StringComparer.Ordinal));

BodyValidationIntegrationTests.cs (2)

842Assert.Equal("someStreet", person.Address.Street, StringComparer.Ordinal); 887Assert.Equal("someStreet", address.Street, StringComparer.Ordinal);

ComplexRecordIntegrationTest.cs (5)

2620Assert.Equal("The value '' is invalid.", error.ErrorMessage, StringComparer.Ordinal); 2671Assert.Equal("someStreet", person.Address.Street, StringComparer.Ordinal); 2719Assert.Equal("someStreet", address.Street, StringComparer.Ordinal); 2779Assert.Equal("someStreet", person.Address.Street, StringComparer.Ordinal); 2832Assert.Equal("someStreet", address.Street, StringComparer.Ordinal);

ComplexTypeIntegrationTestBase.cs (5)

2793Assert.Equal("The value '' is invalid.", error.ErrorMessage, StringComparer.Ordinal); 2850Assert.Equal("someStreet", person.Address.Street, StringComparer.Ordinal); 2898Assert.Equal("someStreet", address.Street, StringComparer.Ordinal); 2970Assert.Equal("someStreet", person.Address.Street, StringComparer.Ordinal); 3023Assert.Equal("someStreet", address.Street, StringComparer.Ordinal);

SimpleTypeModelBinderIntegrationTest.cs (2)

507Assert.Equal("The value '' is invalid.", error.ErrorMessage, StringComparer.Ordinal); 561Assert.Equal("Hurts when '' is provided.", error.ErrorMessage, StringComparer.Ordinal);

TryValidateModelIntegrationTest.cs (2)

196expected.Split('.').OrderBy(item => item, StringComparer.Ordinal), 197actual.Split('.').OrderBy(item => item, StringComparer.Ordinal));

AnnotatedProblemDetails.cs (1)

45public IDictionary<string, object?> Extensions { get; } = new Dictionary<string, object?>(StringComparer.Ordinal);

BsonTempDataSerializer.cs (1)

229var convertedDictionary = new Dictionary<string, TVal?>(StringComparer.Ordinal);

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

78else if (StringComparer.Ordinal.Compare(@interface.FullName, bestMatch.FullName) < 0)

ValidationProblemDetailsConverter.cs (1)

66public IDictionary<string, string[]> Errors { get; } = new Dictionary<string, string[]>(StringComparer.Ordinal);

NewtonsoftJsonOutputFormatterTest.cs (1)

241var dictionary = new Dictionary<string, int>(StringComparer.Ordinal)

ApplicationParts\RazorCompiledItemFeatureProvider.cs (1)

67_hotReloadedViews ??= new(StringComparer.Ordinal);

Compilation\DefaultViewCompiler.cs (1)

32_normalizedPathCache = new ConcurrentDictionary<string, string>(StringComparer.Ordinal);

RazorViewEngine.cs (1)

244expanderValues = new Dictionary<string, string?>(StringComparer.Ordinal);

ViewLocationCacheKey.cs (6)

131hashCode.Add(ViewName, StringComparer.Ordinal); 132hashCode.Add(ControllerName, StringComparer.Ordinal); 133hashCode.Add(AreaName, StringComparer.Ordinal); 134hashCode.Add(PageName, StringComparer.Ordinal); 140hashCode.Add(item.Key, StringComparer.Ordinal); 141hashCode.Add(item.Value, StringComparer.Ordinal);

CompilationFailedExceptionFactory.cs (2)

29StringComparer.Ordinal); 55.GroupBy(diagnostic => GetFilePath(codeDocument, diagnostic), StringComparer.Ordinal);

RuntimeViewCompiler.cs (1)

53_normalizedPathCache = new ConcurrentDictionary<string, string>(StringComparer.Ordinal);

RazorPageTest.cs (18)

RazorViewEngineOptionsTest.cs (2)

40Assert.Equal(areaViewLocations, formats, StringComparer.Ordinal); 70Assert.Equal(viewLocations, formats, StringComparer.Ordinal);

TagHelpers\TagHelperComponentTagHelperTest.cs (2)

247Assert.Equal($"Tag helper component '{typeof(TestTagHelperComponent)}' initialized.", sink.Writes.First().State.ToString(), StringComparer.Ordinal); 280Assert.Equal($"Tag helper component '{typeof(TestTagHelperComponent)}' processed.", sink.Writes.First().State.ToString(), StringComparer.Ordinal);

TagHelpers\UrlResolutionTagHelperTest.cs (14)

Infrastructure\CompiledPageActionDescriptorProvider.cs (1)

57var lookup = new Dictionary<string, CompiledViewDescriptor>(feature.ViewDescriptors.Count, StringComparer.Ordinal);

Cache\CacheTagKey.cs (4)

246hashCode.Add(Key, StringComparer.Ordinal); 250hashCode.Add(_varyBy, StringComparer.Ordinal); 251hashCode.Add(_username, StringComparer.Ordinal); 334hashCode.Add(collectionName, StringComparer.Ordinal);

InputTagHelper.cs (1)

57new(StringComparer.Ordinal)

JavaScriptResources.cs (1)

18new ConcurrentDictionary<string, string>(StringComparer.Ordinal);

TagHelperOutputExtensions.cs (1)

175if (arrayOfClasses.Contains(encodedClassValue, StringComparer.Ordinal))

FormActionTagHelperTest.cs (15)

GlobbingUrlBuilderTest.cs (1)

350Assert.Equal(expectedOutput, urlList, StringComparer.Ordinal);

ImageTagHelperTest.cs (1)

78StringComparer.Ordinal);

LinkTagHelperTest.cs (1)

76StringComparer.Ordinal);

ScriptTagHelperTest.cs (1)

75StringComparer.Ordinal);

SelectTagHelperTest.cs (1)

107var attributeData = new Dictionary<string, string>(StringComparer.Ordinal)

WebApplicationFactory.cs (1)

473.ToDictionary(r => r.Name, r => r, StringComparer.Ordinal);

FormContext.cs (3)

35_formData = new Dictionary<string, object>(StringComparer.Ordinal); 107_renderedFields = new Dictionary<string, bool>(StringComparer.Ordinal); 122_invariantFields ??= new(StringComparer.Ordinal);

Infrastructure\DefaultTempDataSerializer.cs (2)

27var deserialized = new Dictionary<string, object>(StringComparer.Ordinal); 119var dictionary = new Dictionary<string, string>(StringComparer.Ordinal);

LambdaExpressionComparer.cs (1)

98hashCode.Add(memberName, StringComparer.Ordinal);

DefaultValidationHtmlAttributeProviderTest.cs (7)

29var attributes = new SortedDictionary<string, string>(StringComparer.Ordinal); 64var attributes = new SortedDictionary<string, string>(StringComparer.Ordinal); 100var attributes = new SortedDictionary<string, string>(StringComparer.Ordinal); 123var attributes = new SortedDictionary<string, string>(StringComparer.Ordinal); 164var attributes = new SortedDictionary<string, string>(StringComparer.Ordinal); 198var attributes = new SortedDictionary<string, string>(StringComparer.Ordinal); 236var attributes = new SortedDictionary<string, string>(StringComparer.Ordinal);

ExpressionHelperTest.cs (2)

402Assert.Equal(text1, text2, StringComparer.Ordinal); 431Assert.NotEqual(text1, text2, StringComparer.Ordinal);

Rendering\HtmlHelperSelectTest.cs (2)

1503expected.OrderBy(item => item.Text, StringComparer.Ordinal), 1504result.OrderBy(item => item.Text, StringComparer.Ordinal));

ViewComponents\DefaultViewComponentSelectorTest.cs (1)

246: base(GetApplicationPartManager(allowedTypes.OrderBy(type => type.Name, StringComparer.Ordinal)))

TestFileProvider.cs (2)

11new Dictionary<string, IFileInfo>(StringComparer.Ordinal); 16new Dictionary<string, TestFileChangeToken>(StringComparer.Ordinal);

Services\OpenApiDocumentService.cs (1)

98StringComparer.Ordinal);

OutputCacheKeyProvider.cs (3)

175Array.Sort(headerValuesArray, StringComparer.Ordinal); 217Array.Sort(queryValueArray, StringComparer.Ordinal); 251Array.Sort(queryValueArray, StringComparer.Ordinal);

RateLimiterOptions.cs (2)

17= new Dictionary<string, DefaultRateLimiterPolicy>(StringComparer.Ordinal); 20= new Dictionary<string, Func<IServiceProvider, DefaultRateLimiterPolicy>>(StringComparer.Ordinal);

TagHelpers\TagHelperAttribute.cs (1)

218hashCode.Add(Name, StringComparer.Ordinal);

Runtime\TagHelpers\TagHelperScopeManagerTest.cs (9)

23Assert.Equal("test-entry", (string)executionContextItem.Key, StringComparer.Ordinal); 40Assert.Equal("test-entry", (string)executionContextItem.Key, StringComparer.Ordinal); 49var parentComplexObject = new Dictionary<string, int>(StringComparer.Ordinal); 59Assert.Equal("test-entry", (string)executionContextItem.Key, StringComparer.Ordinal); 62Assert.Equal("from-child", parentEntry.Key, StringComparer.Ordinal); 80Assert.Equal("test-entry", (string)executionContextItem.Key, StringComparer.Ordinal); 83Assert.Equal("test-entry", (string)parentExecutionContextItem.Key, StringComparer.Ordinal); 100Assert.Equal("new-entry", (string)executionContextItem.Key, StringComparer.Ordinal); 120Assert.Equal("test-entry", (string)parentExecutionContextItem.Key, StringComparer.Ordinal);

TagHelpers\TagHelperContextTest.cs (2)

64Assert.Equal("test-entry", (string)item.Key, StringComparer.Ordinal); 87Assert.Equal("test-entry", (string)item.Key, StringComparer.Ordinal);

TagHelpers\TagHelperOutputTest.cs (3)

1039Assert.Equal(expected, writer.ToString(), StringComparer.Ordinal); 1061Assert.Equal(expected, writer.ToString(), StringComparer.Ordinal); 1087Assert.Equal(expected, writer.ToString(), StringComparer.Ordinal);

ResponseCachingKeyProvider.cs (3)

116Array.Sort(headerValuesArray, StringComparer.Ordinal); 146Array.Sort(queryValueArray, StringComparer.Ordinal); 170Array.Sort(queryValueArray, StringComparer.Ordinal);

ResponseCachingMiddleware.cs (1)

500Array.Sort(newArray, StringComparer.Ordinal);

EndpointNameAddressScheme.cs (2)

38var entries = new Dictionary<string, Endpoint[]>(StringComparer.Ordinal); 71return entries.ToFrozenDictionary(StringComparer.Ordinal);

Matching\DfaMatcherBuilder.cs (1)

124_cachedParameters = new Dictionary<string, IParameterPolicy>(StringComparer.Ordinal);

Matching\HttpMethodMatcherPolicy.cs (1)

489hash.Add(HttpMethod, StringComparer.Ordinal);

PropertyHelperTest.cs (8)

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

78else if (StringComparer.Ordinal.Compare(@interface.FullName, bestMatch.FullName) < 0)

HubConnection.cs (2)

85private readonly ConcurrentDictionary<string, InvocationHandlerList> _handlers = new ConcurrentDictionary<string, InvocationHandlerList>(StringComparer.Ordinal); 2130private readonly Dictionary<string, InvocationRequest> _pendingCalls = new Dictionary<string, InvocationRequest>(StringComparer.Ordinal);

HubConnectionContext.cs (1)

172internal ConcurrentDictionary<string, CancellationTokenSource> ActiveRequestCancellationSources { get; } = new ConcurrentDictionary<string, CancellationTokenSource>(StringComparer.Ordinal);

HubConnectionStore.cs (1)

18new ConcurrentDictionary<string, HubConnectionContext>(StringComparer.Ordinal);

Internal\HubGroupList.cs (1)

12new ConcurrentDictionary<string, GroupConnectionList>(StringComparer.Ordinal);

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

78else if (StringComparer.Ordinal.Compare(@interface.FullName, bestMatch.FullName) < 0)

Protocol\JsonHubProtocol.cs (1)

483var headers = new Dictionary<string, string>(StringComparer.Ordinal);

Protocol\MessagePackHubProtocolWorker.cs (1)

246var headers = new Dictionary<string, string>(StringComparer.Ordinal);

Protocol\NewtonsoftJsonHubProtocol.cs (1)

480var headers = new Dictionary<string, string>(StringComparer.Ordinal);

Internal\RedisSubscriptionManager.cs (1)

10private readonly ConcurrentDictionary<string, HubConnectionStore> _subscriptions = new ConcurrentDictionary<string, HubConnectionStore>(StringComparer.Ordinal);

ServerLogScope.cs (1)

27_serverLoggers = new ConcurrentDictionary<string, ILogger>(StringComparer.Ordinal);

StaticFileContextTest.cs (1)

150private readonly Dictionary<string, IFileInfo> _files = new Dictionary<string, IFileInfo>(StringComparer.Ordinal);

WebSocketMiddleware.cs (2)

43_anyOriginAllowed = _options.AllowedOrigins.Count == 0 || _options.AllowedOrigins.Contains("*", StringComparer.Ordinal); 73if (!_allowedOrigins.Contains(originHeader.ToString(), StringComparer.Ordinal))

BackEnd\Shared\TargetResult.cs (1)

343var interner = new LookasideStringInterner(StringComparer.Ordinal, _items.Length);

Construction\Solution\SolutionFile.cs (1)

133? StringComparer.Ordinal

EscapingUtilities.cs (1)

29private static readonly Dictionary<string, string> s_unescapedToEscapedStrings = new Dictionary<string, string>(StringComparer.Ordinal);

Evaluation\ConditionEvaluator.cs (3)

244_ => new ExpressionTreeForCurrentOptionsWithSize(new ConcurrentDictionary<string, ConcurrentStack<GenericExpressionNode>>(StringComparer.Ordinal))); 320new ConcurrentDictionary<string, ConcurrentStack<GenericExpressionNode>>(StringComparer.Ordinal)), 327new ConcurrentDictionary<string, ConcurrentStack<GenericExpressionNode>>(StringComparer.Ordinal));

Evaluation\Expander.cs (1)

2668return DistinctWithComparer(expander, elementLocation, includeNullEntries, functionName, itemsOfType, arguments, StringComparer.Ordinal);

Evaluation\ItemSpec.cs (2)

580StringComparer comparer = options == MatchOnMetadataOptions.CaseSensitive ? StringComparer.Ordinal : 582StringComparer.Ordinal;

FileUtilities.cs (1)

67internal static readonly StringComparer PathComparer = GetIsFileSystemCaseSensitive() ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase;

Graph\GraphBuilder.cs (1)

267valueComparer: StringComparer.Ordinal);

EscapingUtilities.cs (1)

29private static readonly Dictionary<string, string> s_unescapedToEscapedStrings = new Dictionary<string, string>(StringComparer.Ordinal);

FileUtilities.cs (1)

67internal static readonly StringComparer PathComparer = GetIsFileSystemCaseSensitive() ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase;

BackEnd\BinaryTranslator_Tests.cs (16)

BackEnd\BuildResult_Tests.cs (2)

332Assert.True(TranslationHelpers.CompareCollections(result.DefaultTargets, deserializedResult.DefaultTargets, StringComparer.Ordinal)); 336Assert.True(TranslationHelpers.CompareCollections(result.InitialTargets, deserializedResult.InitialTargets, StringComparer.Ordinal));

BackEnd\LoggingServicesLogMethod_Tests.cs (1)

1299Assert.Equal(expectedEventArgs.Properties.OrderBy(kvp => kvp.Key, StringComparer.Ordinal), actualEventArgs.Properties.OrderBy(kvp => kvp.Key, StringComparer.OrdinalIgnoreCase));

BackEnd\TaskHostConfiguration_Tests.cs (2)

674config.WarningsAsErrors.SequenceEqual(deserializedConfig.WarningsAsErrors, StringComparer.Ordinal).ShouldBeTrue(); 720config.WarningsAsMessages.SequenceEqual(deserializedConfig.WarningsAsMessages, StringComparer.Ordinal).ShouldBeTrue();

Evaluation\ExpressionShredder_Tests.cs (1)

449Assert.Equal(actual, expected, StringComparer.Ordinal);

Graph\ParallelWorkSet_Tests.cs (2)

23new Dictionary<string, string>(StringComparer.Ordinal); 239_workSet = new ParallelWorkSet<string, string>(tt.DegreeOfParallelism, StringComparer.Ordinal, CancellationToken.None);

EscapingUtilities.cs (1)

29private static readonly Dictionary<string, string> s_unescapedToEscapedStrings = new Dictionary<string, string>(StringComparer.Ordinal);

BootstrapperUtil\BootstrapperBuilder.cs (4)

44private readonly Dictionary<string, ProductValidationResults> _validationResults = new Dictionary<string, ProductValidationResults>(StringComparer.Ordinal); 207var eulas = new Dictionary<string, KeyValuePair<string, string>>(StringComparer.Ordinal); 618var availableProducts = new Dictionary<string, Product>(StringComparer.Ordinal); 620var buildQueue = new Dictionary<string, Product>(StringComparer.Ordinal);

BootstrapperUtil\productvalidationresults.cs (1)

17new Dictionary<string, XmlValidationResults>(StringComparer.Ordinal);

EscapingUtilities.cs (1)

29private static readonly Dictionary<string, string> s_unescapedToEscapedStrings = new Dictionary<string, string>(StringComparer.Ordinal);

FileUtilities.cs (1)

67internal static readonly StringComparer PathComparer = GetIsFileSystemCaseSensitive() ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase;

EscapingUtilities.cs (1)

29private static readonly Dictionary<string, string> s_unescapedToEscapedStrings = new Dictionary<string, string>(StringComparer.Ordinal);

FileUtilities.cs (1)

67internal static readonly StringComparer PathComparer = GetIsFileSystemCaseSensitive() ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase;

CommandLine\AnalyzerConfig.cs (1)

311public static IEqualityComparer<string> NameEqualityComparer { get; } = StringComparer.Ordinal;

CommandLine\SarifErrorLogger.cs (1)

106foreach (var pair in diagnostic.Properties.OrderBy(x => x.Key, StringComparer.Ordinal))

Compilation\CompilationOptions.cs (5)

676Hash.Combine(this.CryptoKeyContainer != null ? StringComparer.Ordinal.GetHashCode(this.CryptoKeyContainer) : 0, 677Hash.Combine(this.CryptoKeyFile != null ? StringComparer.Ordinal.GetHashCode(this.CryptoKeyFile) : 0, 680Hash.Combine(this.MainTypeName != null ? StringComparer.Ordinal.GetHashCode(this.MainTypeName) : 0, 683Hash.Combine(this.ModuleName != null ? StringComparer.Ordinal.GetHashCode(this.ModuleName) : 0, 688Hash.Combine(this.ScriptClassName != null ? StringComparer.Ordinal.GetHashCode(this.ScriptClassName) : 0,

Compilation\DeterministicKeyBuilder.cs (2)

463foreach (var key in options.SpecificDiagnosticOptions.Keys.OrderBy(StringComparer.Ordinal)) 526foreach (var key in features.Keys.OrderBy(StringComparer.Ordinal))

Compilation\ParseOptions.cs (2)

145(this.PreprocessorSymbolNames == null ? other.PreprocessorSymbolNames == null : this.PreprocessorSymbolNames.SequenceEqual(other.PreprocessorSymbolNames, StringComparer.Ordinal)); 156Hash.Combine(Hash.CombineValues(this.PreprocessorSymbolNames, StringComparer.Ordinal), 0))));

DiagnosticAnalyzer\AnalyzerAssemblyLoader.cs (2)

56internal static readonly StringComparer OriginalPathComparer = StringComparer.Ordinal; 62internal static readonly StringComparer GeneratedPathComparer = StringComparer.Ordinal;

Emit\AnonymousTypeKey.cs (2)

46(IgnoreCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal).Equals(Name, other.Name); 58(IgnoreCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal).GetHashCode(Name)));

Emit\CommonPEModuleBuilder.cs (1)

815return NestedTypes?.OrderBy(t => t.Name, StringComparer.Ordinal);

Emit\DebugDocumentsBuilder.cs (1)

30StringComparer.Ordinal :

FileSystem\PathUtilities.cs (1)

520var comparer = ignoreCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;

PEWriter\MetadataWriter.PortablePdb.cs (1)

984builder.WriteUTF8(string.Join(",", pair.Aliases.OrderBy(StringComparer.Ordinal)));

ReferenceManager\CommonReferenceManager.State.cs (1)

724return aliases.Length == 0 || aliases.IndexOf(MetadataReferenceProperties.GlobalAlias, StringComparer.Ordinal) >= 0;

SourceFileResolver.cs (3)

144_searchPaths.SequenceEqual(other._searchPaths, StringComparer.Ordinal) && 150return Hash.Combine(_baseDirectory != null ? StringComparer.Ordinal.GetHashCode(_baseDirectory) : 0, 151Hash.Combine(Hash.CombineValues(_searchPaths, StringComparer.Ordinal),

StrongName\DesktopStrongNameProvider.cs (2)

267return Hash.CombineValues(_keyFileSearchPaths, StringComparer.Ordinal); 283if (!_keyFileSearchPaths.SequenceEqual(other._keyFileSearchPaths, StringComparer.Ordinal))

StrongName\StrongNameFileSystem.cs (2)

46=> _signingTempPath != null ? StringComparer.Ordinal.GetHashCode(_signingTempPath) : 0; 56return this.GetType() == other?.GetType() && StringComparer.Ordinal.Equals(_signingTempPath, other?._signingTempPath);

XmlFileResolver.cs (1)

104return _baseDirectory != null ? StringComparer.Ordinal.GetHashCode(_baseDirectory) : 0;

MetaAnalyzers\DiagnosticDescriptorCreationAnalyzer.cs (1)

59StringComparer.Ordinal,

MetaAnalyzers\DiagnosticDescriptorCreationAnalyzer_IdRangeAndCategoryValidation.cs (1)

212StringComparer comparer = StringComparer.Ordinal;

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (1)

488ImmutableHashSet.Create(StringComparer.Ordinal, "Add", "AddOrUpdate", "GetOrAdd", "TryAdd", "TryUpdate");

src\RoslynAnalyzers\Utilities\Compiler\SymbolByDisplayStringComparer.cs (1)

54return StringComparer.Ordinal.Compare(

src\RoslynAnalyzers\Utilities\Compiler\WellKnownTypeProvider.cs (2)

30_fullNameToTypeMap = new ConcurrentDictionary<string, INamedTypeSymbol?>(StringComparer.Ordinal); 80new(StringComparer.Ordinal);

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (1)

488ImmutableHashSet.Create(StringComparer.Ordinal, "Add", "AddOrUpdate", "GetOrAdd", "TryAdd", "TryUpdate");

src\RoslynAnalyzers\Utilities\Compiler\SymbolByDisplayStringComparer.cs (1)

54return StringComparer.Ordinal.Compare(

src\RoslynAnalyzers\Utilities\Compiler\WellKnownTypeProvider.cs (2)

30_fullNameToTypeMap = new ConcurrentDictionary<string, INamedTypeSymbol?>(StringComparer.Ordinal); 80new(StringComparer.Ordinal);

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\PropertySetAnalysis\PropertyMapperCollection.cs (1)

58ImmutableDictionary<string, (int Index, PropertyMapper PropertyMapper)>.Builder builder = ImmutableDictionary.CreateBuilder<string, (int Index, PropertyMapper PropertyMapper)>(StringComparer.Ordinal);

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\TaintedDataAnalysis\PooledHashSetExtensions.cs (8)

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\TaintedDataAnalysis\SanitizerInfo.cs (1)

90hashCode.Add(StringComparer.Ordinal.GetHashCode(this.FullTypeName));

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\TaintedDataAnalysis\SinkInfo.cs (1)

78hashCode.Add(StringComparer.Ordinal.GetHashCode(this.FullTypeName));

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\TaintedDataAnalysis\SourceInfo.cs (1)

206hashCode.Add(StringComparer.Ordinal.GetHashCode(this.FullTypeName));

RestrictedInternalsVisibleToAnalyzer.cs (1)

133var namespaceNameComparer = compilation.IsCaseSensitive ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase;

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (1)

488ImmutableHashSet.Create(StringComparer.Ordinal, "Add", "AddOrUpdate", "GetOrAdd", "TryAdd", "TryUpdate");

src\RoslynAnalyzers\Utilities\Compiler\SymbolByDisplayStringComparer.cs (1)

54return StringComparer.Ordinal.Compare(

src\RoslynAnalyzers\Utilities\Compiler\WellKnownTypeProvider.cs (2)

30_fullNameToTypeMap = new ConcurrentDictionary<string, INamedTypeSymbol?>(StringComparer.Ordinal); 80new(StringComparer.Ordinal);

src\Compilers\Core\Portable\FileSystem\PathUtilities.cs (1)

520var comparer = ignoreCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;

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

590var comparer = caseSensitive ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\StringExtensions.cs (2)

253var caseSensitive = builder.KeyComparer == StringComparer.Ordinal; 254Debug.Assert(builder.KeyComparer == StringComparer.Ordinal || builder.KeyComparer == StringComparer.OrdinalIgnoreCase);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\EditorConfig\EditorConfigNamingStyleParser.cs (1)

60.ThenBy(item => item.title, StringComparer.Ordinal);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\ObjectPools\SharedPools.cs (1)

50new(() => new HashSet<string>(StringComparer.Ordinal), 20);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyComparer.cs (1)

36: StringComparer.Ordinal;

src\Analyzers\Core\CodeFixes\AliasAmbiguousType\AbstractAliasAmbiguousTypeCodeFixProvider.cs (2)

95var comparer = i == 0 && sortSystemFirst ? SortSystemFirstComparer.Instance : StringComparer.Ordinal; 154return StringComparer.Ordinal.Compare(x, y);

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

33syntaxFacts.IsCaseSensitive ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase);

Binder\ImportChain.cs (1)

100aliases.Sort(StringComparer.Ordinal); // Actual order doesn't matter - just want to be deterministic.

Binder\LookupSymbolsInfo.cs (1)

21: base(StringComparer.Ordinal)

Compilation\CSharpDeterministicKeyBuilder.cs (1)

57foreach (var symbol in csharpOptions.PreprocessorSymbols.OrderBy(StringComparer.Ordinal))

CSharpCompilationOptions.cs (2)

744(this.Usings == null ? other.Usings == null : this.Usings.SequenceEqual(other.Usings, StringComparer.Ordinal) && 757Hash.Combine(Hash.CombineValues(this.Usings, StringComparer.Ordinal),

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (1)

198if (StringComparer.Ordinal.Equals(otherModule.Name, module.Name))

SymbolDisplay\SymbolDisplayVisitor.cs (1)

143if (kind is SyntaxKind.None && isNamedTypeOrAliasName && StringComparer.Ordinal.Equals(identifier, "record"))

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

91groups = _moduleSymbol.Module.GroupTypesByNamespaceOrThrow(System.StringComparer.Ordinal);

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

230StringComparer.Ordinal,

Symbols\Source\QuickAttributeChecker.cs (2)

64_nameToAttributeMap = new Dictionary<string, QuickAttributes>(StringComparer.Ordinal); 70_nameToAttributeMap = new Dictionary<string, QuickAttributes>(previous._nameToAttributeMap, StringComparer.Ordinal);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Services\SemanticFacts\CSharpSemanticFacts.cs (1)

137var builder = ImmutableHashSet.CreateBuilder<string>(StringComparer.Ordinal);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Services\SyntaxFacts\CSharpSyntaxFacts.cs (1)

36public StringComparer StringComparer { get; } = StringComparer.Ordinal;

Diagnostics\GetDiagnosticsTests.cs (1)

425], declaredSymbols.OrderBy(name => name, StringComparer.Ordinal));

Diagnostics\Analyzers\TypeSyntaxSimplifierWalker.cs (1)

24StringComparer.Ordinal,

EncapsulateField\CSharpEncapsulateFieldService.cs (1)

198return NameGenerator.GenerateUniqueName(baseName, containingTypeMemberNames.ToSet(), StringComparer.Ordinal);

QuickInfo\CSharpDiagnosticAnalyzerQuickInfoProviderExtensions.cs (1)

33var stringComparer = StringComparer.Ordinal;

CSharpScriptCompiler.cs (1)

26public override StringComparer IdentifierComparer => StringComparer.Ordinal;

Compilation\CompilationAPITests.cs (1)

206StringComparer.Ordinal,

Compilation\SemanticModelGetSemanticInfoTests.cs (140)

Rename\LabelConflictVisitor.cs (1)

19=> _tracker = new ConflictingIdentifierTracker(tokenBeingRenamed, StringComparer.Ordinal);

Rename\LocalConflictVisitor.cs (1)

20=> _tracker = new ConflictingIdentifierTracker(tokenBeingRenamed, StringComparer.Ordinal);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Services\SemanticFacts\CSharpSemanticFacts.cs (1)

137var builder = ImmutableHashSet.CreateBuilder<string>(StringComparer.Ordinal);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Services\SyntaxFacts\CSharpSyntaxFacts.cs (1)

36public StringComparer StringComparer { get; } = StringComparer.Ordinal;

EditorConfigSettings\Updater\NamingStyles\SourceTextExtensions.cs (6)

140StringComparer.Ordinal.Equals(left.Prefix, right.Prefix) && 141StringComparer.Ordinal.Equals(left.Suffix, right.Suffix) && 142StringComparer.Ordinal.Equals(left.WordSeparator, right.WordSeparator) && 149Hash.Combine(StringComparer.Ordinal.GetHashCode(style.Prefix), 150Hash.Combine(StringComparer.Ordinal.GetHashCode(style.Suffix), 151Hash.Combine(StringComparer.Ordinal.GetHashCode(style.WordSeparator),

NavigateTo\NavigateToItemProvider.cs (1)

90=> StartSearch(callback, searchValue, filter.Kinds.ToImmutableHashSet(StringComparer.Ordinal));

SignatureHelp\Controller.Session_UpdateModel.cs (2)

57var comparer = isCaseSensitive ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase; 125var comparer = isCaseSensitive ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase;

Completion\AbstractCompletionProviderTests.cs (1)

428=> StringComparer.Ordinal;

Utilities\BloomFilterTests.cs (2)

47var comparer = isCaseSensitive ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase; 208var comparer = isCaseSensitive ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase;

MetadataResolver.cs (2)

40_stringComparer = ignoreCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal; 283var comparer = _ignoreCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;

AddImport\References\SymbolReference.cs (1)

42return StringComparer.Ordinal.Equals(name1, name2);

CodeRefactorings\SyncNamespace\AbstractSyncNamespaceCodeRefactoringProvider.MoveFileCodeAction.cs (2)

135_childFolders = new Dictionary<string, FolderInfo>(StringComparer.Ordinal); 161var handledFolders = new HashSet<string>(StringComparer.Ordinal);

Completion\FileSystemCompletionHelper.cs (1)

242PathUtilities.IsUnixLikePlatform ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase))

EditAndContinue\EditAndContinueMethodDebugInfoReader.cs (1)

231if (symDocument == null || !StringComparer.Ordinal.Equals(symDocument.GetName(), documentPath))

NavigateTo\NavigateToUtilities.cs (1)

18var result = ImmutableHashSet.CreateBuilder<string>(StringComparer.Ordinal);

src\Analyzers\Core\CodeFixes\AliasAmbiguousType\AbstractAliasAmbiguousTypeCodeFixProvider.cs (2)

95var comparer = i == 0 && sortSystemFirst ? SortSystemFirstComparer.Instance : StringComparer.Ordinal; 154return StringComparer.Ordinal.Compare(x, y);

SymbolSearch\Windows\SymbolSearchUpdateEngine.Update.cs (1)

709if (!StringComparer.Ordinal.Equals(expectedChecksum, actualChecksum))

src\Compilers\Core\Portable\FileSystem\PathUtilities.cs (1)

520var comparer = ignoreCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;

HostWorkspace\FileWatching\LspFileChangeWatcher.cs (1)

67private static readonly StringComparer s_stringComparer = RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase;

HostWorkspace\LoadedProject.cs (2)

307return StringComparer.Ordinal.Equals(x?.FilePath, y?.FilePath); 312return StringComparer.Ordinal.GetHashCode(obj.FilePath);

HostWorkspace\ProjectToLoad.cs (2)

20return StringComparer.Ordinal.Equals(x?.Path, y?.Path); 25return StringComparer.Ordinal.GetHashCode(obj.Path);

Services\ExtensionAssemblyManager.cs (2)

57var directoryLoadContexts = new Dictionary<string, AssemblyLoadContext>(StringComparer.Ordinal); 58var assemblyFullNameToLoadContext = new Dictionary<string, AssemblyLoadContext>(StringComparer.Ordinal);

Protocol\Internal\VSInternalIconMapping.cs (1)

72hashCode = (hashCode * -1521134295) + StringComparer.Ordinal.GetHashCode(this.Tags[i]);

Protocol\Internal\VSInternalKindAndModifier.cs (2)

75hashCode = (hashCode * -1521134295) + (this.Kind == null ? 0 : StringComparer.Ordinal.GetHashCode(this.Kind)); 82hashCode = (hashCode * -1521134295) + StringComparer.Ordinal.GetHashCode(this.Modifier[i]);

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

61var comparer = StringComparer.Ordinal;

DeclarePublicApiAnalyzer.cs (1)

398using var publicApiMap = PooledDictionary<string, ApiLine>.GetInstance(StringComparer.Ordinal);

DeclarePublicApiAnalyzer.Impl.cs (2)

81private readonly ConcurrentDictionary<string, UnusedValue> _visitedApiList = new(StringComparer.Ordinal); 101var publicApiMap = new Dictionary<string, ApiLine>(shippedData.ApiList.Length + unshippedData.ApiList.Length, StringComparer.Ordinal);

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (1)

488ImmutableHashSet.Create(StringComparer.Ordinal, "Add", "AddOrUpdate", "GetOrAdd", "TryAdd", "TryUpdate");

src\RoslynAnalyzers\Utilities\Compiler\SymbolByDisplayStringComparer.cs (1)

54return StringComparer.Ordinal.Compare(

src\RoslynAnalyzers\Utilities\Compiler\WellKnownTypeProvider.cs (2)

30_fullNameToTypeMap = new ConcurrentDictionary<string, INamedTypeSymbol?>(StringComparer.Ordinal); 80new(StringComparer.Ordinal);

DeclarePublicApiFix.cs (1)

389result = StringComparer.Ordinal.Compare(x, y);

ExportProviderBuilder.cs (1)

113assemblyPaths = assemblyPaths.Sort(StringComparer.Ordinal);

AbstractResxGenerator.cs (1)

152foreach (var (resourceName, resourceHintName) in resourceNames.OrderBy(x => x.ResourceName, StringComparer.Ordinal))

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (1)

488ImmutableHashSet.Create(StringComparer.Ordinal, "Add", "AddOrUpdate", "GetOrAdd", "TryAdd", "TryUpdate");

src\RoslynAnalyzers\Utilities\Compiler\SymbolByDisplayStringComparer.cs (1)

54return StringComparer.Ordinal.Compare(

src\RoslynAnalyzers\Utilities\Compiler\WellKnownTypeProvider.cs (2)

30_fullNameToTypeMap = new ConcurrentDictionary<string, INamedTypeSymbol?>(StringComparer.Ordinal); 80new(StringComparer.Ordinal);

Hosting\ObjectFormatter\CommonObjectFormatter.Visitor.cs (1)

348comparisonResult = StringComparer.Ordinal.Compare(x.Name, y.Name);

Mocks\VirtualizedRelativePathResolver.cs (1)

22_existingFullPaths = new HashSet<string>(existingFullPaths, StringComparer.Ordinal);

Platform\CoreClr\TestExecutionLoadContext.cs (1)

32_dependencies = dependencies.ToImmutableDictionary(d => d.FullName, StringComparer.Ordinal);

TargetFrameworkUtil.cs (1)

168private static readonly ConcurrentDictionary<string, ImmutableArray<PortableExecutableReference>> s_dynamicReferenceMap = new ConcurrentDictionary<string, ImmutableArray<PortableExecutableReference>>(StringComparer.Ordinal);

CachingLookupTests.cs (2)

77return numbers.ToLookup(n => GetKey(n, randomCase), StringComparer.Ordinal); 154StringComparer comparer = StringComparer.Ordinal;

Collections\ImmutableSegmentedDictionaryBuilderTest.cs (2)

30builder = ImmutableSegmentedDictionary.CreateBuilder<string, string>(StringComparer.Ordinal); 31Assert.Same(StringComparer.Ordinal, builder.KeyComparer);

Collections\ImmutableSegmentedDictionaryTest.cs (7)

27AddExistingKeySameValueTestHelper(Empty<string, string>(StringComparer.Ordinal), "Company", "Microsoft", "Microsoft"); 33AddExistingKeyDifferentValueTestHelper(Empty<string, string>(StringComparer.Ordinal), "Company", "Microsoft", "MICROSOFT"); 39var map = Empty<string, string>(StringComparer.Ordinal) 54var map = Empty<string, string>(StringComparer.Ordinal) 57var sortedMap = map.ToImmutableSortedDictionary(StringComparer.Ordinal); 364return StringComparer.Ordinal.Equals(x!.Value, y!.Value); 369return StringComparer.Ordinal.GetHashCode(obj.Value);

Collections\ImmutableSegmentedHashSetTest.cs (2)

32ImmutableSegmentedHashSet<string>.Empty.WithComparer(StringComparer.Ordinal), 47.WithComparer(StringComparer.Ordinal)

MetadataReferences\MetadataHelpersTests.cs (5)

433result.Sort(new PEModule.TypesByNamespaceSortComparer(StringComparer.Ordinal)); 447StringComparer.Ordinal, 473result.Sort(new PEModule.TypesByNamespaceSortComparer(StringComparer.Ordinal)); 487StringComparer.Ordinal, 499StringComparer.Ordinal,

CompilationContext.vb (1)

1370sourceMethodMustBeInstance = candidateSubstitutedSourceType.MemberNames.Contains(GeneratedNameConstants.HoistedMeName, StringComparer.Ordinal)

FindSymbols\FindReferences\FindReferenceCache.cs (1)

87LanguageNames.CSharp => StringComparer.Ordinal,

FindSymbols\SearchQuery.cs (1)

36_predicate = s => StringComparer.Ordinal.Equals(name, s);

FindSymbols\SymbolTree\SymbolTreeInfo.cs (4)

203if (StringComparer.Ordinal.Equals(name, node.Name)) 231if (ignoreCase || StringComparer.Ordinal.Equals(name, node.Name)) 387: StringComparer.Ordinal.Compare(s1, s2); 488if (StringComparer.Ordinal.Equals(derivedName, node.Name))

FindSymbols\SymbolTree\SymbolTreeInfo_Source.cs (1)

94var textChecksumsTasks = projectState.DocumentStates.States.Values.OrderBy(state => state.FilePath, StringComparer.Ordinal).Select(async state =>

FindSymbols\SyntaxTree\SyntaxTreeIndex_Create.cs (4)

371Debug.Assert(identifiers.Comparer == StringComparer.Ordinal); 372Debug.Assert(escapedIdentifiers.Comparer == StringComparer.Ordinal); 387Debug.Assert(identifiers.Comparer == StringComparer.Ordinal); 388Debug.Assert(escapedIdentifiers.Comparer == StringComparer.Ordinal);

Shared\Extensions\IFindReferencesResultExtensions.cs (1)

132var comparer = isCaseSensitive ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase;

src\Compilers\Core\Portable\DiagnosticAnalyzer\AnalyzerAssemblyLoader.cs (2)

56internal static readonly StringComparer OriginalPathComparer = StringComparer.Ordinal; 62internal static readonly StringComparer GeneratedPathComparer = StringComparer.Ordinal;

src\Compilers\Core\Portable\FileSystem\PathUtilities.cs (1)

520var comparer = ignoreCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;

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

590var comparer = caseSensitive ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\StringExtensions.cs (2)

253var caseSensitive = builder.KeyComparer == StringComparer.Ordinal; 254Debug.Assert(builder.KeyComparer == StringComparer.Ordinal || builder.KeyComparer == StringComparer.OrdinalIgnoreCase);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\EditorConfig\EditorConfigNamingStyleParser.cs (1)

60.ThenBy(item => item.title, StringComparer.Ordinal);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\ObjectPools\SharedPools.cs (1)

50new(() => new HashSet<string>(StringComparer.Ordinal), 20);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyComparer.cs (1)

36: StringComparer.Ordinal;

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

33syntaxFacts.IsCaseSensitive ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase);

Workspace\ProjectSystem\ProjectSystemProject.cs (1)

202StringComparer.Ordinal,

src\Compilers\Core\Portable\FileSystem\PathUtilities.cs (1)

520var comparer = ignoreCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\ObjectPools\SharedPools.cs (1)

50new(() => new HashSet<string>(StringComparer.Ordinal), 20);

VisualStudioMSBuildWorkspaceTests.cs (1)

3204project.MetadataReferences.Select(r => Path.GetFileName(((PortableExecutableReference)r).FilePath)).OrderBy(StringComparer.Ordinal));

UtilityTest\ImmutableDictionaryExtensionsTests.cs (1)

32var emptyOrdinal = ImmutableDictionary<string, int>.Empty.WithComparers(keyComparer: StringComparer.Ordinal);

TypeRef.cs (1)

61var comparer = StringComparer.Ordinal;

DataFrameColumnCollection.cs (1)

17private readonly Dictionary<string, int> _columnNameToIndexDictionary = new Dictionary<string, int>(StringComparer.Ordinal);

GenerateNuSpec.cs (4)

274orderby fr.ItemSpec, StringComparer.Ordinal 314orderby dependency.Id, StringComparer.Ordinal 326))).OrderBy(s => s?.TargetFramework?.GetShortFolderName(), StringComparer.Ordinal) 344orderby reference.File, StringComparer.Ordinal

Analyzers\AppContextDefaultsAnalyzer.cs (4)

133if (!StringComparer.Ordinal.Equals(methodSym.ContainingType.Name, "LocalAppContext") && 134!StringComparer.Ordinal.Equals(methodSym.ContainingType.Name, "AppContext")) 137if (!StringComparer.Ordinal.Equals(methodSym.ContainingNamespace.Name, "System")) 140if (!StringComparer.Ordinal.Equals(methodSym.Name, "DefineSwitchDefault"))

GenPartialFacadeSourceGenerator.cs (1)

66var dictionary = new Dictionary<string, string>(StringComparer.Ordinal);

src\CreateFrameworkListFile.cs (2)

101.OrderBy(f => f.TargetPath, StringComparer.Ordinal) 102.ThenBy(f => f.Filename, StringComparer.Ordinal))

src\UsageReport\XmlParsingHelpers.cs (2)

34return source.OrderBy(selector, StringComparer.Ordinal); 41return source.ThenBy(selector, StringComparer.Ordinal);

Model\XlfDocument.cs (3)

197if (StringComparer.Ordinal.Compare(newTransUnit.GetId(), transUnit.GetId()) < 0) 231IComparer<string> comparer = StringComparer.Ordinal; 287return new HashSet<string>(untranslatedResourceIDs, StringComparer.Ordinal);

Tasks\EnsureAllResourcesTranslated.cs (1)

26SortedSet<string> untranslatedResourceSet = new(StringComparer.Ordinal);

XlfDocumentTests.cs (3)

488Assert.Contains("Goodbye", untranslatedResources, StringComparer.Ordinal); 489Assert.Contains("Hello", untranslatedResources, StringComparer.Ordinal); 490Assert.DoesNotContain("Apple", untranslatedResources, StringComparer.Ordinal);

AsyncCollectionAssertsTests.cs (1)

442 Assert.Distinct(list, StringComparer.Ordinal);

CollectionAssertsTests.cs (3)

369 var ex = Record.Exception(() => Assert.Contains("HI THERE", set, StringComparer.Ordinal)); 476 Assert.Distinct(list, StringComparer.Ordinal); 606 Assert.DoesNotContain("HI THERE", set, StringComparer.Ordinal);

AlphabeticalOrderer.cs (1)

19result.Sort((x, y) => StringComparer.Ordinal.Compare(x.TestMethod.Method.Name, y.TestMethod.Method.Name));

Functions\AIFunctionArgumentsTests.cs (1)

291var originalDict = new Dictionary<string, object?>(StringComparer.Ordinal)

src\LegacySupport\StringHash\StringHash.cs (1)

23StringComparison.Ordinal => StringComparer.Ordinal,

src\LegacySupport\StringHash\StringHash.cs (1)

23StringComparison.Ordinal => StringComparer.Ordinal,

src\LegacySupport\StringHash\StringHash.cs (1)

23StringComparison.Ordinal => StringComparer.Ordinal,

GetCurrentOpenApiReferenceTest.cs (2)

26var expectedMetadata = new SortedDictionary<string, string>(StringComparer.Ordinal) 48var orderedMetadata = new SortedDictionary<string, string>(StringComparer.Ordinal);

GetOpenApiReferenceMetadataTest.cs (18)

MetadataSerializerTest.cs (8)

111var expectedMetadata = new SortedDictionary<string, string>(StringComparer.Ordinal) 130var orderedMetadata = new SortedDictionary<string, string>(StringComparer.Ordinal); 176var metadata = new SortedDictionary<string, string>(StringComparer.Ordinal) 207var metadata = new SortedDictionary<string, string>(StringComparer.Ordinal) { { "Value", escapedValue } }; 222var metadata = new SortedDictionary<string, string>(StringComparer.Ordinal) { { "Value", "a value" } }; 238var metadata = new SortedDictionary<string, string>(StringComparer.Ordinal) 275var metadata = new SortedDictionary<string, string>(StringComparer.Ordinal) { { "Value", value } }; 298var metadata = new SortedDictionary<string, string>(StringComparer.Ordinal) { { "Value", "a value" } };

EmbeddedFileProviderTests.cs (1)

212Assert.Collection(files.OrderBy(f => f.Name, StringComparer.Ordinal),

PollingWildCardChangeToken.cs (1)

117IOrderedEnumerable<FilePatternMatch> files = result.Files.OrderBy(f => f.Path, StringComparer.Ordinal);

Util\StringComparisonHelper.cs (1)

14StringComparison.Ordinal => StringComparer.Ordinal,

DefaultHttpClientFactory.cs (1)

79_activeHandlers = new ConcurrentDictionary<string, Lazy<ActiveHandlerTrackingEntry>>(StringComparer.Ordinal);

Http\DownstreamDependencyMetadataManager.cs (1)

38_frozenProcessedMetadataMap = ProcessDownstreamDependencyMetadata(dependencyTrieMap).ToFrozenDictionary(StringComparer.Ordinal);

Latency\Internal\HttpRequestLatencyListener.cs (4)

144{ SocketProviderName, socket.ToFrozenDictionary(StringComparer.Ordinal) }, 145{ NameResolutionProivderName, nameResolution.ToFrozenDictionary(StringComparer.Ordinal) }, 146{ HttpProviderName, http.ToFrozenDictionary(StringComparer.Ordinal) } 147}.ToFrozenDictionary(StringComparer.Ordinal);

Logging\Internal\HttpRequestReader.cs (1)

79_defaultSensitiveParameters = options.RouteParameterDataClasses.ToFrozenDictionary(StringComparer.Ordinal);

Internal\HttpKey.cs (2)

16public bool Equals(HttpKey x, HttpKey y) => StringComparer.Ordinal.Equals(x.Name, y.Name); 18public int GetHashCode([DisallowNull] HttpKey obj) => StringComparer.Ordinal.GetHashCode(obj.Name);

LoggerFactory.cs (1)

22private readonly ConcurrentDictionary<string, Logger> _loggers = new ConcurrentDictionary<string, Logger>(StringComparer.Ordinal);

LoggerMessageGenerator.Parser.cs (1)

645HashSet<string> shadowedNames = new(StringComparer.Ordinal);

OptionsCache.cs (1)

18private readonly ConcurrentDictionary<string, Lazy<TOptions>> _cache = new ConcurrentDictionary<string, Lazy<TOptions>>(concurrencyLevel: 1, capacity: 31, StringComparer.Ordinal); // 31 == default capacity

Emitter.cs (1)

620var attributesData = _optionsSourceGenContext.AttributesToGenerate.OrderBy(static kvp => kvp.Key, StringComparer.Ordinal).ToArray();

StringSegmentComparer.cs (1)

18= new StringSegmentComparer(StringComparison.Ordinal, StringComparer.Ordinal);

Latency\Internal\Registry.cs (1)

44_keyOrder = keyOrderBuilder.ToFrozenDictionary(StringComparer.Ordinal);

Logging\ExtendedLoggerFactory.cs (1)

21private readonly Dictionary<string, ExtendedLogger> _loggers = new(StringComparer.Ordinal);

Parsing\Parser.cs (2)

481var names = new HashSet<string>(StringComparer.Ordinal); 643HashSet<string> shadowedNames = new(StringComparer.Ordinal);

Infrastructure\DotNetDispatcher.cs (3)

401var result = new Dictionary<string, (MethodInfo, Type[])>(StringComparer.Ordinal); 438var result = new Dictionary<string, (MethodInfo, Type[])>(StringComparer.Ordinal); 551public override int GetHashCode() => StringComparer.Ordinal.GetHashCode(AssemblyName);

CommandMapper.cs (1)

9 readonly Dictionary<string, Command> _mapper = new(StringComparer.Ordinal);

Fonts\FontRegistrar.cs (3)

13 readonly Dictionary<string, (string Filename, string? Alias, Assembly Assembly)> _embeddedFonts = new(StringComparer.Ordinal); 14 readonly Dictionary<string, (string Filename, string? Alias)> _nativeFonts = new(StringComparer.Ordinal); 15 readonly Dictionary<string, string?> _fontLookupCache = new(StringComparer.Ordinal);

HotReload\HotReloadHelper.cs (2)

117 static Dictionary<string, Type> replacedViews = new(StringComparer.Ordinal); 119 static Dictionary<string, List<KeyValuePair<Type, Type>>> replacedHandlers = new(StringComparer.Ordinal);

LifecycleEvents\LifecycleEventService.cs (1)

9 readonly Dictionary<string, List<Delegate>> _mapper = new(StringComparer.Ordinal);

PropertyMapper.cs (1)

20 protected readonly Dictionary<string, Action<IElementHandler, IElement>> _mapper = new(StringComparer.Ordinal);

WeakEventManager.cs (1)

13 readonly Dictionary<string, List<Subscription>> _eventHandlers = new(StringComparer.Ordinal);

Application\Application.cs (2)

350 var innerKeys = new HashSet<string>(StringComparer.Ordinal); 418 readonly Dictionary<string, WeakReference<Window>> _requestedWindows = new(StringComparer.Ordinal);

AppLinkEntry.cs (1)

15 keyValues = new(StringComparer.Ordinal);

DragAndDrop\DataPackagePropertySet.cs (1)

16 _propertyBag = new(StringComparer.Ordinal);

Internals\NameScope.cs (1)

17 readonly Dictionary<string, object> _names = new(StringComparer.Ordinal);

Registrar.cs (2)

312 internal static Dictionary<string, EffectType> Effects { get; } = new(StringComparer.Ordinal); 359 var properties = new Dictionary<string, IList<StylePropertyAttribute>>(StringComparer.Ordinal);

ResourceDictionary.cs (1)

23 readonly Dictionary<string, object> _innerDictionary = new(StringComparer.Ordinal);

ResourcesExtensions.cs (3)

17 resources = resources ?? new(StringComparer.Ordinal); 36 resources = resources ?? new Dictionary<string, object>(8, StringComparer.Ordinal); 49 resources = resources ?? new(StringComparer.Ordinal);

Routing.cs (3)

13 static Dictionary<string, RouteFactory> s_routes = new(StringComparer.Ordinal); 14 static Dictionary<string, Page> s_implicitPageRoutes = new(StringComparer.Ordinal); 143 keys = new HashSet<string>(StringComparer.Ordinal);

Shell\ShellRouteParameters.cs (1)

105 Dictionary<string, string> lookupDict = new(StringComparer.Ordinal);

StyleSheets\Style.cs (1)

17 public IDictionary<string, string> Declarations { get; set; } = new Dictionary<string, string>(StringComparer.Ordinal);

VisualElement\VisualElement.cs (1)

1550 var innerKeys = new HashSet<string>(StringComparer.Ordinal);

VisualStateManager.cs (1)

156 readonly HashSet<string> _names = new HashSet<string>(StringComparer.Ordinal);

PerformanceProvider.cs (1)

21 readonly Dictionary<string, Statistic> _Statistics = new(StringComparer.Ordinal);

XamlCache.cs (1)

54 GetOrAdd(_resourceNamesInUse, variableDefinition, _ => new HashSet<string>(StringComparer.Ordinal));

XamlServiceProvider.cs (1)

286 readonly Dictionary<string, string> namespaces = new Dictionary<string, string>(StringComparer.Ordinal);

Types\Shared\WebUtils.shared.cs (1)

11 var parameters = new Dictionary<string, string>(StringComparer.Ordinal);

VersionTracking\VersionTracking.shared.cs (2)

241 versionTrail = new(StringComparer.Ordinal) 249 versionTrail = new(StringComparer.Ordinal)

WebAuthenticator\WebAuthenticatorResult.shared.cs (1)

76 public Dictionary<string, string> Properties { get; set; } = new(StringComparer.Ordinal);

Renderer\SimpleCssParser.cs (1)

13 var values = new Dictionary<string, string>(StringComparer.Ordinal);

ResizetizeImages.cs (1)

107 var attr = new Dictionary<string, string>(StringComparer.Ordinal);

TizenResourceXmlGenerator.cs (1)

10 static readonly IDictionary<string, string> resolutionMap = new Dictionary<string, string>(StringComparer.Ordinal)

CodeModel\CSharpCodeModelService.CodeModelEventCollector.cs (11)

CodeModel\CSharpCodeModelService.cs (4)

3609if (StringComparer.Ordinal.Equals(name, ExtenderNames.PartialMethod)) 3627else if (StringComparer.Ordinal.Equals(name, ExtenderNames.ExtensionMethod)) 3649if (StringComparer.Ordinal.Equals(name, ExtenderNames.AutoImplementedProperty)) 3667if (StringComparer.Ordinal.Equals(name, ExtenderNames.ExternalLocation))

EscapingUtilities.cs (1)

29private static readonly Dictionary<string, string> s_unescapedToEscapedStrings = new Dictionary<string, string>(StringComparer.Ordinal);

FileUtilities.cs (1)

67internal static readonly StringComparer PathComparer = GetIsFileSystemCaseSensitive() ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase;

EscapingUtilities.cs (1)

29private static readonly Dictionary<string, string> s_unescapedToEscapedStrings = new Dictionary<string, string>(StringComparer.Ordinal);

FileUtilities.cs (1)

67internal static readonly StringComparer PathComparer = GetIsFileSystemCaseSensitive() ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase;

src\Microsoft.DotNet.Wpf\src\PresentationFramework\System\Windows\Markup\XmlnsCache.cs (1)

87foreach(string assemblyName in _assemblyPathTable.Keys.OfType<string>().OrderBy(s => s, StringComparer.Ordinal))

MS\Internal\AppModel\ResourceContainer.cs (1)

322private static readonly Dictionary<string, ResourceManagerWrapper> s_registeredResourceManagers = new(StringComparer.Ordinal);

System\Windows\ThemeMode.cs (1)

91public override int GetHashCode() => _value != null ? StringComparer.Ordinal.GetHashCode(_value) : 0;

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (1)

488ImmutableHashSet.Create(StringComparer.Ordinal, "Add", "AddOrUpdate", "GetOrAdd", "TryAdd", "TryUpdate");

src\RoslynAnalyzers\Utilities\Compiler\SymbolByDisplayStringComparer.cs (1)

54return StringComparer.Ordinal.Compare(

src\RoslynAnalyzers\Utilities\Compiler\WellKnownTypeProvider.cs (2)

30_fullNameToTypeMap = new ConcurrentDictionary<string, INamedTypeSymbol?>(StringComparer.Ordinal); 80new(StringComparer.Ordinal);

SymbolDeclaredEventMustBeGeneratedForSourceSymbols.cs (1)

156namedType.GetBaseTypesAndThis().Any(b => SymbolTypesWithExpectedSymbolDeclaredEvent.Contains(b.Name, StringComparer.Ordinal)))

Services\SolutionServiceTests.cs (2)

102Assert.Equal(Hash.CombineValues(array, StringComparer.Ordinal), compilationOptions.StrongNameProvider.GetHashCode()); 130Assert.Equal(Hash.CombineValues(array, StringComparer.Ordinal), compilationOptions.StrongNameProvider.GetHashCode());

ConnectionList.cs (1)

12private readonly ConcurrentDictionary<string, ConnectionContext> _connections = new ConcurrentDictionary<string, ConnectionContext>(StringComparer.Ordinal);

ConnectionList.cs (1)

13new ConcurrentDictionary<string, ConnectionContext>(StringComparer.Ordinal);

Microsoft\CSharp\CSharpCodeGenerator.cs (1)

2444var importList = new SortedSet<string>(StringComparer.Ordinal);

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

205(ReferenceEquals(comparer, EqualityComparer<TKey>.Default) || ReferenceEquals(comparer, StringComparer.Ordinal) || ReferenceEquals(comparer, StringComparer.OrdinalIgnoreCase)))

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

136(ReferenceEquals(comparer, EqualityComparer<T>.Default) || ReferenceEquals(comparer, StringComparer.Ordinal) || ReferenceEquals(comparer, StringComparer.OrdinalIgnoreCase)))

System\Collections\Frozen\String\LengthBuckets.cs (1)

19Debug.Assert(comparer == EqualityComparer<string>.Default || comparer == StringComparer.Ordinal || comparer == StringComparer.OrdinalIgnoreCase);

System\Collections\Frozen\String\LengthBucketsFrozenDictionary.cs (1)

23Debug.Assert(comparer == EqualityComparer<string>.Default || comparer == StringComparer.Ordinal || comparer == StringComparer.OrdinalIgnoreCase);

System\Collections\Frozen\String\LengthBucketsFrozenSet.cs (1)

21Debug.Assert(comparer == EqualityComparer<string>.Default || comparer == StringComparer.Ordinal || comparer == StringComparer.OrdinalIgnoreCase);

System\Collections\Frozen\String\OrdinalStringFrozenDictionary.cs (1)

31Debug.Assert(comparer == EqualityComparer<string>.Default || comparer == StringComparer.Ordinal || comparer == StringComparer.OrdinalIgnoreCase);

System\ComponentModel\DataAnnotations\AssociatedMetadataTypeTypeDescriptor.cs (1)

154HashSet<string> buddyTypeMembers = new HashSet<string>(buddyFields.Concat(buddyProperties), StringComparer.Ordinal);

Microsoft\Internal\StringComparers.cs (2)

12get { return StringComparer.Ordinal; } 17get { return StringComparer.Ordinal; }

System\ComponentModel\Composition\ExportAttribute.cs (4)

27/// using <see cref="StringComparer.Ordinal"/>. 58/// using <see cref="StringComparer.Ordinal"/>. 83/// using <see cref="StringComparer.Ordinal"/>. 113/// using <see cref="StringComparer.Ordinal"/>.

System\ComponentModel\Composition\Hosting\ExportProvider.GetExportOverrides.cs (15)

System\ComponentModel\Composition\ImportAttribute.cs (3)

28/// using <see cref="StringComparer.Ordinal"/>. 57/// using <see cref="StringComparer.Ordinal"/>. 81/// using <see cref="StringComparer.Ordinal"/>.

System\ComponentModel\Composition\ImportManyAttribute.cs (3)

28/// using <see cref="StringComparer.Ordinal"/>. 57/// using <see cref="StringComparer.Ordinal"/>. 81/// using <see cref="StringComparer.Ordinal"/>.

System\ComponentModel\Composition\InheritedExportAttribute.cs (4)

26/// using <see cref="StringComparer.Ordinal"/>. 56/// using <see cref="StringComparer.Ordinal"/>. 81/// using <see cref="StringComparer.Ordinal"/>. 111/// using <see cref="StringComparer.Ordinal"/>.

System\ComponentModel\Composition\Primitives\ComposablePart.cs (1)

100/// non-linguistic comparer, such as <see cref="StringComparer.Ordinal"/>,

System\ComponentModel\Composition\Primitives\ComposablePartDefinition.cs (1)

76/// non-linguistic comparer, such as <see cref="StringComparer.Ordinal"/>,

System\ComponentModel\Composition\Primitives\ExportDefinition.cs (1)

108/// non-linguistic comparer, such as <see cref="StringComparer.Ordinal"/>,

System\ComponentModel\Composition\Primitives\ImportDefinition.cs (1)

152/// non-linguistic comparer, such as <see cref="StringComparer.Ordinal"/>,

System\ComponentModel\ComponentResourceManager.cs (1)

235sd = new SortedList<string, object?>(StringComparer.Ordinal);

System\Configuration\ConfigurationSectionCollection.cs (1)

16base(StringComparer.Ordinal)

System\Configuration\ConfigurationSectionGroupCollection.cs (1)

17base(StringComparer.Ordinal)

System\Configuration\ConfigurationValues.cs (1)

16internal ConfigurationValues() : base(StringComparer.Ordinal) { }

System\Configuration\PropertyInformationCollection.cs (1)

12internal PropertyInformationCollection(ConfigurationElement thisElement) : base(StringComparer.Ordinal)

System\Configuration\ProviderSettings.cs (1)

69_propertyNameCollection = new NameValueCollection(StringComparer.Ordinal);

System\TerminalFormatStrings.cs (1)

54public readonly Dictionary<string, ConsoleKeyInfo> KeyFormatToConsoleKey = new(StringComparer.Ordinal);

Common\System\Data\Common\DBConnectionString.cs (7)

352return ((null == _restrictionValues) || (0 > Array.BinarySearch(_restrictionValues, key, StringComparer.Ordinal))); 398if (0 > Array.BinarySearch(preventusage, allowonly[i], StringComparer.Ordinal)) 421if (0 <= Array.BinarySearch(b, a[i], StringComparer.Ordinal)) 454if (0 > Array.BinarySearch(a, b[i], StringComparer.Ordinal)) 460Array.Sort(restrictionValues, StringComparer.Ordinal); 496Array.Sort(restrictions, StringComparer.Ordinal); 539Debug.Assert(0 >= StringComparer.Ordinal.Compare(restrictionValues[i - 1], restrictionValues[i]));

System\Diagnostics\ProcessStartInfo.cs (1)

101OperatingSystem.IsWindows() ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal));

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

55Dictionary<string, int> memberNames = new(StringComparer.Ordinal);

System\Formats\Tar\TarHelpers.Unix.cs (1)

43=> StringComparer.Ordinal.Compare(y, x);

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

1371_ignoredItemDictionary = new Dictionary<string, List<string>>(_dictionaryInitialSize, StringComparer.Ordinal);

System\Net\Cookie.cs (2)

637StringComparer.Ordinal.GetHashCode(Value), 638StringComparer.Ordinal.GetHashCode(Path),

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\NonRandomizedStringEqualityComparer.cs (2)

24private static readonly NonRandomizedStringEqualityComparer WrappedAroundStringComparerOrdinal = new OrdinalComparer(StringComparer.Ordinal); 157if (ReferenceEquals(comparer, StringComparer.Ordinal))

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventSource.cs (1)

5828Array.Sort(sortedStrings, StringComparer.Ordinal);

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\TraceLogging\NameInfo.cs (1)

65int result = StringComparer.Ordinal.Compare(this.name, otherName);

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

14return StringComparer.Ordinal;

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

95unreachableValues ??= new HashSet<string>(StringComparer.Ordinal);

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

44var uniqueValues = new HashSet<string>(values.Length, ignoreCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal); 403uniqueValues ??= new HashSet<string>(1, ignoreCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal) { value };

src\libraries\System.Private.CoreLib\src\System\StringComparer.cs (4)

40StringComparison.Ordinal => Ordinal, 71/// A "well-known ordinal comparer" describes a comparer which behaves identically to <see cref="Ordinal"/> 75/// argument will behave identically to a <see cref="Dictionary{String, TValue}"/> given <see cref="Ordinal"/> 128/// This method returns <see langword="false"/> when given <see cref="Ordinal"/> and other non-linguistic comparers as input.

System\Security\Cryptography\OidLookup.cs (1)

102new Dictionary<string, string>(OidToFriendlyNameCount, StringComparer.Ordinal);

System\Security\Cryptography\X509Certificates\CertificatePolicy.cs (1)

84if (StringComparer.Ordinal.Equals(mapping.IssuerDomainPolicy, oidToCheck))

System\Security\Cryptography\X509Certificates\ManagedCertificateFinder.cs (3)

184if (StringComparer.Ordinal.Equals(templateName, template.TemplateID)) 212if (StringComparer.Ordinal.Equals(oidValue, usageOid.Value)) 325StringComparer.Ordinal.Equals(extensionOid, ext.Oid.Value))

System\Security\Cryptography\X509Certificates\OpenSslCachedSystemStoreProvider.cs (2)

245if (StringComparer.Ordinal.Equals(cert.Subject, cert.Issuer)) 350var set = new HashSet<string>(directories, StringComparer.Ordinal);

System\Security\Cryptography\X509Certificates\OpenSslDirectoryBasedStoreProvider.cs (1)

341if (!StringComparer.Ordinal.Equals(storeName, fileName))

System\Security\Cryptography\X509Certificates\OpenSslX509ChainProcessor.cs (1)

1241if (StringComparer.Ordinal.Equals(description.AccessMethod, recordTypeOid))

System\Security\Cryptography\X509Certificates\X500NameEncoder.cs (2)

160if (StringComparer.Ordinal.Equals(oid.FriendlyName, oidValue) || 594Dictionary<string, EncodingRules> lookup = new(LookupDictionarySize, StringComparer.Ordinal)

System\IdentityModel\Tokens\Saml2AssertionKeyIdentifierClause.cs (2)

32if (keyIdentifierClause is Saml2AssertionKeyIdentifierClause saml2Clause && StringComparer.Ordinal.Equals(assertionId, saml2Clause.Id)) 44if (keyIdentifierClause is SamlAssertionKeyIdentifierClause samlClause && StringComparer.Ordinal.Equals(assertionId, samlClause.Id))

System\IdentityModel\Tokens\SamlAssertionKeyIdentifierClause.cs (1)

33if (keyIdentifierClause is SamlAssertionKeyIdentifierClause samlClause && StringComparer.Ordinal.Equals(assertionId, samlClause.Id))

System\Text\Json\Document\JsonElement.cs (1)

1367Dictionary<string, ValueQueue<JsonElement>> properties2 = new(capacity: remainingProps, StringComparer.Ordinal);

System\Text\Json\Nodes\JsonObject.IDictionary.cs (1)

242: StringComparer.Ordinal;

System\Text\Json\Serialization\Converters\Value\EnumConverter.cs (2)

66_nameCacheForReading = new(StringComparer.Ordinal); 530(enumMemberAttributes ??= new(StringComparer.Ordinal)).Add(field.Name, attribute.Name);

System\Text\Json\Serialization\Metadata\JsonTypeInfo.cs (1)

1049public Dictionary<string, (JsonPropertyInfo, int index)> AddedProperties = new(options.PropertyNameCaseInsensitive ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal);

JsonSourceGenerator.Parser.cs (1)

1029public Dictionary<string, (PropertyGenerationSpec, ISymbol, int index)> AddedProperties = new(options?.PropertyNameCaseInsensitive == true ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal);

RegexGenerator.cs (1)

266foreach (KeyValuePair<string, string[]> helper in requiredHelpers.OrderBy(h => h.Key, StringComparer.Ordinal))

RegexGenerator.Emitter.cs (1)

162AppendHashtableContents(writer, rm.Tree.CaptureNameToNumberMapping.Cast<DictionaryEntry>().OrderBy(de => de.Key as string, StringComparer.Ordinal));

System\Resources\AssemblyNamesTypeResolutionService.cs (1)

80_cachedTypes ??= new(StringComparer.Ordinal);

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

136Array.Sort(actual, StringComparer.Ordinal); 139Array.Sort(expected, StringComparer.Ordinal);

System\Windows\Forms\EmbeddedResourceTests.cs (2)

254Array.Sort(actual, StringComparer.Ordinal); 258Array.Sort(expected, StringComparer.Ordinal);

System\Xaml\Context\NameFixupGraph.cs (1)

43_dependenciesByName = new Dictionary<string, FrugalObjectList<NameFixupToken>>(StringComparer.Ordinal);

System\Xaml\MS\Impl\XmlNsInfo.cs (4)

145else if (StringComparer.Ordinal.Compare(prefix1, prefix2) < 0) 304Dictionary<string, string> result = new Dictionary<string, string>(StringComparer.Ordinal); 357Dictionary<string, string> result = new Dictionary<string, string>(StringComparer.Ordinal); 568return StringComparer.Ordinal.Compare(ns1, ns2);

src\ProjectTemplates\Shared\Project.cs (1)

331Assert.Equal(expectedProfileName, actualProfile.Name, StringComparer.Ordinal);

src\ProjectTemplates\Shared\Project.cs (1)

331Assert.Equal(expectedProfileName, actualProfile.Name, StringComparer.Ordinal);

src\ProjectTemplates\Shared\Project.cs (1)

331Assert.Equal(expectedProfileName, actualProfile.Name, StringComparer.Ordinal);

src\ProjectTemplates\Shared\Project.cs (1)

331Assert.Equal(expectedProfileName, actualProfile.Name, StringComparer.Ordinal);

src\ProjectTemplates\Shared\Project.cs (1)

331Assert.Equal(expectedProfileName, actualProfile.Name, StringComparer.Ordinal);

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (1)

488ImmutableHashSet.Create(StringComparer.Ordinal, "Add", "AddOrUpdate", "GetOrAdd", "TryAdd", "TryUpdate");

src\RoslynAnalyzers\Utilities\Compiler\SymbolByDisplayStringComparer.cs (1)

54return StringComparer.Ordinal.Compare(

src\RoslynAnalyzers\Utilities\Compiler\WellKnownTypeProvider.cs (2)

30_fullNameToTypeMap = new ConcurrentDictionary<string, INamedTypeSymbol?>(StringComparer.Ordinal); 80new(StringComparer.Ordinal);

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (1)

488ImmutableHashSet.Create(StringComparer.Ordinal, "Add", "AddOrUpdate", "GetOrAdd", "TryAdd", "TryUpdate");

src\RoslynAnalyzers\Utilities\Compiler\SymbolByDisplayStringComparer.cs (1)

54return StringComparer.Ordinal.Compare(

src\RoslynAnalyzers\Utilities\Compiler\WellKnownTypeProvider.cs (2)

30_fullNameToTypeMap = new ConcurrentDictionary<string, INamedTypeSymbol?>(StringComparer.Ordinal); 80new(StringComparer.Ordinal);

System\ComponentModel\GroupDescriptionTests.cs (1)

53CustomSort = StringComparer.Ordinal