StringComparer

CaseInsensitiveComparison.cs (1)

87private sealed class OneToOneUnicodeComparer : StringComparer

src\Compilers\Core\Portable\CaseInsensitiveComparison.cs (1)

87private sealed class OneToOneUnicodeComparer : StringComparer

src\Compilers\Core\Portable\CaseInsensitiveComparison.cs (1)

87private sealed class OneToOneUnicodeComparer : StringComparer

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

215public sealed class CultureAwareComparer : StringComparer, IAlternateEqualityComparer<ReadOnlySpan<char>, string?>, ISerializable 323public class OrdinalComparer : StringComparer, IAlternateEqualityComparer<ReadOnlySpan<char>, string?>

DiagnosticAnalyzerRunner.cs (4)

158foreach (var group in allDiagnostics.GroupBy(diagnostic => diagnostic.Id).OrderBy(diagnosticGroup => diagnosticGroup.Key, StringComparer.OrdinalIgnoreCase)) 205.ThenBy(tuple => tuple.Item2.Location.SourceTree?.FilePath, StringComparer.OrdinalIgnoreCase) 430foreach (var pair in telemetryInfoDictionary.OrderBy(x => x.Key.GetType().Name, StringComparer.OrdinalIgnoreCase)) 437foreach (var pair in telemetryInfoDictionary.OrderBy(x => x.Key.GetType().Name, StringComparer.OrdinalIgnoreCase))

Commands\NewCommand.cs (1)

71Dictionary<string, (string TemplateName, string TemplateDescription, Func<string, string> PathDeriver)> validTemplates = new(StringComparer.OrdinalIgnoreCase) {

tests\Aspire.Azure.Security.KeyVault.Tests\MockTransport.cs (2)

78private readonly Dictionary<string, List<string>> _headers = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase); 134private readonly Dictionary<string, List<string>> _headers = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);

MockTransport.cs (2)

78private readonly Dictionary<string, List<string>> _headers = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase); 134private readonly Dictionary<string, List<string>> _headers = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);

Components\Dialogs\SettingsDialog.razor.cs (1)

43_languageOptions = [.. GlobalizationHelpers.LocalizedCultures.OrderBy(c => c.NativeName, StringComparer.InvariantCultureIgnoreCase)];

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

Otlp\Model\ColorGenerator.cs (1)

35_colorIndexByKey = new ConcurrentDictionary<string, Lazy<int>>(StringComparer.OrdinalIgnoreCase);

src\Shared\StringComparers.cs (44)

Dashboard\DashboardLifecycleHook.cs (2)

42private static readonly HashSet<string> s_suppressAutomaticConfigurationCopy = new HashSet<string>(StringComparer.OrdinalIgnoreCase) 362var loggerCache = new ConcurrentDictionary<string, ILogger>(StringComparer.Ordinal);

src\Shared\SecretsStore.cs (1)

94.ToDictionary(i => i.Key, i => i.Value, StringComparer.OrdinalIgnoreCase);

src\Shared\StringComparers.cs (44)

src\Shared\StringComparers.cs (44)

src\Shared\StringComparers.cs (44)

src\Shared\StringComparers.cs (44)

src\Shared\StringComparers.cs (44)

AzureWebPubSubResource.cs (1)

18internal Dictionary<string, AzureWebPubSubHubResource> Hubs { get; } = new(StringComparer.OrdinalIgnoreCase);

DockerComposeServiceResource.cs (1)

23private static readonly HashSet<string> s_shellExecutables = new(StringComparer.OrdinalIgnoreCase)

Extensions\ResourceExtensions.cs (2)

74var processedKeys = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 105var processedKeys = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

src\Shared\StringComparers.cs (44)

src\Shared\StringComparers.cs (44)

src\Shared\StringComparers.cs (44)

src\Shared\StringComparers.cs (44)

src\Shared\StringComparers.cs (44)

src\Shared\StringComparers.cs (44)

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

Utils\StringComparersTests.cs (20)

src\Vendoring\OpenTelemetry.Instrumentation.SqlClient\SqlClientTraceInstrumentationOptions.cs (1)

52private static readonly ConcurrentDictionary<string, SqlConnectionDetails> ConnectionDetailCache = new(StringComparer.OrdinalIgnoreCase);

src\Vendoring\OpenTelemetry.Instrumentation.SqlClient\SqlClientTraceInstrumentationOptions.cs (1)

52private static readonly ConcurrentDictionary<string, SqlConnectionDetails> ConnectionDetailCache = new(StringComparer.OrdinalIgnoreCase);

NuGetUtils.cs (2)

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

Startup.cs (1)

48foreach (var key in vars.Keys.Cast<string>().OrderBy(key => key, StringComparer.OrdinalIgnoreCase))

Startup.cs (1)

59foreach (var key in vars.Keys.Cast<string>().OrderBy(key => key, StringComparer.OrdinalIgnoreCase))

FormatTests\FormattedObject\HashTableTests.cs (2)

66Hashtable hashtable = new(new CustomHashCodeProvider(), StringComparer.OrdinalIgnoreCase) 85Hashtable hashtable = new(new CustomHashCodeProvider(), StringComparer.OrdinalIgnoreCase)

src\Compilers\Core\Portable\InternalUtilities\Hash.cs (2)

140internal static int CombineValues(IEnumerable<string?>? values, StringComparer stringComparer, int maxItemsToHash = int.MaxValue) 165internal static int CombineValues(ImmutableArray<string> values, StringComparer stringComparer, int maxItemsToHash = int.MaxValue)

CompilerNuGetCheckerUtil.cs (2)

57internal static StringComparer PathComparer { get; } = StringComparer.OrdinalIgnoreCase;

ProjectKey.cs (1)

27public static bool operator ==(ProjectKey left, ProjectKey right) => StringComparer.OrdinalIgnoreCase.Equals(left.FilePath, right.FilePath);

FileNameEqualityComparer.cs (2)

14public static readonly StringComparer StringComparer = StringComparer.OrdinalIgnoreCase;

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

784.Select(h => h.Identifier).Distinct().OrderBy(n => n, StringComparer.InvariantCulture).ToArray(); 1568return StringComparer.InvariantCulture.Compare(x.Name, y.Name);

ConfigSchemaEmitter.cs (1)

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

RuntimeSource\Configuration.Binder\ConfigurationBindingGenerator.Parser.cs (1)

682(properties ??= new(StringComparer.OrdinalIgnoreCase))[propertyName] = spec;

PrepareForReadyToRunCompilation.cs (2)

111var exclusionSet = ExcludeList == null || Crossgen2Composite ? null : new HashSet<string>(ExcludeList, StringComparer.OrdinalIgnoreCase); 112var compositeExclusionSet = PublishReadyToRunCompositeExclusions == null || !Crossgen2Composite ? null : new HashSet<string>(PublishReadyToRunCompositeExclusions, StringComparer.OrdinalIgnoreCase);

src\Compilers\Shared\NamedPipeUtil.cs (1)

64StringComparer.OrdinalIgnoreCase.Equals(serverIdentity.name, clientIdentity.name) &&

Startup.cs (1)

39foreach (var key in vars.Keys.Cast<string>().OrderBy(key => key, StringComparer.OrdinalIgnoreCase))

Commands\BaseCommand.cs (1)

465var packageVersionsDictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

GlobalTool.cs (2)

20if (!arguments.Contains("--toolContext", StringComparer.InvariantCultureIgnoreCase) && !arguments.Contains("-tc", StringComparer.InvariantCultureIgnoreCase))

Bootstrapper\SvcutilBootstrapper.cs (1)

71if (this.Options.Project != null && StringComparer.OrdinalIgnoreCase.Compare(this.Options.Project.FileName, SvcutilBootstrapper.ProjectName) == 0)

FrameworkFork\Microsoft.CodeDom\Compiler\TempFiles.cs (1)

58_files = new Hashtable(StringComparer.OrdinalIgnoreCase);

FrameworkFork\Microsoft.CodeDom\Configuration\CodeDomCompilationConfiguration.cs (2)

22_compilerLanguages = new Hashtable(StringComparer.OrdinalIgnoreCase); 23_compilerExtensions = new Hashtable(StringComparer.OrdinalIgnoreCase);

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

3323importList = new SortedList(StringComparer.Ordinal);

FrameworkFork\Microsoft.CodeDom\System\CodeNamespaceImportCollection.cs (2)

26private Hashtable _keys = new Hashtable(StringComparer.OrdinalIgnoreCase); 127_keys = new Hashtable(StringComparer.OrdinalIgnoreCase);

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\Internals\System\Runtime\UrlUtility.cs (1)

487: base(StringComparer.OrdinalIgnoreCase)

FrameworkFork\System.ServiceModel\System\IdentityModel\Claims\ClaimComparer.cs (1)

73s_dnsComparer = new ClaimComparer(StringComparer.OrdinalIgnoreCase);

FrameworkFork\System.ServiceModel\System\IdentityModel\Claims\X509CertificateClaimSet.cs (1)

113else if (StringComparer.OrdinalIgnoreCase.Equals(_certificate.SubjectName.Name, _certificate.IssuerName.Name))

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\HttpRequestMessageExtensionMethods.cs (1)

18internal static HashSet<string> WellKnownContentHeaders = new HashSet<string>(StringComparer.OrdinalIgnoreCase)

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\WebSocketTransportSettings.cs (1)

141&& StringComparer.OrdinalIgnoreCase.Compare(this.SubProtocol, other.SubProtocol) == 0;

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

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

FrameworkFork\System.ServiceModel\System\ServiceModel\EndpointAddress.cs (1)

418return StringComparer.OrdinalIgnoreCase.GetHashCode(uriString);

Metadata\MetadataFileNameManager.cs (3)

45if (!_files.Any((f) => StringComparer.OrdinalIgnoreCase.Compare(f, filePath) == 0)) 211return Uri.TryCreate(filePath1, UriKind.Absolute, out uri1) && Uri.TryCreate(filePath2, UriKind.Absolute, out uri2) && StringComparer.OrdinalIgnoreCase.Compare(uri1.AbsoluteUri, uri2.AbsoluteUri) == 0 || 212Uri.TryCreate(filePath1, UriKind.Relative, out uri1) && Uri.TryCreate(filePath2, UriKind.Relative, out uri2) && StringComparer.OrdinalIgnoreCase.Compare(uri1.ToString(), uri2.ToString()) == 0;

Shared\MSBuildProj.cs (1)

810bool isPackage = StringComparer.OrdinalIgnoreCase.Compare(lib.Type, "package") == 0;

Shared\Options\OptionBase.cs (2)

101return StringComparer.OrdinalIgnoreCase.Compare(this.Name, optionId) == 0 || 102this.Aliases.Any(a => StringComparer.OrdinalIgnoreCase.Compare(a, optionId) == 0);

Shared\Options\OptionValueParser.cs (1)

229if (StringComparer.OrdinalIgnoreCase.Compare(entry.ToString(), value) == 0)

Shared\ProjectDependency.cs (2)

401StringComparer.CurrentCultureIgnoreCase.Compare(this.FullPath, other.FullPath) : 406StringComparer.CurrentCultureIgnoreCase.Compare(this.AssemblyName, other.AssemblyName) :

Shared\ProjectPropertyResolver.cs (2)

200if (StringComparer.OrdinalIgnoreCase.Compare("OutputPath", propertyName) == 0) 215else if (StringComparer.OrdinalIgnoreCase.Compare("TargetPath", propertyName) == 0)

Shared\Utilities\RuntimeEnvironmentHelper.cs (1)

95while (pkgSourcesNode.Elements("add").Any(e => StringComparer.OrdinalIgnoreCase.Compare(e.Attribute("key").Value, feedName) == 0))

Internal\SecretsStore.cs (1)

99.ToDictionary(i => i.Key, i => i.Value, StringComparer.OrdinalIgnoreCase);

Program.cs (1)

213if (fileNamesToExclude.Contains(fileName, StringComparer.OrdinalIgnoreCase))

Program.cs (1)

698foreach (var language in rule.Value.languages.OrderBy(l => l, StringComparer.InvariantCultureIgnoreCase))

Program.cs (1)

12_scenarios = new Dictionary<string, Type>(StringComparer.OrdinalIgnoreCase)

src\Shared\Http2cat\Http2Utilities.cs (1)

130public readonly Dictionary<string, string> _decodedHeaders = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

src\Shared\Http2cat\Http2Utilities.cs (1)

130public readonly Dictionary<string, string> _decodedHeaders = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

src\Shared\Http2cat\Http2Utilities.cs (1)

130public readonly Dictionary<string, string> _decodedHeaders = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

src\Shared\Http2cat\Http2Utilities.cs (1)

130public readonly Dictionary<string, string> _decodedHeaders = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

src\Shared\Http2cat\Http2Utilities.cs (1)

130public readonly Dictionary<string, string> _decodedHeaders = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

src\Shared\Http2cat\Http2Utilities.cs (1)

130public readonly Dictionary<string, string> _decodedHeaders = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

Startup.cs (1)

75foreach (var key in vars.Keys.Cast<string>().OrderBy(key => key, StringComparer.OrdinalIgnoreCase))

Linker\AssemblyResolver.cs (1)

62 public IDictionary<string, AssemblyDefinition> AssemblyCache { get; } = new Dictionary<string, AssemblyDefinition> (StringComparer.OrdinalIgnoreCase);

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

LinkTask.cs (1)

350 HashSet<string> assemblyNames = new HashSet<string> (StringComparer.OrdinalIgnoreCase);

ConditionalWcfTest.cs (1)

18private static Dictionary<string, bool> s_evaluatedConditions = new Dictionary<string, bool>(StringComparer.OrdinalIgnoreCase);

JsonSerializer.cs (1)

32Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

TestProperties.cs (1)

21Dictionary<String, String> properties = new Dictionary<String, String>(StringComparer.OrdinalIgnoreCase);

Http2\Http2ConnectionTests.cs (2)

2432public readonly Dictionary<string, StringValues> Headers = new Dictionary<string, StringValues>(StringComparer.OrdinalIgnoreCase); 5015Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase);

Http2\Http2StreamTests.cs (95)

Http2\Http2TestBase.cs (3)

129protected readonly Dictionary<string, string> _receivedHeaders = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 130protected readonly Dictionary<string, string> _receivedTrailers = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 131protected readonly Dictionary<string, string> _decodedHeaders = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

Http2\Http2WebSocketTests.cs (8)

Http3\Http3StreamTests.cs (42)

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

661public readonly Dictionary<string, string> DecodedHeaders = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

FileUtilities.cs (1)

16StringComparer.OrdinalIgnoreCase);

GenerateFileVersionProps.cs (1)

44var fileVersions = new Dictionary<string, FileVersionData>(StringComparer.OrdinalIgnoreCase);

GenerateTestSharedFrameworkDepsFile.cs (1)

45var ignoredExtensions = new HashSet<string>(StringComparer.OrdinalIgnoreCase)

Http3\Http3RequestTests.cs (1)

893requestHeaders.Add(context.Request.Headers.ToDictionary(k => k.Key, k => k.Value, StringComparer.OrdinalIgnoreCase));

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\CompilationExtensions.cs (2)

46return guids.Contains(WebAppProjectGuidString, StringComparer.OrdinalIgnoreCase) || 47guids.Contains(WebSiteProjectGuidString, StringComparer.OrdinalIgnoreCase);

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

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

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

15private static readonly ImmutableHashSet<string> s_uriWords = ImmutableHashSet.Create(StringComparer.OrdinalIgnoreCase, "uri", "urn", "url");

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

67var ruleIdToComments = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

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\CompilationExtensions.cs (2)

46return guids.Contains(WebAppProjectGuidString, StringComparer.OrdinalIgnoreCase) || 47guids.Contains(WebSiteProjectGuidString, StringComparer.OrdinalIgnoreCase);

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

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

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

15private static readonly ImmutableHashSet<string> s_uriWords = ImmutableHashSet.Create(StringComparer.OrdinalIgnoreCase, "uri", "urn", "url");

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

67var ruleIdToComments = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

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

FakeHttpClient.cs (1)

58.ToDictionary(kvp => kvp.Key, kvp => kvp.Value, StringComparer.OrdinalIgnoreCase);

TestSource.cs (1)

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

Internal\DefaultAntiforgeryTokenGenerator.cs (3)

154var comparer = StringComparer.OrdinalIgnoreCase; 158comparer = StringComparer.Ordinal;

Http\HeaderDictionaryIndexerAnalyzer.cs (1)

77internal static readonly Dictionary<string, string> PropertyMapping = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)

Mvc\DetectAmbiguousActionRoutes.cs (1)

258hashCode ^= StringComparer.OrdinalIgnoreCase.GetHashCode(method);

RouteEmbeddedLanguage\FrameworkParametersCompletionProvider.cs (1)

480private readonly HashSet<string> _names = new(StringComparer.OrdinalIgnoreCase);

RouteEmbeddedLanguage\Infrastructure\EmbeddedLanguageCommentOptions.cs (1)

27.ToDictionary(f => f.Name, f => (TOptions)f.GetValue(null)!, StringComparer.OrdinalIgnoreCase);

RouteEmbeddedLanguage\RoutePatternAnalyzer.cs (1)

71var routeParameterNames = new HashSet<string>(routeUsage.RoutePattern.RouteParameters.Select(p => p.Name), StringComparer.OrdinalIgnoreCase);

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

AuthenticationSchemeProviderTests.cs (1)

303: base(options, new Dictionary<string, AuthenticationScheme>(StringComparer.OrdinalIgnoreCase))

AuthorizationOptions.cs (1)

18private Dictionary<string, Task<AuthorizationPolicy?>> PolicyMap { get; } = new Dictionary<string, Task<AuthorizationPolicy?>>(StringComparer.OrdinalIgnoreCase);

ClaimsAuthorizationRequirement.cs (1)

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

BrowserManager.cs (1)

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

BrowserManagerConfiguration.cs (3)

29new Dictionary<string, BrowserOptions>(StringComparer.OrdinalIgnoreCase); 32new HashSet<string>(StringComparer.OrdinalIgnoreCase); 35new Dictionary<string, BrowserNewContextOptions>(StringComparer.OrdinalIgnoreCase);

PersistentState\ComponentStatePersistenceManager.cs (1)

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

PersistentState\PersistentServicesRegistry.cs (1)

164_underlyingAccessors = new Dictionary<string, (PropertySetter, PropertyGetter)>(StringComparer.OrdinalIgnoreCase);

Reflection\ComponentProperties.cs (4)

118unmatched ??= new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase); 139unmatched ??= new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase); 249propertyNames.Sort(StringComparer.Ordinal); 275_underlyingWriters = new Dictionary<string, PropertySetter>(StringComparer.OrdinalIgnoreCase);

Reflection\MemberAssignment.cs (1)

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

ResourceAssetCollection.cs (2)

29var mappings = new Dictionary<string, ResourceAsset>(StringComparer.OrdinalIgnoreCase); 30var contentSpecificUrls = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

Routing\RouteTableFactory.cs (3)

166public HashSet<string> AllRouteParameterNames { get; set; } = new(StringComparer.OrdinalIgnoreCase); 226var parameterNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 357hashCode.Add(literal.Content, StringComparer.OrdinalIgnoreCase);

src\Http\Routing\src\Patterns\RoutePatternFactory.cs (3)

461updatedDefaults = new Dictionary<string, object?>(defaults.Count, StringComparer.OrdinalIgnoreCase); 602updatedDefaults = new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase); 614parameterPolicyReferences = new Dictionary<string, List<RoutePatternParameterPolicyReference>>(StringComparer.OrdinalIgnoreCase);

src\Http\Routing\src\Patterns\RoutePatternParser.cs (1)

481private readonly HashSet<string> _parameterNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

src\Http\Routing\src\RouteConstraintBuilder.cs (3)

44_constraints = new Dictionary<string, List<IRouteConstraint>>(StringComparer.OrdinalIgnoreCase); 45_optionalParameters = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 54var constraints = new Dictionary<string, IRouteConstraint>(StringComparer.OrdinalIgnoreCase);

src\Http\Routing\src\RouteOptions.cs (1)

104var defaults = new Dictionary<string, Type>(StringComparer.OrdinalIgnoreCase);

src\Http\Routing\src\RouteValueEqualityComparer.cs (2)

52return StringComparer.OrdinalIgnoreCase.GetHashCode(string.Empty); 56return StringComparer.OrdinalIgnoreCase.GetHashCode(stringObj);

src\Http\Routing\src\Tree\UrlMatchingNode.cs (1)

31Literals = new Dictionary<string, UrlMatchingNode>(StringComparer.OrdinalIgnoreCase);

Discovery\PageComponentBuilder.cs (1)

64RouteTemplates.SequenceEqual(other.RouteTemplates!, StringComparer.OrdinalIgnoreCase) &&

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)

src\Shared\PropertyHelper\PropertyHelper.cs (2)

326return new Dictionary<string, object?>(dictionary, StringComparer.OrdinalIgnoreCase); 329dictionary = new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase);

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

Rendering\RenderTreeBuilderTest.cs (10)

HtmlRendering\StaticHtmlRenderer.HtmlWriting.cs (1)

14private static readonly HashSet<string> SelfClosingElements = new HashSet<string>(StringComparer.OrdinalIgnoreCase)

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

JSComponents\JSComponentInterop.cs (1)

202ParameterInfoByName = new(StringComparer.OrdinalIgnoreCase);

Hosting\WebAssemblyHostConfiguration.cs (1)

94var hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

HotReload\MetadataUpdateHandlerInvoker.cs (1)

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

Http\WebAssemblyHttpRequestMessageExtensions.cs (1)

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

Prerendering\WebAssemblyComponentParameterDeserializer.cs (1)

26var parametersDictionary = new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase);

FileExtensionContentTypeProvider.cs (1)

28: this(new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)

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

310internal static readonly StringComparer PathComparer = 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);

Repositories\FileSystemXmlRepositoryTests.cs (1)

79Assert.Equal("valid-friendly-name.xml", fileInfo.Name, StringComparer.OrdinalIgnoreCase);

Repositories\RegistryXmlRepositoryTests.cs (1)

67Assert.Equal("valid-friendly-name", valueName, StringComparer.OrdinalIgnoreCase);

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\LoggingRedactionOptions.cs (4)

59public IDictionary<string, DataClassification> RouteParameterDataClasses { get; set; } = new Dictionary<string, DataClassification>(StringComparer.OrdinalIgnoreCase); 70public IDictionary<string, DataClassification> RequestHeadersDataClasses { get; set; } = new Dictionary<string, DataClassification>(StringComparer.OrdinalIgnoreCase); 81public IDictionary<string, DataClassification> ResponseHeadersDataClasses { get; set; } = new Dictionary<string, DataClassification>(StringComparer.OrdinalIgnoreCase); 101public ISet<string> ExcludePathStartsWith { get; set; } = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

Logging\RequestHeadersLogEnricherOptions.cs (1)

27public IDictionary<string, DataClassification> HeadersDataClasses { get; set; } = new Dictionary<string, DataClassification>(StringComparer.OrdinalIgnoreCase);

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

Internal\GrpcProtocolConstants.cs (1)

15internal static readonly HashSet<string> FilteredHeaders = new HashSet<string>(StringComparer.OrdinalIgnoreCase)

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

HeaderParsingOptions.cs (2)

24public IDictionary<string, StringValues> DefaultValues { get; set; } = new Dictionary<string, StringValues>(StringComparer.OrdinalIgnoreCase); 42public IDictionary<string, int> MaxCachedValuesPerHeader { get; set; } = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);

HeaderPropagationMiddleware.cs (1)

46var headers = _values.Headers ??= new Dictionary<string, StringValues>(StringComparer.OrdinalIgnoreCase);

HeaderPropagationMessageHandlerTest.cs (1)

17State.Headers = new Dictionary<string, StringValues>(StringComparer.OrdinalIgnoreCase);

Internal\HostingMetrics.cs (1)

131}, StringComparer.OrdinalIgnoreCase);

Internal\WebHostOptions.cs (1)

74return HostingStartupAssemblies.Except(HostingStartupExcludeAssemblies, StringComparer.OrdinalIgnoreCase);

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

310internal static readonly StringComparer PathComparer = 311OperatingSystem.IsWindows() ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;

WebHostBuilder.cs (1)

179var assemblyNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

Builder\ApplicationBuilder.cs (2)

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

Features\QueryFeature.cs (3)

136_accumulator = new AdaptiveCapacityDictionary<string, StringValues>(StringComparer.OrdinalIgnoreCase); 163_expandingAccumulator = new AdaptiveCapacityDictionary<string, List<string>>(capacity: 5, StringComparer.OrdinalIgnoreCase); 214return _accumulator ?? new AdaptiveCapacityDictionary<string, StringValues>(0, StringComparer.OrdinalIgnoreCase);

HeaderDictionary.cs (1)

58Store = new Dictionary<string, StringValues>(capacity, StringComparer.OrdinalIgnoreCase);

Internal\RequestCookieCollection.cs (2)

30Store = new AdaptiveCapacityDictionary<string, string>(StringComparer.OrdinalIgnoreCase); 35Store = new AdaptiveCapacityDictionary<string, string>(capacity, StringComparer.OrdinalIgnoreCase);

QueryCollection.cs (1)

60Store = new Dictionary<string, StringValues>(capacity, StringComparer.OrdinalIgnoreCase);

Timeouts\RequestTimeoutOptions.cs (1)

20public IDictionary<string, RequestTimeoutPolicy> Policies { get; } = new Dictionary<string, RequestTimeoutPolicy>(StringComparer.OrdinalIgnoreCase);

HostString.cs (1)

310return (HasValue ? StringComparer.OrdinalIgnoreCase.GetHashCode(_value) : 0);

HttpMethods.cs (1)

193return object.ReferenceEquals(methodA, methodB) || StringComparer.OrdinalIgnoreCase.Equals(methodA, methodB);

HttpProtocol.cs (5)

54return object.ReferenceEquals(Http09, protocol) || StringComparer.OrdinalIgnoreCase.Equals(Http09, protocol); 66return object.ReferenceEquals(Http10, protocol) || StringComparer.OrdinalIgnoreCase.Equals(Http10, protocol); 78return object.ReferenceEquals(Http11, protocol) || StringComparer.OrdinalIgnoreCase.Equals(Http11, protocol); 90return object.ReferenceEquals(Http2, protocol) || StringComparer.OrdinalIgnoreCase.Equals(Http2, protocol); 102return object.ReferenceEquals(Http3, protocol) || StringComparer.OrdinalIgnoreCase.Equals(Http3, protocol);

PathString.cs (1)

423return (HasValue ? StringComparer.OrdinalIgnoreCase.GetHashCode(Value) : 0);

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

Routing\RouteValueDictionary.cs (3)

306/// This will always be a reference to <see cref="StringComparer.OrdinalIgnoreCase"/> 308public IEqualityComparer<string> Comparer => StringComparer.OrdinalIgnoreCase; 900var names = new Dictionary<string, PropertyHelper>(StringComparer.OrdinalIgnoreCase);

src\Shared\PropertyHelper\PropertyHelper.cs (2)

326return new Dictionary<string, object?>(dictionary, StringComparer.OrdinalIgnoreCase); 329dictionary = new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase);

RouteValueDictionaryTests.cs (1)

421Assert.Same(StringComparer.OrdinalIgnoreCase, dict.Comparer);

Internal\HttpConnectionDispatcher.cs (1)

726var requestHeaders = new Dictionary<string, StringValues>(existingRequestFeature.Headers.Count, StringComparer.OrdinalIgnoreCase);

Internal\HttpConnectionManager.cs (1)

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

HttpConnection.cs (1)

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

RequestDelegateFactory.cs (2)

724if (factoryContext.RouteParameters is { } routeParams && !routeParams.Contains(routeName, StringComparer.OrdinalIgnoreCase)) 881if (routeParams.Contains(parameter.Name, StringComparer.OrdinalIgnoreCase))

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

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

src\Shared\ParameterBindingMethodCache.cs (1)

720return StringComparer.OrdinalIgnoreCase.GetHashCode(Name);

AdaptiveCapacityDictionaryBenchmark.cs (6)

39_smallCapDict = new AdaptiveCapacityDictionary<string, string>(capacity: 1, StringComparer.OrdinalIgnoreCase); 40_smallCapDictTen = new AdaptiveCapacityDictionary<string, string>(capacity: 10, StringComparer.OrdinalIgnoreCase); 41_filledSmallDictionary = new AdaptiveCapacityDictionary<string, string>(capacity: 10, StringComparer.OrdinalIgnoreCase); 47_dict = new Dictionary<string, string>(1, StringComparer.OrdinalIgnoreCase); 48_dictTen = new Dictionary<string, string>(10, StringComparer.OrdinalIgnoreCase); 49_filledDictTen = new Dictionary<string, string>(10, StringComparer.OrdinalIgnoreCase);

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;

StaticRouteHandlerModel\Model\ParameterLookupKey.cs (1)

23return StringComparer.OrdinalIgnoreCase.GetHashCode(Name);

DefaultHttpContextTests.cs (1)

450= new Dictionary<string, byte[]>(StringComparer.OrdinalIgnoreCase);

HeaderDictionaryTests.cs (4)

24new Dictionary<string, StringValues>(StringComparer.OrdinalIgnoreCase) 44new Dictionary<string, StringValues>(StringComparer.OrdinalIgnoreCase) 59new Dictionary<string, StringValues>(StringComparer.OrdinalIgnoreCase) 72new Dictionary<string, StringValues>(StringComparer.OrdinalIgnoreCase)

HttpLoggingOptions.cs (2)

32internal HashSet<string> _internalRequestHeaders = new HashSet<string>(26, StringComparer.OrdinalIgnoreCase) 71internal HashSet<string> _internalResponseHeaders = new HashSet<string>(19, StringComparer.OrdinalIgnoreCase)

W3CLoggerOptions.cs (2)

115public ISet<string> AdditionalRequestHeaders { get; } = new SortedSet<string>(StringComparer.OrdinalIgnoreCase); 128var clonedSet = new SortedSet<string>(options.AdditionalRequestHeaders, StringComparer.InvariantCultureIgnoreCase);

src\Identity\test\Shared\PriorityOrderer.cs (1)

62list.Sort((x, y) => StringComparer.OrdinalIgnoreCase.Compare(x.TestMethod.Method.Name, y.TestMethod.Method.Name));

Pages\Account\ExternalLogin.cs (1)

46Assert.Equal(RegisterConfirmation.Path + "?email=" + email, redirect.ToString(), StringComparer.OrdinalIgnoreCase);

src\Identity\test\Shared\PriorityOrderer.cs (1)

62list.Sort((x, y) => StringComparer.OrdinalIgnoreCase.Compare(x.TestMethod.Method.Name, y.TestMethod.Method.Name));

src\Identity\test\Shared\PriorityOrderer.cs (1)

62list.Sort((x, y) => StringComparer.OrdinalIgnoreCase.Compare(x.TestMethod.Method.Name, y.TestMethod.Method.Name));

Tracing\CollectingEventListener.cs (1)

17private readonly Dictionary<string, EventSource> _existingSources = new Dictionary<string, EventSource>(StringComparer.OrdinalIgnoreCase);

AlphabeticalOrderer.cs (1)

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

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)

Abstractions\ActionDescriptor.cs (1)

22RouteValues = new Dictionary<string, string?>(StringComparer.OrdinalIgnoreCase);

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)

src\Shared\ParameterBindingMethodCache.cs (1)

720return StringComparer.OrdinalIgnoreCase.GetHashCode(Name);

DefaultApiDescriptionProvider.cs (1)

240var routeParameters = new Dictionary<string, ApiParameterRouteInfo>(StringComparer.OrdinalIgnoreCase);

ApplicationModels\ActionModel.cs (2)

38RouteValues = new Dictionary<string, string?>(StringComparer.OrdinalIgnoreCase); 62RouteValues = new Dictionary<string, string?>(other.RouteValues, StringComparer.OrdinalIgnoreCase);

ApplicationModels\ApplicationModelFactory.cs (3)

61var actionsByRouteName = new Dictionary<string, List<(ActionModel, SelectorModel)>>(StringComparer.OrdinalIgnoreCase); 131var routeValues = new Dictionary<string, string?>(StringComparer.OrdinalIgnoreCase) 308formattedVerbs = string.Join(", ", verbs.OrderBy(v => v, StringComparer.OrdinalIgnoreCase));

ApplicationModels\AttributeRouteModel.cs (1)

415string.Join(", ", values.Keys.OrderBy(k => k, StringComparer.OrdinalIgnoreCase)));

ApplicationModels\ControllerActionDescriptorProvider.cs (1)

52var keys = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

ApplicationModels\ControllerModel.cs (2)

39RouteValues = new Dictionary<string, string?>(StringComparer.OrdinalIgnoreCase); 60RouteValues = new Dictionary<string, string?>(other.RouteValues, StringComparer.OrdinalIgnoreCase);

ApplicationModels\DefaultApplicationModelProvider.cs (1)

668.Distinct(StringComparer.OrdinalIgnoreCase)

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

Formatters\FormatterMappings.cs (1)

16new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

Infrastructure\ActionSelectionTable.cs (1)

113var routeKeys = new SortedSet<string>(StringComparer.OrdinalIgnoreCase);

Infrastructure\ControllerActionInvoker.cs (1)

73_arguments = new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase);

Infrastructure\StringArrayComparer.cs (4)

8public static readonly StringArrayComparer Ordinal = new StringArrayComparer(StringComparer.Ordinal); 10public static readonly StringArrayComparer OrdinalIgnoreCase = new StringArrayComparer(StringComparer.OrdinalIgnoreCase); 12private readonly StringComparer _valueComparer; 14private StringArrayComparer(StringComparer valueComparer)

ModelBinding\Binders\DictionaryModelBinder.cs (1)

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

ModelBinding\CompositeValueProvider.cs (1)

141return new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

ModelBinding\FormValueProvider.cs (1)

39_invariantValueKeys = new(invariantKeys, StringComparer.OrdinalIgnoreCase);

ModelBinding\JQueryFormValueProvider.cs (1)

32_invariantValueKeys = new(invariantKeys, StringComparer.OrdinalIgnoreCase);

ModelBinding\JQueryKeyValuePairNormalizer.cs (1)

22StringComparer.OrdinalIgnoreCase);

ModelBinding\PrefixContainer.cs (2)

38Array.Sort(_sortedValues, StringComparer.OrdinalIgnoreCase); 77var result = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

MvcOptions.cs (1)

40CacheProfiles = new Dictionary<string, CacheProfile>(StringComparer.OrdinalIgnoreCase);

Routing\AttributeRoute.cs (2)

145var templateCache = new Dictionary<string, RouteTemplate>(StringComparer.OrdinalIgnoreCase); 282hash.Add(obj.RouteTemplate!.TemplateText, StringComparer.OrdinalIgnoreCase);

Routing\ControllerActionEndpointDataSource.cs (2)

74var keys = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 79var routeNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

Routing\KnownRouteValueConstraint.cs (1)

98var values = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

SerializableError.cs (1)

20: base(StringComparer.OrdinalIgnoreCase)

src\Shared\PropertyHelper\PropertyHelper.cs (2)

326return new Dictionary<string, object?>(dictionary, StringComparer.OrdinalIgnoreCase); 329dictionary = new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase);

ValidationProblemDetails.cs (1)

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

ApplicationModels\AttributeRouteModelTests.cs (30)

ApplicationModels\ControllerActionDescriptorProviderTests.cs (13)

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)

Formatters\JsonOutputFormatterTestBase.cs (1)

105Assert.Equal(expectedContent, actualContent, StringComparer.OrdinalIgnoreCase);

Infrastructure\ActionSelectionTableTest.cs (25)

Infrastructure\ActionSelectorTest.cs (20)

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

70var dictionary = new Dictionary<string, string>(StringComparer.Ordinal) 119var values = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);

ModelBinding\ModelBinderFactoryTest.cs (1)

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

ModelBinding\PrefixContainerTest.cs (3)

210Assert.Collection(result.OrderBy(k => k.Key, StringComparer.OrdinalIgnoreCase), 253Assert.Collection(result.OrderBy(k => k.Key, StringComparer.OrdinalIgnoreCase), 287Assert.Collection(result.OrderBy(k => k.Key, StringComparer.OrdinalIgnoreCase),

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

Routing\AttributeRouteTest.cs (10)

Routing\AttributeRoutingTest.cs (2)

119action.RouteValues = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) 152RouteValues = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase),

Routing\ControllerActionEndpointDataSourceTest.cs (13)

Routing\DynamicControllerEndpointMatcherPolicyTest.cs (3)

22RouteValues = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) 30RouteValues = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) 38RouteValues = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)

SimpleValueProvider.cs (1)

18: base(StringComparer.OrdinalIgnoreCase)

AntiforgeryAuthTests.cs (2)

39Assert.Equal("/Home/Login", response.Headers.Location.AbsolutePath, StringComparer.OrdinalIgnoreCase); 51Assert.Equal("/Home/Login", response.Headers.Location.AbsolutePath, StringComparer.OrdinalIgnoreCase);

RoutingTestsBase.cs (3)

273new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase) 297new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase) 331new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase)

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

53return new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase); 59StringComparer.OrdinalIgnoreCase); 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)

src\Mvc\Mvc.Core\test\Formatters\JsonOutputFormatterTestBase.cs (1)

105Assert.Equal(expectedContent, actualContent, StringComparer.OrdinalIgnoreCase);

ApplicationParts\RazorCompiledItemFeatureProvider.cs (2)

23.GroupBy(i => i.Identifier, StringComparer.OrdinalIgnoreCase) 67_hotReloadedViews ??= new(StringComparer.Ordinal);

Compilation\DefaultViewCompiler.cs (2)

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

RazorPage.cs (4)

15private readonly HashSet<string> _renderedSections = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 200_ignoredSections = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 216StringComparer.OrdinalIgnoreCase); 221sectionsNotIgnored = sectionsNotRendered.Except(_ignoredSections, StringComparer.OrdinalIgnoreCase).ToArray();

RazorPageBase.cs (1)

28private readonly IDictionary<string, RenderAsyncDelegate> _sectionWriters = new Dictionary<string, RenderAsyncDelegate>(StringComparer.OrdinalIgnoreCase);

RazorViewEngine.cs (1)

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

TagHelpers\UrlResolutionTagHelper.cs (1)

58new(StringComparer.OrdinalIgnoreCase)

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

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

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)

ApplicationModels\CompiledPageRouteModelProvider.cs (1)

54var visited = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

ApplicationModels\PageRouteModel.cs (2)

39RouteValues = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 57RouteValues = new Dictionary<string, string>(other.RouteValues, StringComparer.OrdinalIgnoreCase);

Infrastructure\CompiledPageActionDescriptorProvider.cs (1)

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

Infrastructure\DefaultPageLoader.cs (1)

68routeNames: new HashSet<string>(StringComparer.OrdinalIgnoreCase),

Infrastructure\PageActionEndpointDataSource.cs (1)

53var routeNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

Infrastructure\PageActionInvoker.cs (1)

423_arguments = new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase);

Infrastructure\DynamicPageEndpointMatcherPolicyTest.cs (2)

22RouteValues = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) 30RouteValues = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)

Infrastructure\PageActionEndpointDataSourceTest.cs (6)

29RouteValues = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) 61RouteValues = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) 105RouteValues = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) 118RouteValues = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) 183RouteValues = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) 225RouteValues = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)

AnchorTagHelper.cs (1)

143_routeValues = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

Cache\CacheTagKey.cs (4)

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

ComponentTagHelper.cs (1)

43_parameters ??= new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);

FormActionTagHelper.cs (1)

159_routeValues = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

FormTagHelper.cs (1)

128_routeValues = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

InputTagHelper.cs (5)

23new(StringComparer.OrdinalIgnoreCase) 57new(StringComparer.Ordinal) 216htmlAttributes = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase) 418htmlAttributes = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase); 460htmlAttributes = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);

JavaScriptResources.cs (1)

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

OptionTagHelper.cs (1)

93var allValues = new HashSet<string>(currentValues.Values, StringComparer.OrdinalIgnoreCase);

SelectTagHelper.cs (1)

139htmlAttributes = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase)

TagHelperOutputExtensions.cs (1)

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

TextAreaTagHelper.cs (1)

77htmlAttributes = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase)

ValidationMessageTagHelper.cs (1)

67htmlAttributes = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase)

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)

TagHelperOutputExtensionsTest.cs (7)

641new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) 656new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) 671new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) 686new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) 701new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) 716new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) 737new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)

TestableHtmlGenerator.cs (1)

35validationAttributes: new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase))

WebApplicationFactory.cs (1)

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

AttributeDictionary.cs (1)

133var compare = StringComparer.OrdinalIgnoreCase.Compare(Get(pivot).Key, key);

CookieTempDataProvider.cs (1)

94return new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);

DefaultEditorTemplates.cs (1)

179var htmlAttributes = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase)

DefaultHtmlGenerator.cs (1)

971var currentValues = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

FormContext.cs (3)

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

HtmlHelper.cs (2)

161return new Dictionary<string, object>(dictionary, StringComparer.OrdinalIgnoreCase); 164dictionary = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);

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

Rendering\MultiSelectList.cs (1)

150var selectedValues = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

SessionStateTempDataProvider.cs (1)

43return new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);

TempDataDictionary.cs (4)

141? new Dictionary<string, object?>(providerDictionary, StringComparer.OrdinalIgnoreCase) 142: new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase); 143_initialKeys = new HashSet<string>(_data.Keys, StringComparer.OrdinalIgnoreCase); 144_retainedKeys = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

TemplateRenderer.cs (2)

23new Dictionary<string, Func<IHtmlHelper, IHtmlContent>>(StringComparer.OrdinalIgnoreCase) 38new Dictionary<string, Func<IHtmlHelper, IHtmlContent>>(StringComparer.OrdinalIgnoreCase)

ViewComponents\DefaultViewComponentHelper.cs (1)

119return new Dictionary<string, object?>(capacity: 1, comparer: StringComparer.OrdinalIgnoreCase)

ViewDataDictionary.cs (2)

119data: new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase), 181data: new CopyOnWriteDictionary<string, object?>(source, StringComparer.OrdinalIgnoreCase),

CookieTempDataProviderTest.cs (1)

341private readonly Dictionary<string, CookieInfo> _cookies = new Dictionary<string, CookieInfo>(StringComparer.OrdinalIgnoreCase);

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

56private static readonly FrozenSet<string> _disallowedHeaderParameters = new[] { HeaderNames.Accept, HeaderNames.Authorization, HeaderNames.ContentType }.ToFrozenSet(StringComparer.OrdinalIgnoreCase); 98StringComparer.Ordinal);

src\Shared\ParameterBindingMethodCache.cs (1)

720return StringComparer.OrdinalIgnoreCase.GetHashCode(Name);

OutputCacheEntryFormatter.cs (2)

503}, StringComparer.OrdinalIgnoreCase); 520return FrozenDictionary.ToFrozenDictionary(pairs, StringComparer.OrdinalIgnoreCase);

OutputCacheKeyProvider.cs (7)

175Array.Sort(headerValuesArray, StringComparer.Ordinal); 217Array.Sort(queryValueArray, StringComparer.Ordinal); 251Array.Sort(queryValueArray, StringComparer.Ordinal); 349Array.Sort(newArray, StringComparer.OrdinalIgnoreCase); 356private readonly StringComparer _stringComparer; 358public static QueryKeyComparer OrdinalIgnoreCase { get; } = new QueryKeyComparer(StringComparer.OrdinalIgnoreCase); 360public QueryKeyComparer(StringComparer stringComparer)

OutputCacheOptions.cs (2)

55NamedPolicies ??= new Dictionary<string, IOutputCachePolicy>(StringComparer.OrdinalIgnoreCase); 77NamedPolicies ??= new Dictionary<string, IOutputCachePolicy>(StringComparer.OrdinalIgnoreCase);

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

RequestDecompressionOptions.cs (1)

14public IDictionary<string, IDecompressionProvider> DecompressionProviders { get; } = new Dictionary<string, IDecompressionProvider>(StringComparer.OrdinalIgnoreCase)

ResponseCachingKeyProvider.cs (6)

116Array.Sort(headerValuesArray, StringComparer.Ordinal); 146Array.Sort(queryValueArray, StringComparer.Ordinal); 170Array.Sort(queryValueArray, StringComparer.Ordinal); 195private readonly StringComparer _stringComparer; 197public static QueryKeyComparer OrdinalIgnoreCase { get; } = new QueryKeyComparer(StringComparer.OrdinalIgnoreCase); 199public QueryKeyComparer(StringComparer stringComparer)

ResponseCachingMiddleware.cs (1)

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

ResponseCompressionProvider.cs (3)

62_mimeTypes = new HashSet<string>(mimeTypes, StringComparer.OrdinalIgnoreCase); 66StringComparer.OrdinalIgnoreCase 290return StringComparer.OrdinalIgnoreCase.GetHashCode(EncodingName);

ApacheModRewrite\FlagParser.cs (1)

8private static readonly IDictionary<string, FlagType> _ruleFlagLookup = new Dictionary<string, FlagType>(StringComparer.OrdinalIgnoreCase) {

Constraints\HttpMethodRouteConstraint.cs (2)

49return AllowedMethods.Contains(httpContext.Request.Method, StringComparer.OrdinalIgnoreCase); 70return AllowedMethods.Contains(Convert.ToString(obj, CultureInfo.InvariantCulture), StringComparer.OrdinalIgnoreCase);

DecisionTree\DecisionTreeBuilder.cs (3)

103var criteria = new Dictionary<string, Criterion>(StringComparer.OrdinalIgnoreCase); 200CurrentCriteria = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 206CurrentCriteria = new HashSet<string>(other.CurrentCriteria, StringComparer.OrdinalIgnoreCase);

DefaultLinkParser.cs (1)

89var constraints = new Dictionary<string, List<IRouteConstraint>>(StringComparer.OrdinalIgnoreCase);

EndpointNameAddressScheme.cs (2)

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

Matching\AcceptsMatcherPolicy.cs (1)

150var edges = new Dictionary<string, List<Endpoint>>(StringComparer.OrdinalIgnoreCase);

Matching\ContentEncodingNegotiationMatcherPolicy.cs (1)

70_extraDestinations ??= new Dictionary<string, (int destination, double quality)>(StringComparer.OrdinalIgnoreCase);

Matching\DfaMatcherBuilder.cs (2)

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

Matching\DfaNode.cs (1)

52Literals = new Dictionary<string, DfaNode>(StringComparer.OrdinalIgnoreCase);

Matching\DictionaryJumpTable.cs (1)

25_dictionary = entries.ToFrozenDictionary(e => e.text, e => e.destination, StringComparer.OrdinalIgnoreCase);

Matching\HttpMethodDestinationsLookup.cs (1)

81_extraDestinations ??= new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);

Matching\HttpMethodMatcherPolicy.cs (4)

133methods = methods ?? new HashSet<string>(StringComparer.OrdinalIgnoreCase); 152httpContext.SetEndpoint(CreateRejectionEndpoint(methods?.OrderBy(m => m, StringComparer.OrdinalIgnoreCase))); 222allHttpMethods.Sort(StringComparer.OrdinalIgnoreCase); 489hash.Add(HttpMethod, StringComparer.Ordinal);

Matching\NegotiationMatcherPolicy.cs (1)

233var edges = new Dictionary<string, List<Endpoint>>(StringComparer.OrdinalIgnoreCase);

Patterns\RoutePatternFactory.cs (6)

461updatedDefaults = new Dictionary<string, object?>(defaults.Count, StringComparer.OrdinalIgnoreCase); 602updatedDefaults = new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase); 614parameterPolicyReferences = new Dictionary<string, List<RoutePatternParameterPolicyReference>>(StringComparer.OrdinalIgnoreCase); 653updatedParameterPolicies = new Dictionary<string, List<RoutePatternParameterPolicyReference>>(parameterPolicies.Count, StringComparer.OrdinalIgnoreCase); 1050var combinedDictionary = new Dictionary<string, TValue>(leftDictionary.Count + rightDictionary.Count, StringComparer.OrdinalIgnoreCase); 1073var parameterNameSet = new HashSet<string>(parameterCount, StringComparer.OrdinalIgnoreCase);

Patterns\RoutePatternParser.cs (1)

481private readonly HashSet<string> _parameterNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

RouteCollection.cs (1)

22new Dictionary<string, INamedRouter>(StringComparer.OrdinalIgnoreCase);

RouteConstraintBuilder.cs (3)

44_constraints = new Dictionary<string, List<IRouteConstraint>>(StringComparer.OrdinalIgnoreCase); 45_optionalParameters = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 54var constraints = new Dictionary<string, IRouteConstraint>(StringComparer.OrdinalIgnoreCase);

RouteOptions.cs (1)

104var defaults = new Dictionary<string, Type>(StringComparer.OrdinalIgnoreCase);

RouteValueEqualityComparer.cs (2)

52return StringComparer.OrdinalIgnoreCase.GetHashCode(string.Empty); 56return StringComparer.OrdinalIgnoreCase.GetHashCode(stringObj);

RouteValuesAddressScheme.cs (2)

73var namedOutboundMatchResults = new Dictionary<string, List<OutboundMatchResult>>(StringComparer.OrdinalIgnoreCase); 143namedOutboundMatchResults.ToFrozenDictionary(StringComparer.OrdinalIgnoreCase));

src\Shared\PropertyHelper\PropertyHelper.cs (2)

326return new Dictionary<string, object?>(dictionary, StringComparer.OrdinalIgnoreCase); 329dictionary = new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase);

Tree\LinkGenerationDecisionTree.cs (1)

176var results = new Dictionary<string, DecisionCriterionValue>(StringComparer.OrdinalIgnoreCase);

Tree\TreeRouter.cs (1)

88_namedEntries = new Dictionary<string, OutboundMatch>(StringComparer.OrdinalIgnoreCase);

Tree\UrlMatchingNode.cs (1)

31Literals = new Dictionary<string, UrlMatchingNode>(StringComparer.OrdinalIgnoreCase);

src\Shared\PropertyHelper\PropertyHelper.cs (2)

326return new Dictionary<string, object?>(dictionary, StringComparer.OrdinalIgnoreCase); 329dictionary = new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase);

DecisionTreeBuilderTest.cs (1)

198Criteria = new Dictionary<string, DecisionCriterionValue>(StringComparer.OrdinalIgnoreCase);

src\Shared\HttpSys\NativeInterop\HttpApiTypes.cs (1)

58return headerNames.ToFrozenDictionary(s => s, _ => index++, StringComparer.OrdinalIgnoreCase);

src\Shared\HttpSys\RequestProcessing\HeaderCollection.cs (2)

19internal static readonly HashSet<string> DisallowedTrailers = new HashSet<string>(StringComparer.OrdinalIgnoreCase) 51: this(new Dictionary<string, StringValues>(4, StringComparer.OrdinalIgnoreCase))

src\Shared\HttpSys\RequestProcessing\RequestHeaders.cs (1)

36var newDict = new Dictionary<string, StringValues>(StringComparer.OrdinalIgnoreCase);

UrlPrefix.cs (1)

200return StringComparer.OrdinalIgnoreCase.GetHashCode(FullPrefix);

AuthenticationTests.cs (3)

58Assert.Equal(authType.ToString(), response.Headers.WwwAuthenticate.ToString(), StringComparer.OrdinalIgnoreCase); 80Assert.Equal(authType.ToString(), response.Headers.WwwAuthenticate.ToString(), StringComparer.OrdinalIgnoreCase); 106Assert.Equal("Negotiate, NTLM, basic", response.Headers.WwwAuthenticate.ToString(), StringComparer.OrdinalIgnoreCase);

Listener\AuthenticationOnExistingQueueTests.cs (3)

88Assert.Equal(authType.ToString(), response.Headers.WwwAuthenticate.ToString(), StringComparer.OrdinalIgnoreCase); 112Assert.Equal(authType.ToString(), response.Headers.WwwAuthenticate.ToString(), StringComparer.OrdinalIgnoreCase); 137Assert.Equal("Negotiate, NTLM, basic", response.Headers.WwwAuthenticate.ToString(), StringComparer.OrdinalIgnoreCase);

src\Shared\Http2cat\Http2Utilities.cs (1)

130public readonly Dictionary<string, string> _decodedHeaders = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

src\Shared\HttpSys\NativeInterop\HttpApiTypes.cs (1)

58return headerNames.ToFrozenDictionary(s => s, _ => index++, StringComparer.OrdinalIgnoreCase);

src\Shared\HttpSys\RequestProcessing\HeaderCollection.cs (2)

19internal static readonly HashSet<string> DisallowedTrailers = new HashSet<string>(StringComparer.OrdinalIgnoreCase) 51: this(new Dictionary<string, StringValues>(4, StringComparer.OrdinalIgnoreCase))

src\Shared\HttpSys\RequestProcessing\RequestHeaders.cs (1)

36var newDict = new Dictionary<string, StringValues>(StringComparer.OrdinalIgnoreCase);

Internal\ConfigurationReader.cs (2)

41var certificates = new Dictionary<string, CertificateConfig>(0, StringComparer.OrdinalIgnoreCase); 123var sniDictionary = new Dictionary<string, SniConfig>(0, StringComparer.OrdinalIgnoreCase);

Internal\Http\HttpHeaders.cs (2)

26protected Dictionary<string, StringValues> Unknown => MaybeUnknown ??= new Dictionary<string, StringValues>(StringComparer.OrdinalIgnoreCase); 119ICollection<string> IDictionary<string, StringValues>.Keys => ((IDictionary<string, StringValues>)this).Select(pair => pair.Key).ToHashSet(StringComparer.OrdinalIgnoreCase);

Internal\Http\HttpHeaders.Generated.cs (1)

282private readonly static HashSet<string> _internedHeaderNames = new HashSet<string>(91, StringComparer.OrdinalIgnoreCase)

Internal\SniOptionsSelector.cs (1)

28private readonly Dictionary<string, SniOptions> _exactNameOptions = new Dictionary<string, SniOptions>(StringComparer.OrdinalIgnoreCase);

KestrelConfigurationLoader.cs (1)

72= new Dictionary<string, Action<EndpointConfiguration>>(0, StringComparer.OrdinalIgnoreCase);

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

784.Select(h => h.Identifier).Distinct().OrderBy(n => n, StringComparer.InvariantCulture).ToArray(); 1568return StringComparer.InvariantCulture.Compare(x.Name, y.Name);

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

661public readonly Dictionary<string, string> DecodedHeaders = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

AdaptiveCapacityDictionaryTests.cs (18)

CopyOnWriteDictionaryHolderTest.cs (3)

17var source = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase) 43var source = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase) 68var source = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase)

CopyOnWriteDictionaryTest.cs (3)

46StringComparer.OrdinalIgnoreCase); 70StringComparer.OrdinalIgnoreCase); 94StringComparer.OrdinalIgnoreCase);

PropertyHelperTest.cs (8)

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

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

src\Shared\HttpSys\NativeInterop\HttpApiTypes.cs (1)

58return headerNames.ToFrozenDictionary(s => s, _ => index++, StringComparer.OrdinalIgnoreCase);

src\Shared\HttpSys\RequestProcessing\HeaderCollection.cs (2)

19internal static readonly HashSet<string> DisallowedTrailers = new HashSet<string>(StringComparer.OrdinalIgnoreCase) 51: this(new Dictionary<string, StringValues>(4, StringComparer.OrdinalIgnoreCase))

src\Shared\HttpSys\RequestProcessing\RequestHeaders.cs (1)

36var newDict = new Dictionary<string, StringValues>(StringComparer.OrdinalIgnoreCase);

src\Shared\PropertyHelper\PropertyHelper.cs (2)

326return new Dictionary<string, object?>(dictionary, StringComparer.OrdinalIgnoreCase); 329dictionary = new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase);

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\DefaultHubDispatcher.cs (1)

25private readonly Dictionary<string, HubMethodDescriptor> _methods = new(StringComparer.OrdinalIgnoreCase);

Internal\DefaultHubProtocolResolver.cs (2)

22_availableProtocols = new Dictionary<string, IHubProtocol>(StringComparer.OrdinalIgnoreCase); 36if (_availableProtocols.TryGetValue(protocolName, out var protocol) && (supportedProtocols == null || supportedProtocols.Contains(protocolName, StringComparer.OrdinalIgnoreCase)))

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

RedisHubLifetimeManager.cs (1)

861public HashSet<string> Groups { get; } = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

ServerLogScope.cs (1)

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

Proxying\SpaProxy.cs (3)

24StringComparer.OrdinalIgnoreCase 31StringComparer.OrdinalIgnoreCase 37StringComparer.OrdinalIgnoreCase

FileExtensionContentTypeProvider.cs (1)

22: this(new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)

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

KeyValueAccumulator.cs (3)

25_accumulator = new Dictionary<string, StringValues>(StringComparer.OrdinalIgnoreCase); 49_expandingAccumulator = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase); 105return _accumulator ?? new Dictionary<string, StringValues>(0, StringComparer.OrdinalIgnoreCase);

AssemblyNameExtension.cs (1)

489int hash = StringComparer.OrdinalIgnoreCase.GetHashCode(this.Name);

BackEnd\BuildManager\BuildParameters.cs (5)

288_propertiesFromCommandLine = other._propertiesFromCommandLine != null ? new HashSet<string>(other._propertiesFromCommandLine, StringComparer.OrdinalIgnoreCase) : null; 311WarningsAsErrors = other.WarningsAsErrors == null ? null : new HashSet<string>(other.WarningsAsErrors, StringComparer.OrdinalIgnoreCase); 312WarningsNotAsErrors = other.WarningsNotAsErrors == null ? null : new HashSet<string>(other.WarningsNotAsErrors, StringComparer.OrdinalIgnoreCase); 313WarningsAsMessages = other.WarningsAsMessages == null ? null : new HashSet<string>(other.WarningsAsMessages, StringComparer.OrdinalIgnoreCase); 913translator.TranslateDictionary(ref _buildProcessEnvironment, StringComparer.OrdinalIgnoreCase);

BackEnd\BuildManager\RequestedProjectState.cs (1)

135return new Dictionary<string, List<string>>(capacity, StringComparer.OrdinalIgnoreCase);

BackEnd\Components\Logging\LoggingService.cs (1)

764warningsByProject[key] = new HashSet<string>(codes, StringComparer.OrdinalIgnoreCase);

BackEnd\Components\ProjectCache\ProjectCacheDescriptorEqualityComparer.cs (1)

41hashCode = (hashCode * -1521134295) + StringComparer.OrdinalIgnoreCase.GetHashCode(obj.PluginAssemblyPath);

BackEnd\Components\ProjectCache\ProjectCacheService.cs (5)

37private static readonly HashSet<string> s_projectSpecificPropertyNames = new(StringComparer.OrdinalIgnoreCase) { "TargetFramework", "Configuration", "Platform", "TargetPlatform", "OutputType" }; 184var pluginSettings = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 330Dictionary<string, string> globalProperties = new(configuration.GlobalProperties.Count, StringComparer.OrdinalIgnoreCase); 626var globalProperties = new Dictionary<string, string>(configuration.GlobalProperties.Count, StringComparer.OrdinalIgnoreCase); 693var globalProperties = new Dictionary<string, string>(templateGlobalProperties, StringComparer.OrdinalIgnoreCase)

BackEnd\Components\ProjectCache\ProxyTargets.cs (2)

38_proxyTargetToRealTargetMap = proxyTargetToRealTargetMap.ToDictionary(kvp => kvp.Key, kvp => kvp.Value, StringComparer.OrdinalIgnoreCase); 43translator.TranslateDictionary(ref _proxyTargetToRealTargetMap, StringComparer.OrdinalIgnoreCase);

BackEnd\Components\RequestBuilder\IntrinsicTasks\ItemGroupIntrinsicTask.cs (2)

520HashSet<string> excludesUnescapedForComparison = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 559HashSet<string> specificationsToFind = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

BackEnd\Components\RequestBuilder\IntrinsicTasks\ItemGroupLoggingHelper.cs (1)

226keyValuePairList.Sort((l, r) => StringComparer.OrdinalIgnoreCase.Compare(l.Key, r.Key));

BackEnd\Components\RequestBuilder\IntrinsicTasks\MSBuild.cs (1)

612var combinedTable = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

BackEnd\Components\RequestBuilder\RequestBuilder.cs (4)

1355args.WarningsAsErrors = loggingService.GetWarningsAsErrors(projectBuildEventContext).ToHashSet(StringComparer.OrdinalIgnoreCase); 1356args.WarningsAsMessages = loggingService.GetWarningsAsMessages(projectBuildEventContext).ToHashSet(StringComparer.OrdinalIgnoreCase); 1357args.WarningsNotAsErrors = loggingService.GetWarningsNotAsErrors(projectBuildEventContext).ToHashSet(StringComparer.OrdinalIgnoreCase); 1513.Select(w => w.Trim()), StringComparer.OrdinalIgnoreCase);

BackEnd\Components\RequestBuilder\TargetUpToDateChecker.cs (4)

1264(s_sortInputsOutputs ? (IDictionary<string, object>)new SortedDictionary<string, object>(StringComparer.OrdinalIgnoreCase) : (IDictionary<string, object>)new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase)); 1270(s_sortInputsOutputs ? (IDictionary<string, object>)new SortedDictionary<string, object>(StringComparer.OrdinalIgnoreCase) : (IDictionary<string, object>)new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase));

BackEnd\Components\RequestBuilder\TaskBuilder.cs (1)

542taskIdentityParameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

BackEnd\Components\RequestBuilder\TaskHost.cs (3)

985targetOutputsPerProject.Add(new Dictionary<string, ITaskItem[]>(StringComparer.OrdinalIgnoreCase)); 1163new Dictionary<string, ITaskItem[]>(StringComparer.OrdinalIgnoreCase) 1225targetOutputsPerProject?.Add(new Dictionary<string, ITaskItem[]>(StringComparer.OrdinalIgnoreCase));

BackEnd\Components\Scheduler\Scheduler.cs (2)

2263leftTargets.Sort(StringComparer.OrdinalIgnoreCase); 2264rightTargets.Sort(StringComparer.OrdinalIgnoreCase);

BackEnd\Components\SdkResolution\SdkResult.cs (7)

88translator.TranslateDictionary(ref _propertiesToAdd, count => new Dictionary<string, string>(count, StringComparer.OrdinalIgnoreCase)); 92dictionaryCreator: count => new Dictionary<string, SdkResultItem>(count, StringComparer.OrdinalIgnoreCase)); 108StringComparer.OrdinalIgnoreCase.Equals(_path, result._path) && 109StringComparer.OrdinalIgnoreCase.Equals(_version, result._version) && 159hashCode = (hashCode * -1521134295) + StringComparer.OrdinalIgnoreCase.GetHashCode(_path); 160hashCode = (hashCode * -1521134295) + StringComparer.OrdinalIgnoreCase.GetHashCode(_version); 167hashCode = (hashCode * -1521134295) + StringComparer.OrdinalIgnoreCase.GetHashCode(additionalPath);

BackEnd\Components\SdkResolution\TranslationHelpers.cs (1)

49t.TranslateDictionary(ref metadata, StringComparer.InvariantCultureIgnoreCase);

BackEnd\Node\ServerNodeBuildCommand.cs (1)

112translator.TranslateDictionary(ref _buildProcessEnvironment, StringComparer.OrdinalIgnoreCase);

BackEnd\Shared\BuildRequestConfiguration.cs (4)

609new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase)); 863return StringComparer.OrdinalIgnoreCase.GetHashCode(_projectFullPath) ^ StringComparer.OrdinalIgnoreCase.GetHashCode(_toolsVersion); 936translator.TranslateDictionary(ref _savedEnvironmentVariables, StringComparer.OrdinalIgnoreCase);

BackEnd\Shared\BuildResult.cs (5)

654translator.TranslateDictionary(ref _savedEnvironmentVariables, StringComparer.OrdinalIgnoreCase); 666translator.TranslateDictionary(ref _savedEnvironmentVariables, StringComparer.OrdinalIgnoreCase, ref additionalEntries, s_additionalEntriesKeys); 674translator.TranslateDictionary(ref _savedEnvironmentVariables, StringComparer.OrdinalIgnoreCase, ref additionalEntries, s_additionalEntriesKeys); 741_resultsByTarget = new ConcurrentDictionary<string, TargetResult>(_resultsByTarget, StringComparer.OrdinalIgnoreCase), 763return new ConcurrentDictionary<string, TargetResult>(1, capacity, StringComparer.OrdinalIgnoreCase);

BackEnd\Shared\ConfigurationMetadata.cs (2)

102return StringComparer.OrdinalIgnoreCase.GetHashCode(ProjectFullPath) ^ StringComparer.OrdinalIgnoreCase.GetHashCode(ToolsVersion);

BackEnd\Shared\TargetResult.cs (1)

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

BackEnd\TaskExecutionHost\TaskExecutionHost.cs (2)

157private readonly Dictionary<string, TaskFactoryWrapper> _intrinsicTasks = new Dictionary<string, TaskFactoryWrapper>(StringComparer.OrdinalIgnoreCase); 365var setParameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

BuildCheck\Checks\DoubleWritesCheck.cs (1)

47private readonly Dictionary<string, (string projectFilePath, string taskName)> _filesWritten = new(StringComparer.CurrentCultureIgnoreCase);

BuildCheck\Infrastructure\BuildCheckManagerProvider.cs (1)

287.SequenceEqual(checkFactoryContext.RuleIds, StringComparer.CurrentCultureIgnoreCase)

BuildCheck\Infrastructure\ConfigurationProvider.cs (3)

23private readonly ConcurrentDictionary<string, CheckConfiguration> _checkConfiguration = new ConcurrentDictionary<string, CheckConfiguration>(StringComparer.InvariantCultureIgnoreCase); 28private readonly ConcurrentDictionary<string, Dictionary<string, string>> _editorConfigData = new ConcurrentDictionary<string, Dictionary<string, string>>(StringComparer.InvariantCultureIgnoreCase); 33private readonly ConcurrentDictionary<string, CustomConfigurationData> _customConfigurationData = new ConcurrentDictionary<string, CustomConfigurationData>(StringComparer.InvariantCultureIgnoreCase);

BuildCheck\Infrastructure\EditorConfig\EditorConfigFile.cs (1)

70var activeSectionProperties = ImmutableDictionary.CreateBuilder<string, string>(StringComparer.OrdinalIgnoreCase);

BuildCheck\Infrastructure\EditorConfig\EditorConfigParser.cs (2)

24private readonly ConcurrentDictionary<string, EditorConfigFile> _editorConfigFileCache = new ConcurrentDictionary<string, EditorConfigFile>(StringComparer.InvariantCultureIgnoreCase); 80var resultingDictionary = new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase);

Collections\LookasideStringInterner.cs (1)

47public LookasideStringInterner(StringComparer comparer, int defaultCollectionSize)

CommunicationsUtilities.cs (1)

303Dictionary<string, string> table = new Dictionary<string, string>(200, StringComparer.OrdinalIgnoreCase); // Razzle has 150 environment variables

Construction\ProjectTaskElement.cs (2)

149var parametersClone = new Dictionary<string, string>(_parameters.Count, StringComparer.OrdinalIgnoreCase); 444_parameters = new CopyOnWriteDictionary<(string, ElementLocation)>(StringComparer.OrdinalIgnoreCase);

Construction\Solution\ProjectInSolution.cs (2)

144AspNetConfigurations = new Hashtable(StringComparer.OrdinalIgnoreCase); 146_projectConfigurations = new Dictionary<string, ProjectConfigurationInSolution>(StringComparer.OrdinalIgnoreCase);

Construction\Solution\SolutionFile.cs (10)

132private static readonly StringComparer _pathComparer = RuntimeInformation.IsOSPlatform(OSPlatform.Linux) 133? StringComparer.Ordinal 134: StringComparer.OrdinalIgnoreCase; 355_projectsByGuid = new Dictionary<string, ProjectInSolution>(StringComparer.OrdinalIgnoreCase); 356_solutionFoldersByGuid = new Dictionary<string, ProjectInSolution>(StringComparer.OrdinalIgnoreCase); 766_projectsByGuid = new Dictionary<string, ProjectInSolution>(StringComparer.OrdinalIgnoreCase); 767_solutionFoldersByGuid = new Dictionary<string, ProjectInSolution>(StringComparer.OrdinalIgnoreCase); 827var projectsByUniqueName = new Dictionary<string, ProjectInSolution>(StringComparer.OrdinalIgnoreCase); 828var projectsByOriginalName = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 1710var rawProjectConfigurationsEntries = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

Construction\Solution\SolutionProjectGenerator.cs (3)

80internal static readonly ImmutableHashSet<string> _defaultTargetNames = ImmutableHashSet.Create(StringComparer.OrdinalIgnoreCase, 182_globalProperties = globalProperties ?? new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 2076var properties = new Dictionary<string, string>(_metaprojectGlobalProperties.Length, StringComparer.OrdinalIgnoreCase);

CopyOnWriteDictionary.cs (3)

40/// Empty dictionary with <see cref="StringComparer.OrdinalIgnoreCase" />, 44private static readonly ImmutableDictionary<string, V> OrdinalIgnoreCaseComparerDictionaryPrototype = ImmutableDictionary.Create<string, V>(StringComparer.OrdinalIgnoreCase); 92: keyComparer == StringComparer.OrdinalIgnoreCase

Definition\Project.cs (2)

4278ItemsByEvaluatedIncludeCache = new MultiDictionary<string, ProjectItem>(StringComparer.OrdinalIgnoreCase); 4281Targets = new RetrievableEntryHashSet<ProjectTargetInstance>(StringComparer.OrdinalIgnoreCase);

Definition\ProjectCollection.cs (3)

1803_toolsets = new Dictionary<string, Toolset>(StringComparer.OrdinalIgnoreCase); 2449private Dictionary<string, List<Project>> _loadedProjects = new Dictionary<string, List<Project>>(StringComparer.OrdinalIgnoreCase); 2609_loadedProjects = new Dictionary<string, List<Project>>(StringComparer.OrdinalIgnoreCase);

Definition\Toolset.cs (3)

627translator.TranslateDictionary(ref _subToolsets, StringComparer.OrdinalIgnoreCase, SubToolset.FactoryForDeserialization); 630translator.TranslateDictionary(ref _propertySearchPathsTable, StringComparer.OrdinalIgnoreCase, ProjectImportPathMatch.FactoryForDeserialization); 740Array.Sort<string>(defaultTasksFiles, StringComparer.OrdinalIgnoreCase);

Definition\ToolsetConfigurationReader.cs (1)

74_projectImportSearchPathsCache = new Dictionary<string, Dictionary<string, ProjectImportPathMatch>>(StringComparer.OrdinalIgnoreCase);

Definition\ToolsetReader.cs (1)

453Dictionary<string, SubToolset> subToolsets = new Dictionary<string, SubToolset>(StringComparer.OrdinalIgnoreCase);

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\Evaluator.cs (5)

254_importsSeen = new Dictionary<string, ProjectImportElement>(StringComparer.OrdinalIgnoreCase); 767Dictionary<string, List<TargetSpecification>> targetsWhichRunBeforeByTarget = new Dictionary<string, List<TargetSpecification>>(StringComparer.OrdinalIgnoreCase); 768Dictionary<string, List<TargetSpecification>> targetsWhichRunAfterByTarget = new Dictionary<string, List<TargetSpecification>>(StringComparer.OrdinalIgnoreCase); 770Dictionary<string, LinkedListNode<ProjectTargetElement>> activeTargets = new Dictionary<string, LinkedListNode<ProjectTargetElement>>(StringComparer.OrdinalIgnoreCase); 1963escapedMetadata = new Dictionary<string, string>(item.Value.Metadata.Count, StringComparer.OrdinalIgnoreCase);

Evaluation\Expander.cs (6)

2246private static readonly ConcurrentDictionary<string, ItemTransformFunction> s_transformFunctionDelegateCache = new ConcurrentDictionary<string, ItemTransformFunction>(StringComparer.OrdinalIgnoreCase); 2475SortedSet<string> directories = new SortedSet<string>(StringComparer.OrdinalIgnoreCase); 2549Dictionary<string, string> directoryNameTable = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 2668return DistinctWithComparer(expander, elementLocation, includeNullEntries, functionName, itemsOfType, arguments, StringComparer.Ordinal); 2677return DistinctWithComparer(expander, elementLocation, includeNullEntries, functionName, itemsOfType, arguments, StringComparer.OrdinalIgnoreCase); 2684internal static IEnumerable<KeyValuePair<string, S>> DistinctWithComparer(Expander<P, I> expander, IElementLocation elementLocation, bool includeNullEntries, string functionName, IEnumerable<KeyValuePair<string, S>> itemsOfType, string[] arguments, StringComparer comparer)

Evaluation\IntrinsicFunctions.cs (1)

505IDictionary<string, string> parameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

Evaluation\ItemSpec.cs (6)

580StringComparer comparer = options == MatchOnMetadataOptions.CaseSensitive ? StringComparer.Ordinal : 581options == MatchOnMetadataOptions.CaseInsensitive || FileUtilities.PathComparison == StringComparison.OrdinalIgnoreCase ? StringComparer.OrdinalIgnoreCase : 582StringComparer.Ordinal; 594private MetadataTrie(StringComparer comparer) 600private void Add(IEnumerable<string> metadata, StringComparer comparer)

Evaluation\LazyItemEvaluator.cs (3)

44new Dictionary<string, LazyItemList>(StringComparer.OrdinalIgnoreCase); 364Dictionary<string, UpdateOperation> itemsWithNoWildcards = new Dictionary<string, UpdateOperation>(StringComparer.OrdinalIgnoreCase); 462private static readonly ImmutableDictionary<string, LazyItemList> s_emptyIgnoreCase = ImmutableDictionary.Create<string, LazyItemList>(StringComparer.OrdinalIgnoreCase);

Evaluation\LazyItemEvaluator.LazyItemOperation.cs (1)

126capturedItems.Comparer == StringComparer.OrdinalIgnoreCase,

Evaluation\LazyItemEvaluator.OrderedItemDataCollection.cs (1)

106_dictionaryBuilder = new Dictionary<string, ItemDataCollectionValue<I>>(StringComparer.OrdinalIgnoreCase);

Evaluation\LazyItemEvaluator.UpdateOperation.cs (1)

134capturedItemsFromReferencedItemTypes ??= new Dictionary<string, I>(StringComparer.OrdinalIgnoreCase);

Evaluation\ProjectParser.cs (1)

41private static readonly HashSet<string> KnownAttributesOnItemIgnoreCase = new HashSet<string>(KnownAttributesOnItem, StringComparer.OrdinalIgnoreCase);

Evaluation\ProjectRootElementCache.cs (4)

157_weakCache = new WeakValueDictionary<string, ProjectRootElement>(StringComparer.OrdinalIgnoreCase); 159_fileLoadLocks = new ConcurrentDictionary<string, object>(StringComparer.OrdinalIgnoreCase); 455_weakCache = new WeakValueDictionary<string, ProjectRootElement>(StringComparer.OrdinalIgnoreCase); 476_weakCache = new WeakValueDictionary<string, ProjectRootElement>(StringComparer.OrdinalIgnoreCase);

Evaluation\PropertiesUseTracker.cs (1)

94_properties = new(StringComparer.OrdinalIgnoreCase);

Evaluation\PropertyTrackingEvaluatorDataWrapper.cs (1)

34private readonly HashSet<string> _overwrittenEnvironmentVariables = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

Evaluation\SimpleProjectRootElementCache.cs (1)

32_cache = new ConcurrentDictionary<string, ProjectRootElement>(StringComparer.OrdinalIgnoreCase);

Evaluation\ToolsetProvider.cs (3)

39_toolsets = new Dictionary<string, Toolset>(StringComparer.OrdinalIgnoreCase); 84translator.TranslateDictionary(ref _toolsets, StringComparer.OrdinalIgnoreCase, Toolset.FactoryForDeserialization); 104_toolsets = new Dictionary<string, Toolset>(StringComparer.OrdinalIgnoreCase);

FileMatcher.cs (4)

FileUtilities.cs (4)

67internal static readonly StringComparer PathComparer = GetIsFileSystemCaseSensitive() ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase; 133private static readonly ConcurrentDictionary<string, bool> FileExistenceCache = new ConcurrentDictionary<string, bool>(StringComparer.OrdinalIgnoreCase);

Graph\GraphBuilder.cs (3)

266keyComparer: StringComparer.OrdinalIgnoreCase, 267valueComparer: StringComparer.Ordinal); 308Dictionary<string, ImmutableDictionary<string, string>> globalPropertiesForProjectConfiguration = new(StringComparer.OrdinalIgnoreCase);

Graph\ProjectGraph.cs (2)

757var seenTargets = new SortedSet<string>(StringComparer.OrdinalIgnoreCase); 910hashCode ^= StringComparer.OrdinalIgnoreCase.GetHashCode(RequestedTargets[i]);

Instance\HostServices.cs (3)

143_hostObjectMap ??= new Dictionary<string, HostObjects>(StringComparer.OrdinalIgnoreCase); 172_hostObjectMap ??= new Dictionary<string, HostObjects>(StringComparer.OrdinalIgnoreCase); 222_projectAffinities = new Dictionary<string, NodeAffinity>(StringComparer.OrdinalIgnoreCase);

Instance\ProjectInstance.cs (11)

Instance\ProjectItemInstance.cs (1)

1583return StringComparer.OrdinalIgnoreCase.GetHashCode(_includeEscaped);

Instance\ProjectTaskInstance.cs (2)

140new CopyOnWriteDictionary<(string, ElementLocation)>(StringComparer.OrdinalIgnoreCase), 238Dictionary<string, string> filteredParameters = new Dictionary<string, string>(_parameters.Count, StringComparer.OrdinalIgnoreCase);

Instance\TaskFactories\AssemblyTaskFactory.cs (5)

265_factoryIdentityParameters = new Dictionary<string, string>(taskFactoryIdentityParameters, StringComparer.OrdinalIgnoreCase); 349mergedParameters ??= new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 558mergedParameters = new Dictionary<string, string>(taskIdentityParameters, StringComparer.OrdinalIgnoreCase); 562mergedParameters = new Dictionary<string, string>(factoryIdentityParameters, StringComparer.OrdinalIgnoreCase); 577mergedParameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

Instance\TaskFactoryWrapper.cs (4)

294propertyInfoCache = new Dictionary<string, TaskPropertyInfo>(StringComparer.OrdinalIgnoreCase); 308namesOfPropertiesWithAmbiguousMatches = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 318namesOfPropertiesWithRequiredAttribute = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 329namesOfPropertiesWithOutputAttribute = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

Instance\TaskRegistry.cs (11)

Logging\BaseConsoleLogger.cs (1)

679table = new Dictionary<string, PerformanceCounter>(StringComparer.OrdinalIgnoreCase);

Logging\BinaryLogger\ProjectImportsCollector.cs (1)

34private readonly HashSet<string> _processedFiles = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

Logging\ParallelLogger\ParallelConsoleLogger.cs (1)

1651table = new Dictionary<string, PerformanceCounter>(StringComparer.OrdinalIgnoreCase);

Logging\ParallelLogger\ParallelLoggerHelpers.cs (2)

22private Dictionary<string, int> _projectTargetKey = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase); 23private Dictionary<string, int> _projectKey = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);

Modifiers.cs (1)

72private static readonly HashSet<string> s_tableOfItemSpecModifiers = new HashSet<string>(All, StringComparer.OrdinalIgnoreCase);

MSBuildNameIgnoreCaseComparer.cs (1)

190return StringComparer.OrdinalIgnoreCase.GetHashCode(obj.Substring(start, length));

PlatformNegotiation.cs (2)

36HashSet<string> projectReferencePlatforms = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 106Dictionary<string, string> table = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

PropertyParser.cs (2)

33propertiesTable = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 89finalPropertiesTable = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

Resources\Constants.cs (2)

288var availableStaticMethods = new ConcurrentDictionary<string, Tuple<string, Type>>(StringComparer.OrdinalIgnoreCase); 360availableStaticMethods.TryAdd("System.StringComparer", new Tuple<string, Type>(null, typeof(StringComparer)));

SolutionConfiguration.cs (5)

23private readonly Dictionary<string, XmlElement> _cachedProjectElements = new Dictionary<string, XmlElement>(StringComparer.OrdinalIgnoreCase); 26private readonly Dictionary<string, XmlElement> _cachedProjectElementsByAbsolutePath = new Dictionary<string, XmlElement>(StringComparer.OrdinalIgnoreCase); 29private readonly Dictionary<string, string> _cachedProjectAbsolutePathsByGuid = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 32private readonly Dictionary<string, string> _cachedProjectGuidsByAbsolutePath = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 35private readonly Dictionary<string, List<string>> _cachedDependencyProjectGuidsByDependingProjectGuid = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);

TaskHostConfiguration.cs (7)

199_taskParameters = new Dictionary<string, TaskParameter>(StringComparer.OrdinalIgnoreCase); 415translator.TranslateDictionary(ref _buildProcessEnvironment, StringComparer.OrdinalIgnoreCase); 441translator.TranslateDictionary(ref _taskParameters, StringComparer.OrdinalIgnoreCase, TaskParameter.FactoryForDeserialization); 443translator.TranslateDictionary(ref _globalParameters, StringComparer.OrdinalIgnoreCase); 449collectionFactory: count => new HashSet<string>(count, StringComparer.OrdinalIgnoreCase)); 456collectionFactory: count => new HashSet<string>(count, StringComparer.OrdinalIgnoreCase)); 463collectionFactory: count => new HashSet<string>(count, StringComparer.OrdinalIgnoreCase));

TaskHostTaskComplete.cs (4)

120_taskOutputParameters = new Dictionary<string, TaskParameter>(StringComparer.OrdinalIgnoreCase); 198_taskOutputParameters = new Dictionary<string, TaskParameter>(StringComparer.OrdinalIgnoreCase); 244translator.TranslateDictionary(ref _taskOutputParameters, StringComparer.OrdinalIgnoreCase, TaskParameter.FactoryForDeserialization); 245translator.TranslateDictionary(ref _buildProcessEnvironment, StringComparer.OrdinalIgnoreCase);

TaskParameter.cs (7)

302escapedMetadata = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 320escapedMetadata = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 429escapedGenericWrappedMetadata = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 453translator.TranslateDictionary(ref escapedGenericWrappedMetadata, StringComparer.OrdinalIgnoreCase); 474translator.TranslateDictionary(ref escapedMetadata, StringComparer.OrdinalIgnoreCase); 852_customEscapedMetadata ??= new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 922IDictionary<string, string> clonedMetadata = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

ToolsetElement.cs (2)

171private Dictionary<string, string> _previouslySeenOS = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 525private Dictionary<string, string> _previouslySeenToolsVersions = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

TypeLoader.cs (3)

311_typeNameToType = new(StringComparer.OrdinalIgnoreCase); 312_publicTypeNameToType = new Dictionary<string, Type>(StringComparer.OrdinalIgnoreCase); 313_publicTypeNameToLoadedType = new(StringComparer.OrdinalIgnoreCase);

Utilities\EngineFileUtilities.cs (2)

371Array.Sort(fileList, StringComparer.OrdinalIgnoreCase); 588private static readonly Lazy<ConcurrentDictionary<string, bool>> _regexMatchCache = new Lazy<ConcurrentDictionary<string, bool>>(() => new ConcurrentDictionary<string, bool>(StringComparer.OrdinalIgnoreCase));

VersionUtilities.cs (1)

112return StringComparer.OrdinalIgnoreCase.Compare(y, x);

XMakeAttributes.cs (3)

106private static readonly HashSet<string> KnownSpecialTaskAttributesIgnoreCase = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { condition, continueOnError, msbuildRuntime, msbuildArchitecture, xmlns }; 110private static readonly HashSet<string> ValidMSBuildRuntimeValues = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { MSBuildRuntimeValues.clr2, MSBuildRuntimeValues.clr4, MSBuildRuntimeValues.currentRuntime, MSBuildRuntimeValues.net, MSBuildRuntimeValues.any }; 112private static readonly HashSet<string> ValidMSBuildArchitectureValues = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { MSBuildArchitectureValues.x86, MSBuildArchitectureValues.x64, MSBuildArchitectureValues.arm64, MSBuildArchitectureValues.currentArchitecture, MSBuildArchitectureValues.any };

CommandLineSwitches_Tests.cs (8)

VersionUtilities.cs (1)

112return StringComparer.OrdinalIgnoreCase.Compare(y, x);

Definition\Project_Tests.cs (12)

Definition\ProjectCollection_Tests.cs (3)

411var globalProperties1 = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) { { "p", "v1" } }; 418var globalProperties2 = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) { { "p", "v2" } }; 572var globalProperties = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) { { "p", "v1" } };

Definition\ProjectProperty_Tests.cs (1)

190Dictionary<string, string> globalProperties = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

EscapingUtilities.cs (1)

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

FileUtilities.cs (4)

67internal static readonly StringComparer PathComparer = GetIsFileSystemCaseSensitive() ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase; 133private static readonly ConcurrentDictionary<string, bool> FileExistenceCache = new ConcurrentDictionary<string, bool>(StringComparer.OrdinalIgnoreCase);

Instance\ProjectInstance_Tests.cs (2)

202Dictionary<string, string> globals = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) { { "p", "p1" } }; 1026var globalProperties = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

TransientIO.cs (1)

18private Dictionary<string, TransientIO> Children = new Dictionary<string, TransientIO>(StringComparer.OrdinalIgnoreCase);

BackEnd\AssemblyTaskFactory_Tests.cs (18)

BackEnd\BinaryTranslator_Tests.cs (75)

BackEnd\BuildManager_Tests.cs (1)

3543Dictionary<string, string> propertiesLookup = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

BackEnd\BuildRequestConfiguration_Tests.cs (13)

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\ConfigurationMetadata_Tests.cs (1)

150Dictionary<string, string> globalProperties = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

BackEnd\IntrinsicTask_Tests.cs (1)

1256Dictionary<string, string> globalProperties = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

BackEnd\LoggingServicesLogMethod_Tests.cs (7)

840BuildRequestData data = new BuildRequestData("file", new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase), "toolsVersion", Array.Empty<string>(), null); 866BuildRequestData data = new BuildRequestData(ProjectFile, new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase), "toolsVersion", Array.Empty<string>(), null); 905BuildRequestData data = new BuildRequestData(ProjectFile, new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase), "toolsVersion", Array.Empty<string>(), null); 946BuildRequestData data = new BuildRequestData(ProjectFile, new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase), "toolsVersion", Array.Empty<string>(), null); 1299Assert.Equal(expectedEventArgs.Properties.OrderBy(kvp => kvp.Key, StringComparer.Ordinal), actualEventArgs.Properties.OrderBy(kvp => kvp.Key, StringComparer.OrdinalIgnoreCase)); 1419BuildRequestData data = new BuildRequestData("file", new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase), "toolsVersion", Array.Empty<string>(), null);

BackEnd\SdkResolverService_Tests.cs (3)

411propertiesToAdd = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) 416itemsToAdd = new Dictionary<string, SdkResultItem>(StringComparer.OrdinalIgnoreCase) 419new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)

BackEnd\TaskExecutionHost_Tests.cs (9)

142var parameters = new Dictionary<string, (string, ElementLocation)>(StringComparer.OrdinalIgnoreCase); 158var parameters = new Dictionary<string, (string, ElementLocation)>(StringComparer.OrdinalIgnoreCase); 168var parameters = new Dictionary<string, (string, ElementLocation)>(StringComparer.OrdinalIgnoreCase); 607var parameters = new Dictionary<string, (string, ElementLocation)>(StringComparer.OrdinalIgnoreCase); 623var parameters = new Dictionary<string, (string, ElementLocation)>(StringComparer.OrdinalIgnoreCase); 641var parameters = new Dictionary<string, (string, ElementLocation)>(StringComparer.OrdinalIgnoreCase); 1289_parametersSetOnTask = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase); 1290_outputsReadFromTask = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase); 1481var parameters = new Dictionary<string, (string, ElementLocation)>(StringComparer.OrdinalIgnoreCase);

BackEnd\TaskHostConfiguration_Tests.cs (2)

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

BackEnd\TaskRegistry_Tests.cs (4)

580Dictionary<string, string> taskParameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 1057Dictionary<string, string> taskParameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 1081taskParameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 2056parameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)

BuildEnvironmentHelper_Tests.cs (1)

507private readonly Dictionary<string, string> _mockEnvironment = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

Collections\MultiDictionary_Tests.cs (6)

24MultiDictionary<string, string> dictionary = new MultiDictionary<string, string>(StringComparer.OrdinalIgnoreCase); 43MultiDictionary<string, string> dictionary = new MultiDictionary<string, string>(StringComparer.OrdinalIgnoreCase); 79MultiDictionary<string, string> dictionary = new MultiDictionary<string, string>(StringComparer.OrdinalIgnoreCase); 99MultiDictionary<string, string> dictionary = new MultiDictionary<string, string>(StringComparer.OrdinalIgnoreCase); 128MultiDictionary<string, string> dictionary = new MultiDictionary<string, string>(StringComparer.OrdinalIgnoreCase); 155MultiDictionary<string, string> dictionary = new MultiDictionary<string, string>(StringComparer.OrdinalIgnoreCase);

Collections\OMcollections_tests.cs (5)

187var dictionary = CreateCloneDictionary<string>(null, StringComparer.OrdinalIgnoreCase); 207var dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 210var readOnlyDictionary = CreateCloneDictionary(dictionary, StringComparer.OrdinalIgnoreCase); 224var dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 334private static ObjectModel.ReadOnlyDictionary<string, TValue> CreateCloneDictionary<TValue>(IDictionary<string, TValue> dictionary, StringComparer strComparer)

CommunicationUtilities_Tests.cs (1)

23IDictionary<string, string> referenceVars2 = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

CopyOnWriteDictionary_Tests.cs (1)

131var dictionary = new CopyOnWriteDictionary<string>(StringComparer.OrdinalIgnoreCase);

Definition\Toolset_Tests.cs (3)

103Dictionary<string, SubToolset> subToolsets = new Dictionary<string, SubToolset>(StringComparer.OrdinalIgnoreCase); 507IDictionary<string, string> properties = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 511Dictionary<string, SubToolset> subToolsets = new Dictionary<string, SubToolset>(StringComparer.OrdinalIgnoreCase);

Definition\ToolsetConfigurationReader_Tests.cs (1)

560Dictionary<string, Toolset> toolsets = new Dictionary<string, Toolset>(StringComparer.OrdinalIgnoreCase);

Definition\ToolsVersion_Tests.cs (3)

273sortedTasksExpectedPaths.Sort(StringComparer.OrdinalIgnoreCase); 274sortedOverrideExpectedPaths.Sort(StringComparer.OrdinalIgnoreCase); 943_defaultTasksFileMap = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

Evaluation\Evaluator_Tests.cs (24)

Evaluation\Expander_Tests.cs (4)

780Dictionary<string, string> itemMetadataTable = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 1358Dictionary<string, string> itemMetadataTable = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 1574var itemMetadataTable = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) 3911Dictionary<string, string> itemMetadataTable = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

Evaluation\ExpressionShredder_Tests.cs (3)

449Assert.Equal(actual, expected, StringComparer.Ordinal); 1124HashSet<string> result = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 1146Dictionary<string, MetadataReference> consumedMetadataReferences = new Dictionary<string, MetadataReference>(StringComparer.OrdinalIgnoreCase);

Evaluation\Preprocessor_Tests.cs (3)

943var propertiesToAdd = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) 948var itemsToAdd = new Dictionary<string, SdkResultItem>(StringComparer.OrdinalIgnoreCase) 951new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)

Evaluation\SdkResultEvaluation_Tests.cs (3)

60propertiesToAdd = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) 65itemsToAdd = new Dictionary<string, SdkResultItem>(StringComparer.OrdinalIgnoreCase) 68new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)

ExpressionTreeExpression_Tests.cs (1)

400Dictionary<string, string> metadataDictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

Graph\GraphLoadedFromSolution_tests.cs (1)

528HashSet<string> propertiesToIgnore = new(StringComparer.OrdinalIgnoreCase)

Graph\ParallelWorkSet_Tests.cs (2)

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

Instance\HostServices_Tests.cs (1)

502Dictionary<string, string> globals = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

Instance\ProjectInstance_Internal_Tests.cs (4)

380IDictionary<string, string> globalProperties = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 418IDictionary<string, string> globalProperties = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 421IDictionary<string, string> projectCollectionGlobalProperties = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 962globalProperties = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

InternalEngineHelpers.cs (3)

110sdkResultItems = new Dictionary<string, SdkResultItem>(StringComparer.OrdinalIgnoreCase); 116newMetadata = new Dictionary<string, string>(item.Value.Metadata, StringComparer.OrdinalIgnoreCase); 125sdkResult.PropertiesToAdd == null ? null : new Dictionary<string, string>(sdkResult.PropertiesToAdd, StringComparer.OrdinalIgnoreCase),

TaskParameter_Tests.cs (3)

365IDictionary metadata = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 398IDictionary metadata = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 445IDictionary metadata = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

BinaryTranslator.cs (2)

767public void TranslateDictionary(ref Dictionary<string, DateTime> dictionary, StringComparer comparer) 1568public void TranslateDictionary(ref Dictionary<string, DateTime> dictionary, StringComparer comparer)

BuildException\BuildExceptionBase.cs (1)

136customKeyedSerializedData = new Dictionary<string, string?>(count, StringComparer.CurrentCulture);

ImmutableFilesTimestampCache.cs (1)

17private readonly ConcurrentDictionary<string, DateTime> _cache = new(StringComparer.OrdinalIgnoreCase);

ITranslator.cs (1)

325void TranslateDictionary(ref Dictionary<string, DateTime> dictionary, StringComparer comparer);

ProjectStartedEventArgs.cs (1)

505HashSet<string> set = EnumerableExtensions.NewHashSet<string>(count, StringComparer.OrdinalIgnoreCase);

Sdk\SdkResultItem.cs (4)

24Metadata = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 31/// <param name="metadata">A dictionary of item metadata. This should be created with <see cref="StringComparer.OrdinalIgnoreCase"/> for the comparer.</param> 59hashCode ^= StringComparer.OrdinalIgnoreCase.GetHashCode(kvp.Key) * (StringComparer.OrdinalIgnoreCase.GetHashCode(kvp.Value ?? "V") + 1);

XamlTypes\ContentType.cs (1)

159var metadata = new Dictionary<string, string>(this.Metadata.Count, StringComparer.OrdinalIgnoreCase);

XamlTypes\Rule.cs (2)

77Metadata = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase); 497var map = new Dictionary<string, BaseProperty>(this.Properties.Count, StringComparer.OrdinalIgnoreCase);

EscapingUtilities.cs (1)

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

src\Compilers\Shared\NamedPipeUtil.cs (1)

64StringComparer.OrdinalIgnoreCase.Equals(serverIdentity.name, clientIdentity.name) &&

TestUtilities\SimpleTaskItem.cs (1)

45var map = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

AssemblyDependency\AssemblyFoldersFromConfig\AssemblyFoldersFromConfigCache.cs (1)

53StringComparer.OrdinalIgnoreCase);

AssemblyDependency\Reference.cs (3)

27private Dictionary<string, ITaskItem> _sourceItems = new Dictionary<string, ITaskItem>(StringComparer.OrdinalIgnoreCase); 76private Dictionary<string, UnificationVersion> _preUnificationVersions = new Dictionary<string, UnificationVersion>(StringComparer.OrdinalIgnoreCase); 508_preUnificationVersions = new Dictionary<string, UnificationVersion>(StringComparer.OrdinalIgnoreCase);

AssemblyDependency\ReferenceTable.cs (9)

36private static readonly Dictionary<string, Tuple<RedistList, string>> s_monikerToHighestRedistList = new Dictionary<string, Tuple<RedistList, string>>(StringComparer.OrdinalIgnoreCase); 41private readonly HashSet<string> _externallyResolvedPrimaryReferences = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 46private readonly Dictionary<string, AssemblyNameExtension> _externallyResolvedImmutableFiles = new Dictionary<string, AssemblyNameExtension>(StringComparer.OrdinalIgnoreCase); 336_resolvedSDKReferences = new Dictionary<string, ITaskItem>(StringComparer.OrdinalIgnoreCase); 1239var parentReferencesAdded = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 1870var conflictingFullNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 1871var fullNameToReference = new Dictionary<string, AssemblyNameReference>(References.Count, StringComparer.OrdinalIgnoreCase); 2051var seenFrameworkDirectories = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 2188var baseNameToReferences = new Dictionary<string, List<AssemblyNameReference>>(References.Count, StringComparer.OrdinalIgnoreCase);

AssemblyDependency\ResolveAssemblyReference.cs (2)

221private Dictionary<string, MessageImportance> _showAssemblyFoldersExLocations = new Dictionary<string, MessageImportance>(StringComparer.OrdinalIgnoreCase); 3059Dictionary<string, AssemblyTableInfo> tableMap = new Dictionary<string, AssemblyTableInfo>(StringComparer.OrdinalIgnoreCase);

AssemblyNameExtension.cs (1)

489int hash = StringComparer.OrdinalIgnoreCase.GetHashCode(this.Name);

AssignProjectConfiguration.cs (2)

370_vcxToDefaultMap = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 371_defaultToVcxMap = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

BootstrapperUtil\BootstrapperBuilder.cs (7)

43private readonly Dictionary<string, XmlNode> _cultures = new Dictionary<string, XmlNode>(StringComparer.OrdinalIgnoreCase); 44private readonly Dictionary<string, ProductValidationResults> _validationResults = new Dictionary<string, ProductValidationResults>(StringComparer.Ordinal); 207var eulas = new Dictionary<string, KeyValuePair<string, string>>(StringComparer.Ordinal); 427var folders = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 618var availableProducts = new Dictionary<string, Product>(StringComparer.Ordinal); 620var buildQueue = new Dictionary<string, Product>(StringComparer.Ordinal); 2212var includedProducts = new Dictionary<string, Product>(StringComparer.OrdinalIgnoreCase)

BootstrapperUtil\PackageCollection.cs (1)

16private readonly Dictionary<string, Package> _cultures = new Dictionary<string, Package>(StringComparer.OrdinalIgnoreCase);

BootstrapperUtil\Product.cs (1)

30private readonly Dictionary<string, Package> _cultures = new Dictionary<string, Package>(StringComparer.OrdinalIgnoreCase);

BootstrapperUtil\ProductCollection.cs (1)

22private readonly Dictionary<string, Product> _table = new Dictionary<string, Product>(StringComparer.OrdinalIgnoreCase);

BootstrapperUtil\productvalidationresults.cs (1)

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

Copy.cs (3)

110private readonly ConcurrentDictionary<string, bool> _directoriesKnownToExist = new ConcurrentDictionary<string, bool>(DefaultCopyParallelism, DefaultCopyParallelism, StringComparer.OrdinalIgnoreCase); 494StringComparer.OrdinalIgnoreCase); 588StringComparer.OrdinalIgnoreCase);

CopyOnWriteDictionary.cs (3)

40/// Empty dictionary with <see cref="StringComparer.OrdinalIgnoreCase" />, 44private static readonly ImmutableDictionary<string, V> OrdinalIgnoreCaseComparerDictionaryPrototype = ImmutableDictionary.Create<string, V>(StringComparer.OrdinalIgnoreCase); 92: keyComparer == StringComparer.OrdinalIgnoreCase

CreateItem.cs (1)

219var uniqueItems = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

CreateManifestResourceName.cs (1)

35protected Dictionary<string, ITaskItem> itemSpecToTaskitem = new Dictionary<string, ITaskItem>(StringComparer.OrdinalIgnoreCase);

CultureInfoCache.cs (1)

78return pseudoLocales.Contains(name, StringComparer.OrdinalIgnoreCase);

EscapingUtilities.cs (1)

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

FileIO\GetFileHash.cs (1)

27= new Dictionary<string, Func<HashAlgorithm>>(StringComparer.OrdinalIgnoreCase)

FileMatcher.cs (4)

FileUtilities.cs (4)

67internal static readonly StringComparer PathComparer = GetIsFileSystemCaseSensitive() ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase; 133private static readonly ConcurrentDictionary<string, bool> FileExistenceCache = new ConcurrentDictionary<string, bool>(StringComparer.OrdinalIgnoreCase);

GenerateResource.cs (2)

1467HashSet<string> set = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 3884resourcesHashTable = new Dictionary<string, IResource>(StringComparer.OrdinalIgnoreCase);

GetSDKReferenceFiles.cs (7)

54private readonly ConcurrentDictionary<string, SDKInfo> _cacheFileForSDKs = new ConcurrentDictionary<string, SDKInfo>(StringComparer.OrdinalIgnoreCase); 995var references = new ConcurrentDictionary<string, SdkReferenceInfo>(StringComparer.OrdinalIgnoreCase); 996var directoryToFileList = new ConcurrentDictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase); 1225_pathToReferenceMetadata = new Dictionary<string, SdkReferenceInfo>(StringComparer.OrdinalIgnoreCase); 1226_directoryToFileList = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase); 1271}, count => new Dictionary<string, SdkReferenceInfo>(count, StringComparer.OrdinalIgnoreCase)); 1276}, count => new Dictionary<string, List<string>>(count, StringComparer.OrdinalIgnoreCase));

ListOperators\RemoveDuplicates.cs (1)

48var alreadySeen = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

MakeDir.cs (1)

46var directoriesSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

ManifestUtil\ApplicationManifest.cs (1)

565var usedExtensions = new Dictionary<string, FileAssociation>(StringComparer.OrdinalIgnoreCase);

ManifestUtil\ComImporter.cs (3)

137if (Array.BinarySearch(knownNames, name, StringComparer.OrdinalIgnoreCase) < 0) 159StringComparer.OrdinalIgnoreCase) < 0) 252if (Array.BinarySearch(s_knownSubKeys, subKeyName, StringComparer.OrdinalIgnoreCase) < 0)

Modifiers.cs (1)

72private static readonly HashSet<string> s_tableOfItemSpecModifiers = new HashSet<string>(All, StringComparer.OrdinalIgnoreCase);

MSBuild.cs (1)

561var combinedTable = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

MSBuildNameIgnoreCaseComparer.cs (1)

190return StringComparer.OrdinalIgnoreCase.GetHashCode(obj.Substring(start, length));

PlatformNegotiation.cs (2)

36HashSet<string> projectReferencePlatforms = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 106Dictionary<string, string> table = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

PropertyParser.cs (2)

33propertiesTable = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 89finalPropertiesTable = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

RedistList.cs (12)

ResolveManifestFiles.cs (3)

176_runtimePackAssets = RuntimePackAssets.ToDictionary(p => p.ItemSpec, StringComparer.OrdinalIgnoreCase); 510var outputAssembliesMap = outputAssemblies.ToDictionary(p => Path.GetFullPath(p.ItemSpec), StringComparer.OrdinalIgnoreCase); 900private readonly Dictionary<string, MapEntry> _dictionary = new Dictionary<string, MapEntry>(StringComparer.InvariantCultureIgnoreCase);

ResolveProjectBase.cs (1)

42private readonly HashSet<string> _cachedProjectReferencesByAbsolutePath = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

ResolveSDKReference.cs (9)

30private static readonly Dictionary<string, string> PlatformAliases = new(StringComparer.OrdinalIgnoreCase) 286_runtimeReferenceOnlyDependenciesByName = new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase); 300var sdkItems = new Dictionary<string, ITaskItem>(InstalledSDKs.Length, StringComparer.OrdinalIgnoreCase); 315var sdkNamesOnReferenceItems = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 332var productFamilyNameToSDK = new Dictionary<string, HashSet<SDKReference>>(StringComparer.OrdinalIgnoreCase); 335var sdkNameToSDK = new Dictionary<string, HashSet<SDKReference>>(StringComparer.OrdinalIgnoreCase); 741FrameworkIdentitiesFromManifest = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 742AppxLocationsFromManifest = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 1347var architectureLocations = new SortedDictionary<string, string>(StringComparer.InvariantCultureIgnoreCase);

RoslynCodeTaskFactory\RoslynCodeTaskFactory.cs (6)

46internal static readonly IDictionary<string, IEnumerable<string>> DefaultReferences = new Dictionary<string, IEnumerable<string>>(StringComparer.OrdinalIgnoreCase) 71internal static readonly IDictionary<string, ISet<string>> ValidCodeLanguages = new Dictionary<string, ISet<string>>(StringComparer.OrdinalIgnoreCase) 74{ "CS", new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "CSharp", "C#" } }, 75{ "VB", new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "VisualBasic", "Visual Basic" } }, 247codeNamespace.Imports.AddRange(DefaultNamespaces.Union(taskInfo.Namespaces, StringComparer.OrdinalIgnoreCase).Select(i => new CodeNamespaceImport(i)).ToArray()); 531ISet<string> resolvedAssemblyReferences = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

RoslynCodeTaskFactory\RoslynCodeTaskFactoryTaskInfo.cs (2)

31public ISet<string> Namespaces { get; } = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 36public ISet<string> References { get; } = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

SolutionConfiguration.cs (5)

23private readonly Dictionary<string, XmlElement> _cachedProjectElements = new Dictionary<string, XmlElement>(StringComparer.OrdinalIgnoreCase); 26private readonly Dictionary<string, XmlElement> _cachedProjectElementsByAbsolutePath = new Dictionary<string, XmlElement>(StringComparer.OrdinalIgnoreCase); 29private readonly Dictionary<string, string> _cachedProjectAbsolutePathsByGuid = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 32private readonly Dictionary<string, string> _cachedProjectGuidsByAbsolutePath = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 35private readonly Dictionary<string, List<string>> _cachedDependencyProjectGuidsByDependingProjectGuid = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);

system.design\stronglytypedresourcebuilder.cs (3)

121var resourceTypes = new Dictionary<String, ResourceData>(StringComparer.InvariantCultureIgnoreCase); 720reverseFixupTable = new Dictionary<string, string>(0, StringComparer.InvariantCultureIgnoreCase); 722new SortedList<string, ResourceData>(StringComparer.InvariantCultureIgnoreCase)

SystemState.cs (8)

31private Dictionary<string, FileState> upToDateLocalFileStateCache = new Dictionary<string, FileState>(StringComparer.OrdinalIgnoreCase); 42internal Dictionary<string, FileState> instanceLocalFileStateCache = new Dictionary<string, FileState>(StringComparer.OrdinalIgnoreCase); 47internal Dictionary<string, FileState> instanceLocalOutgoingFileStateCache = new Dictionary<string, FileState>(StringComparer.OrdinalIgnoreCase); 54private Dictionary<string, DateTime> instanceLocalLastModifiedCache = new Dictionary<string, DateTime>(StringComparer.OrdinalIgnoreCase); 61private Dictionary<string, bool> instanceLocalDirectoryExists = new Dictionary<string, bool>(StringComparer.OrdinalIgnoreCase); 68private Dictionary<string, string[]> instanceLocalDirectories = new Dictionary<string, string[]>(StringComparer.OrdinalIgnoreCase); 73private static readonly ConcurrentDictionary<string, FileState> s_processWideFileStateCache = new ConcurrentDictionary<string, FileState>(StringComparer.OrdinalIgnoreCase); 268StringComparer.OrdinalIgnoreCase,

Telemetry.cs (1)

34IDictionary<string, string> properties = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

Touch.cs (1)

90var touchedFilesSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

VersionUtilities.cs (1)

112return StringComparer.OrdinalIgnoreCase.Compare(y, x);

XMakeAttributes.cs (3)

106private static readonly HashSet<string> KnownSpecialTaskAttributesIgnoreCase = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { condition, continueOnError, msbuildRuntime, msbuildArchitecture, xmlns }; 110private static readonly HashSet<string> ValidMSBuildRuntimeValues = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { MSBuildRuntimeValues.clr2, MSBuildRuntimeValues.clr4, MSBuildRuntimeValues.currentRuntime, MSBuildRuntimeValues.net, MSBuildRuntimeValues.any }; 112private static readonly HashSet<string> ValidMSBuildArchitectureValues = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { MSBuildArchitectureValues.x86, MSBuildArchitectureValues.x64, MSBuildArchitectureValues.arm64, MSBuildArchitectureValues.currentArchitecture, MSBuildArchitectureValues.any };

AssemblyDependency\ResolveAssemblyReferenceTestFixture.cs (2)

309uniqueFileExists = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase); 310uniqueGetAssemblyName = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);

AssignLinkMetadata_Tests.cs (1)

183IDictionary<string, string> metadata = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

DirectoryBuildProjectImportTestBase.cs (13)

GetInstalledSDKLocations_Tests.cs (2)

335Dictionary<string, string> extensionSDKs = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 409Dictionary<string, string> extensionSDKs = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

NuGetPropsImportTests.cs (1)

56Assert.Equal("true", project.GetPropertyValue("NuGetPropsIsImported"), StringComparer.OrdinalIgnoreCase);

MockEngine.cs (4)

61public Dictionary<string, string> GlobalProperties { get; set; } = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 236var finalGlobalProperties = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 305Dictionary<string, string> finalGlobalProperties = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 320targetOutputsPerProject.Add(new Dictionary<string, ITaskItem[]>(StringComparer.OrdinalIgnoreCase));

ObjectModelHelpers.cs (1)

1230Dictionary<string, V> dictionary = new Dictionary<string, V>(StringComparer.OrdinalIgnoreCase);

TestEnvironment.cs (1)

498return files.Distinct(StringComparer.InvariantCultureIgnoreCase).ToArray();

CopyOnWriteDictionary.cs (3)

40/// Empty dictionary with <see cref="StringComparer.OrdinalIgnoreCase" />, 44private static readonly ImmutableDictionary<string, V> OrdinalIgnoreCaseComparerDictionaryPrototype = ImmutableDictionary.Create<string, V>(StringComparer.OrdinalIgnoreCase); 92: keyComparer == StringComparer.OrdinalIgnoreCase

EscapingUtilities.cs (1)

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

FileMatcher.cs (4)

FileUtilities.cs (4)

67internal static readonly StringComparer PathComparer = GetIsFileSystemCaseSensitive() ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase; 133private static readonly ConcurrentDictionary<string, bool> FileExistenceCache = new ConcurrentDictionary<string, bool>(StringComparer.OrdinalIgnoreCase);

Modifiers.cs (1)

72private static readonly HashSet<string> s_tableOfItemSpecModifiers = new HashSet<string>(All, StringComparer.OrdinalIgnoreCase);

MSBuildNameIgnoreCaseComparer.cs (1)

190return StringComparer.OrdinalIgnoreCase.GetHashCode(obj.Substring(start, length));

TargetPlatformSDK.cs (2)

49ExtensionSDKs = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 50Platforms = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

ToolLocationHelper.cs (10)

ToolsetElement.cs (2)

171private Dictionary<string, string> _previouslySeenOS = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 525private Dictionary<string, string> _previouslySeenToolsVersions = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

VersionUtilities.cs (1)

112return StringComparer.OrdinalIgnoreCase.Compare(y, x);

Comparers\ApiComparer.cs (3)

50var nameComparison = StringComparer.OrdinalIgnoreCase.Compare(xNonGenericName, yNonGenericName); 71return StringComparer.OrdinalIgnoreCase.Compare(nameX, nameY); 83return StringComparer.OrdinalIgnoreCase.Compare(nameX, nameY);

Dgml\DgmlExtensions.cs (4)

18var assemblyNames = definedNames.Concat(referencedNames).Distinct(StringComparer.OrdinalIgnoreCase).ToArray(); 20Array.Sort(assemblyNames, StringComparer.OrdinalIgnoreCase); 24let source = Array.BinarySearch(assemblyNames, a.Name.Value, StringComparer.OrdinalIgnoreCase) 26let target = Array.BinarySearch(assemblyNames, ar.Name.Value, StringComparer.OrdinalIgnoreCase)

Extensions\TypeExtensions.cs (4)

510return assemblies.OrderBy(a => a.Name.Value, StringComparer.OrdinalIgnoreCase) 511.ThenBy(a => a.GetPublicKeyToken(), StringComparer.OrdinalIgnoreCase) 517return assemblies.OrderBy(a => a.Name.Value, StringComparer.OrdinalIgnoreCase) 518.ThenBy(a => a.GetPublicKeyToken(), StringComparer.OrdinalIgnoreCase)

HostEnvironment.cs (3)

613paths = Enumerable.Concat(new List<string>() { coreAssemblyFile }, paths.Where(ai => !StringComparer.OrdinalIgnoreCase.Equals(ai, coreAssemblyFile))); 668var coreIdentity = identities.FirstOrDefault(ai => StringComparer.OrdinalIgnoreCase.Equals(ai.Name.Value, coreAssemblySimpleName)); 689HashSet<string> allPaths = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

Traversers\MappingsTypeMemberTraverser.cs (3)

45assemblies = assemblies.OrderBy(GetAssemblyKey, StringComparer.OrdinalIgnoreCase); 64namespaces = namespaces.OrderBy(GetNamespaceKey, StringComparer.OrdinalIgnoreCase); 102members = members.OrderBy(GetMemberKey, StringComparer.OrdinalIgnoreCase);

Traversers\SimpleTypeMemberTraverser.cs (5)

40namespaces = namespaces.OrderBy(GetNamespaceKey, StringComparer.OrdinalIgnoreCase); 59types = types.OrderBy(GetTypeKey, StringComparer.OrdinalIgnoreCase); 90members = orderedTypeDefinitionMembers.ThenBy(GetMemberKey, StringComparer.OrdinalIgnoreCase); 95members = orderedFieldDefinitionMembers.ThenBy(GetMemberKey, StringComparer.OrdinalIgnoreCase); 99members = members.OrderBy(GetMemberKey, StringComparer.OrdinalIgnoreCase);

Writers\CSharp\CSDeclarationWriter.Attributes.cs (1)

23securityAttributes = securityAttributes.OrderBy(s => s.Action.ToString(), StringComparer.OrdinalIgnoreCase);

Writers\CSharp\CSDeclarationWriter.Enums.cs (1)

47IEnumerable<IFieldDefinition> sortedFields = resolvedType.Fields.OrderBy(f => f.Name.Value, StringComparer.OrdinalIgnoreCase);

Writers\CSharp\CSDeclarationWriter.Types.cs (1)

97IEnumerable<ITypeReference> interfaces = type.Interfaces.Where(IncludeBaseType).OrderBy(t => GetTypeName(t), StringComparer.OrdinalIgnoreCase);

Writers\CSharp\CSharpWriter.cs (1)

224includedVisibleFields = includedVisibleFields.OrderBy(GetMemberKey, StringComparer.OrdinalIgnoreCase);

Writers\DocumentIdWriter.cs (1)

30assemblies = assemblies.OrderBy(a => a.Name.Value, StringComparer.OrdinalIgnoreCase);

CaseInsensitiveComparison.cs (1)

283public static StringComparer Comparer => s_comparer;

Collections\IdentifierCollection.cs (1)

28StringComparer.OrdinalIgnoreCase);

CommandLine\AnalyzerConfig.cs (2)

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

CommandLine\AnalyzerConfigSet.cs (2)

333var comparer = StringComparer.OrdinalIgnoreCase;

CommandLine\SarifErrorLogger.cs (1)

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

Compilation\Compilation.cs (1)

2142var uniqueFileNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

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

56internal static readonly StringComparer OriginalPathComparer = StringComparer.Ordinal; 62internal static readonly StringComparer GeneratedPathComparer = StringComparer.Ordinal; 67internal static readonly (StringComparer Comparer, StringComparison Comparison) SimpleNameComparer = (StringComparer.OrdinalIgnoreCase, StringComparison.OrdinalIgnoreCase);

DiagnosticAnalyzer\AnalyzerConfigOptions.cs (1)

17public static StringComparer KeyComparer { get; } = AnalyzerConfig.Section.PropertiesKeyComparer;

DiagnosticAnalyzer\AnalyzerExecutor.cs (1)

1314var diagnosticIds = ImmutableSortedSet<string>.Empty.WithComparer(StringComparer.OrdinalIgnoreCase);

DiagnosticAnalyzer\AnalyzerFileReference.cs (3)

230Dictionary<string, ImmutableHashSet<string>.Builder> typeNameMap = new Dictionary<string, ImmutableHashSet<string>.Builder>(StringComparer.OrdinalIgnoreCase); 257return typeNameMap.ToImmutableSortedDictionary(g => g.Key, g => g.Value.ToImmutable(), StringComparer.OrdinalIgnoreCase); 405var map = ImmutableSortedDictionary.CreateBuilder<string, ImmutableArray<TExtension>>(StringComparer.OrdinalIgnoreCase);

DiagnosticAnalyzer\SuppressMessageAttributeState.cs (1)

20private static readonly SmallDictionary<string, TargetScope> s_suppressMessageScopeTypes = new SmallDictionary<string, TargetScope>(StringComparer.OrdinalIgnoreCase)

Emit\AnonymousTypeKey.cs (4)

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

30StringComparer.Ordinal : 31StringComparer.OrdinalIgnoreCase);

FileKey.cs (1)

46StringComparer.OrdinalIgnoreCase.GetHashCode(this.FullPath),

FileSystem\PathUtilities.cs (3)

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

InternalUtilities\Hash.cs (2)

140internal static int CombineValues(IEnumerable<string?>? values, StringComparer stringComparer, int maxItemsToHash = int.MaxValue) 165internal static int CombineValues(ImmutableArray<string> values, StringComparer stringComparer, int maxItemsToHash = int.MaxValue)

MetadataReader\MetadataHelpers.cs (1)

767StringComparer nameComparer,

MetadataReader\PEAssembly.cs (1)

134var ivtMap = new Dictionary<string, List<ImmutableArray<byte>>>(StringComparer.OrdinalIgnoreCase);

MetadataReader\PEModule.cs (4)

666internal IEnumerable<IGrouping<string, TypeDefinitionHandle>> GroupTypesByNamespaceOrThrow(StringComparer nameComparer) 695private readonly StringComparer _nameComparer; 697public TypesByNamespaceSortComparer(StringComparer nameComparer) 3820var caseInsensitiveMap = new Dictionary<string, (string OriginalName, int FirstIndex, int SecondIndex)>(StringComparer.OrdinalIgnoreCase);

MetadataReference\AssemblyIdentityComparer.cs (4)

18public static StringComparer SimpleNameComparer 20get { return StringComparer.OrdinalIgnoreCase; } 23public static StringComparer CultureComparer 25get { return StringComparer.OrdinalIgnoreCase; }

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;

RuleSet\RuleSet.cs (1)

215if (!arrayBuilder.Contains(ruleSet.FilePath, StringComparer.OrdinalIgnoreCase))

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

SourceGeneration\AdditionalSourcesCollection.cs (2)

23private static readonly StringComparer s_hintNameComparer = StringComparer.OrdinalIgnoreCase;

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

212StringComparer comparer = StringComparer.Ordinal;

MetaAnalyzers\DiagnosticDescriptorCreationAnalyzer_ReleaseTracking.cs (2)

250StringComparer comparer = StringComparer.OrdinalIgnoreCase;

src\RoslynAnalyzers\Utilities\Compiler\Extensions\CompilationExtensions.cs (2)

46return guids.Contains(WebAppProjectGuidString, StringComparer.OrdinalIgnoreCase) || 47guids.Contains(WebSiteProjectGuidString, StringComparer.OrdinalIgnoreCase);

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

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

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

15private static readonly ImmutableHashSet<string> s_uriWords = ImmutableHashSet.Create(StringComparer.OrdinalIgnoreCase, "uri", "urn", "url");

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

67var ruleIdToComments = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

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\CompilationExtensions.cs (2)

46return guids.Contains(WebAppProjectGuidString, StringComparer.OrdinalIgnoreCase) || 47guids.Contains(WebSiteProjectGuidString, StringComparer.OrdinalIgnoreCase);

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

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

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

15private static readonly ImmutableHashSet<string> s_uriWords = ImmutableHashSet.Create(StringComparer.OrdinalIgnoreCase, "uri", "urn", "url");

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

67var ruleIdToComments = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

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

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

src\RoslynAnalyzers\Utilities\Compiler\Extensions\CompilationExtensions.cs (2)

46return guids.Contains(WebAppProjectGuidString, StringComparer.OrdinalIgnoreCase) || 47guids.Contains(WebSiteProjectGuidString, StringComparer.OrdinalIgnoreCase);

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

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

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

15private static readonly ImmutableHashSet<string> s_uriWords = ImmutableHashSet.Create(StringComparer.OrdinalIgnoreCase, "uri", "urn", "url");

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

67var ruleIdToComments = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

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\Analyzers\Core\Analyzers\RemoveUnnecessarySuppressions\AbstractRemoveUnnecessaryPragmaSuppressionsDiagnosticAnalyzer.cs (3)

255userExclusions.Contains(id, StringComparer.OrdinalIgnoreCase)) 793userIdExclusions.Contains(id, StringComparer.OrdinalIgnoreCase) || 794category?.Length > 0 && userCategoryExclusions.Contains(category, StringComparer.OrdinalIgnoreCase))

src\Analyzers\Core\Analyzers\RemoveUnnecessarySuppressions\SuppressMessageAttributeState.cs (1)

27var builder = ImmutableDictionary.CreateBuilder<string, TargetScope>(StringComparer.OrdinalIgnoreCase);

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

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

src\Compilers\Core\Portable\InternalUtilities\Hash.cs (2)

140internal static int CombineValues(IEnumerable<string?>? values, StringComparer stringComparer, int maxItemsToHash = int.MaxValue) 165internal static int CombineValues(ImmutableArray<string> values, StringComparer stringComparer, int maxItemsToHash = int.MaxValue)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EditorConfig\Parsing\Sections\Section.cs (2)

173StringComparer.OrdinalIgnoreCase.Equals(FilePath, other.FilePath) && 179StringComparer.OrdinalIgnoreCase.GetHashCode(FilePath ?? string.Empty),

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

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

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

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

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

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

44new(() => new HashSet<string>(StringComparer.OrdinalIgnoreCase), 20); 50new(() => new HashSet<string>(StringComparer.Ordinal), 20); 75new(() => new Dictionary<string, T>(StringComparer.OrdinalIgnoreCase), 20);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\EditorConfigValueSerializer.cs (2)

128var map = new BidirectionalMap<string, T>(entries, StringComparer.OrdinalIgnoreCase); 129var alternativeMap = ImmutableDictionary<string, T>.Empty.WithComparers(keyComparer: StringComparer.OrdinalIgnoreCase)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\ISyntaxFacts.cs (1)

88StringComparer StringComparer { get; }

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

34var comparer = _options.IgnoreCase 35? StringComparer.OrdinalIgnoreCase 36: StringComparer.Ordinal;

src\Analyzers\Core\CodeFixes\AddParameter\AbstractAddParameterCodeFixProvider.cs (1)

434StringComparer comparer,

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

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

src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementInterfaceGenerator.cs (1)

383: StringComparer.OrdinalIgnoreCase.Equals(identifier1, identifier2);

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\NameGenerator.cs (1)

137public static string GenerateUniqueName(string baseName, ISet<string> names, StringComparer comparer)

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)

CommandLine\CSharpCompiler.cs (1)

99var uniqueFilePaths = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

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

CSharpParseOptions.cs (1)

166features?.ToImmutableDictionary(StringComparer.OrdinalIgnoreCase)

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\MissingModuleSymbol.cs (1)

229return Hash.Combine(assembly.GetHashCode(), StringComparer.OrdinalIgnoreCase.GetHashCode(_name));

Symbols\Source\QuickAttributeChecker.cs (2)

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

Symbols\Source\SourceAssemblySymbol.cs (2)

992var knownModuleNames = new HashSet<String>(StringComparer.OrdinalIgnoreCase); 2306new ConcurrentDictionary<string, ConcurrentDictionary<ImmutableArray<byte>, Tuple<Location, String>>>(StringComparer.OrdinalIgnoreCase), null);

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

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

CommandLineTests.cs (2)

8507}, StringComparer.OrdinalIgnoreCase); 8517}, StringComparer.OrdinalIgnoreCase);

Completion\CompletionProviders\LoadDirectiveCompletionProviderTests.cs (1)

29=> StringComparer.OrdinalIgnoreCase;

Completion\CompletionProviders\ReferenceDirectiveCompletionProviderTests.cs (1)

32=> StringComparer.OrdinalIgnoreCase;

Emit\EmitMetadataTests.cs (4)

196Assert.Equal("MDTestLib1", refs[0].Name, StringComparer.OrdinalIgnoreCase); 197Assert.Equal("mscorlib", refs[1].Name, StringComparer.OrdinalIgnoreCase); 213Assert.Contains("MultiModule", refs2, StringComparer.OrdinalIgnoreCase); 214Assert.Contains("mscorlib", refs2, StringComparer.OrdinalIgnoreCase);

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

33var stringComparer = StringComparer.Ordinal;

CSharpScriptCompiler.cs (2)

26public override StringComparer IdentifierComparer => StringComparer.Ordinal;

SourceGeneration\AdditionalSourcesCollectionTests.cs (1)

60Assert.Equal(expectedName, source.HintName, StringComparer.OrdinalIgnoreCase);

Compilation\CompilationAPITests.cs (3)

206StringComparer.Ordinal, 502Assert.Equal("mscorlib", assemblySmb.Name, StringComparer.OrdinalIgnoreCase); 1199Assert.Equal("Test1", smb.Identity.Name, StringComparer.OrdinalIgnoreCase);

Compilation\SemanticModelGetSemanticInfoTests.cs (140)

Symbols\AssemblyAndNamespaceTests.cs (2)

34Assert.Equal(simpleName, sym.Name, StringComparer.OrdinalIgnoreCase); 35Assert.Equal(simpleName + ", Version=0.0.0.0, Culture=neutral, PublicKeyToken=null", sym.ToTestDisplayString(), StringComparer.OrdinalIgnoreCase);

Symbols\Metadata\PE\LoadingNamespacesAndTypes.cs (2)

62OrderBy((child) => child.Name, StringComparer.OrdinalIgnoreCase); 97var childrenNS = namespaces.OrderBy((child) => child.Name, StringComparer.OrdinalIgnoreCase);

Symbols\RequiredMembersTests.cs (1)

7652.OrderBy(m => m.Key, StringComparer.InvariantCulture)

EmitMetadataTestBase.cs (1)

39OrderBy(child => child.Name, StringComparer.OrdinalIgnoreCase);

SymbolUtilities.cs (1)

21int result = StringComparer.OrdinalIgnoreCase.Compare(x.Name, y.Name);

Metadata\WinMdDumpTest.cs (1)

54foreach (var member in container.GetMembers().OrderBy(m => m.Name, System.StringComparer.InvariantCulture))

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

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

EditorConfigSettings\DataProvider\Analyzer\AnalyzerSettingsProvider.cs (1)

62.OrderBy(g => g.Key, StringComparer.CurrentCulture)

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

NavigateTo\NavigateToItemProvider.cs (1)

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

SignatureHelp\Controller.Session_UpdateModel.cs (6)

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

Completion\AbstractCompletionProviderTests.cs (1)

428=> StringComparer.Ordinal;

Utilities\BloomFilterTests.cs (6)

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

MetadataUtilities.cs (1)

122var refsBySimpleName = new Dictionary<string, ImmutableArray<(AssemblyIdentity, MetadataReference)>>(StringComparer.OrdinalIgnoreCase);

MetadataResolver.cs (6)

28private readonly StringComparer _stringComparer; // for comparing strings 40_stringComparer = ignoreCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal; 283var comparer = _ignoreCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;

VisualBasic\Keywords.cs (1)

16private static ImmutableHashSet<string> GetKeywords(StringComparer comparer)

VisualBasic\MemberSignatureParser.cs (2)

16internal static readonly StringComparer StringComparer = StringComparer.OrdinalIgnoreCase;

VisualBasic\SyntaxKind.cs (1)

40private static ImmutableDictionary<string, SyntaxKind> GetKeywordKinds(StringComparer comparer)

VisualBasicParsingTests.cs (1)

72Assert.Equal(expectedText, pair.Key, StringComparer.OrdinalIgnoreCase);

src\Compilers\Core\Portable\CaseInsensitiveComparison.cs (1)

283public static StringComparer Comparer => s_comparer;

VS\IFSharpWorkspaceProjectContextFactory.cs (2)

108_projectReferences = ImmutableDictionary.Create<string, IFSharpWorkspaceProjectContext>(StringComparer.OrdinalIgnoreCase); 109_metadataReferences = ImmutableHashSet.Create<string>(StringComparer.OrdinalIgnoreCase);

AddImport\AbstractAddImportFeatureService.cs (2)

445return StringComparer.OrdinalIgnoreCase.Equals(path1, path2); 451return path == null ? 0 : StringComparer.OrdinalIgnoreCase.GetHashCode(path);

AddImport\References\MetadataSymbolReference.cs (2)

70StringComparer.OrdinalIgnoreCase.Equals(_reference.FilePath, reference._reference.FilePath); 76StringComparer.OrdinalIgnoreCase.GetHashCode(_reference.FilePath));

AddImport\References\Reference.cs (1)

43diff = StringComparer.OrdinalIgnoreCase.Compare(

AddImport\References\SymbolReference.cs (1)

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

AddImport\SymbolResult.cs (1)

44return StringComparer.OrdinalIgnoreCase.Equals(

CodeLens\LocationComparer.cs (1)

33StringComparer.OrdinalIgnoreCase.GetHashCode(obj.SourceTree.FilePath));

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

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

Completion\CompletionItem.cs (2)

526var result = StringComparer.OrdinalIgnoreCase.Compare(SortText, other.SortText); 529result = StringComparer.OrdinalIgnoreCase.Compare(GetEntireDisplayText(), other.GetEntireDisplayText());

Completion\FileSystemCompletionHelper.cs (2)

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

Completion\Providers\AbstractInternalsVisibleToCompletionProvider.cs (1)

215resultBuilder ??= ImmutableHashSet.CreateBuilder<string>(StringComparer.OrdinalIgnoreCase);

ConvertTupleToStruct\AbstractConvertTupleToStructCodeRefactoringProvider.cs (2)

665private static bool AreEquivalent(StringComparer comparer, INamedTypeSymbol tupleType, INamedTypeSymbol childType) 670StringComparer comparer, ImmutableArray<IFieldSymbol> fields1, ImmutableArray<IFieldSymbol> fields2)

EditAndContinue\ActiveStatementsMap.cs (1)

121byDocumentPath = byDocumentPath.WithComparers(keyComparer: StringComparer.OrdinalIgnoreCase);

EditAndContinue\EditAndContinueMethodDebugInfoReader.cs (1)

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

EmbeddedLanguages\AbstractEmbeddedLanguageFeatureService.cs (4)

75kvp => kvp.Key, kvp => kvp.Value.ToImmutableAndFree(), StringComparer.OrdinalIgnoreCase); 96if (languageIdentifiers.SetEquals(JsonLanguageDetector.LanguageIdentifiers, StringComparer.OrdinalIgnoreCase)) 99if (languageIdentifiers.SetEquals(RegexLanguageDetector.LanguageIdentifiers, StringComparer.OrdinalIgnoreCase)) 102if (languageIdentifiers.SetEquals(DateAndTimeLanguageDetector.LanguageIdentifiers, StringComparer.OrdinalIgnoreCase))

EmbeddedLanguages\EmbeddedLanguageCommentOptions.cs (1)

26.ToDictionary(f => f.Name, f => (TOptions)f.GetValue(null)!, StringComparer.OrdinalIgnoreCase);

EmbeddedLanguages\EmbeddedLanguageDetector.cs (1)

22private readonly HashSet<string> LanguageIdentifiers = new(languageIdentifiers, StringComparer.OrdinalIgnoreCase);

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

57: new HashSet<string>(StringComparer.OrdinalIgnoreCase);

ExternalAccess\UnitTesting\API\UnitTestingSearchHelpers.cs (1)

180StringComparer comparer,

InheritanceMargin\AbstractInheritanceMarginService_Helpers.cs (1)

204? StringComparer.OrdinalIgnoreCase.Compare(syntaxTree1.FilePath, syntaxTree2.FilePath)

MetadataAsSource\DecompilationMetadataAsSourceFileProvider.cs (3)

53private readonly ConcurrentDictionary<string, MetadataAsSourceGeneratedFileInfo> _generatedFilenameToInformation = new(StringComparer.OrdinalIgnoreCase); 432return StringComparer.OrdinalIgnoreCase.Equals(_filePath, other._filePath) && 446Hash.Combine(StringComparer.OrdinalIgnoreCase.GetHashCode(_filePath ?? string.Empty),

NavigateTo\NavigateToUtilities.cs (1)

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

PdbSourceDocument\ImplementationAssemblyLookupService.cs (1)

33private readonly Dictionary<string, Dictionary<(string @namespace, string typeName), string>?> _typeForwardCache = new(StringComparer.OrdinalIgnoreCase);

PdbSourceDocument\PdbSourceDocumentMetadataAsSourceFileProvider.cs (1)

71private readonly ConcurrentDictionary<string, SourceDocumentInfo> _fileToDocumentInfoMap = new(StringComparer.OrdinalIgnoreCase);

src\Analyzers\Core\Analyzers\RemoveUnnecessarySuppressions\AbstractRemoveUnnecessaryPragmaSuppressionsDiagnosticAnalyzer.cs (3)

255userExclusions.Contains(id, StringComparer.OrdinalIgnoreCase)) 793userIdExclusions.Contains(id, StringComparer.OrdinalIgnoreCase) || 794category?.Length > 0 && userCategoryExclusions.Contains(category, StringComparer.OrdinalIgnoreCase))

src\Analyzers\Core\Analyzers\RemoveUnnecessarySuppressions\SuppressMessageAttributeState.cs (1)

27var builder = ImmutableDictionary.CreateBuilder<string, TargetScope>(StringComparer.OrdinalIgnoreCase);

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

199var comparer = syntaxFacts.StringComparer; 434StringComparer comparer,

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

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

src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementInterfaceGenerator.cs (1)

383: StringComparer.OrdinalIgnoreCase.Equals(identifier1, identifier2);

src\Analyzers\Core\CodeFixes\UseNullPropagation\AbstractUseNullPropagationCodeFixProvider.cs (1)

244var comparer = syntaxFacts.StringComparer;

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

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

Interactive\Core\InteractiveHostPlatformInfo.cs (1)

55=> !StringComparer.OrdinalIgnoreCase.Equals(PathUtilities.GetDirectoryName(path), s_hostDirectory);

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

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

src\Compilers\Core\Portable\InternalUtilities\Hash.cs (2)

140internal static int CombineValues(IEnumerable<string?>? values, StringComparer stringComparer, int maxItemsToHash = int.MaxValue) 165internal static int CombineValues(ImmutableArray<string> values, StringComparer stringComparer, int maxItemsToHash = int.MaxValue)

HostWorkspace\FileWatching\LspFileChangeWatcher.cs (3)

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\ProjectDependencyHelper.cs (2)

111.GroupBy(l => l.Name, l => l.Version, StringComparer.OrdinalIgnoreCase) 112.ToImmutableDictionary(g => g.Key, g => g.ToImmutableArray(), StringComparer.OrdinalIgnoreCase);

HostWorkspace\ProjectToLoad.cs (2)

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

Logging\LspLogMessageLoggerProvider.cs (1)

11private readonly ConcurrentDictionary<string, LspLogMessageLogger> _loggers = new(StringComparer.OrdinalIgnoreCase);

Services\ExtensionAssemblyManager.cs (2)

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

Handler\InlineCompletions\InlineCompletionsHandler.cs (1)

139if (!BuiltInSnippets.Contains(wordText, StringComparer.OrdinalIgnoreCase))

Handler\InlineCompletions\XmlSnippetParser.CodeSnippet.cs (1)

60return _snippetTypes?.Contains(ExpansionSnippetType, StringComparer.OrdinalIgnoreCase) == true;

Handler\Rename\RenameHandler.cs (1)

77.GroupBy(docId => renamedSolution.GetRequiredDocument(docId).FilePath, StringComparer.OrdinalIgnoreCase).Select(group => group.First());

Protocol\DocumentUri.cs (1)

132return StringComparer.OrdinalIgnoreCase.GetHashCode(this.ParsedUri.AbsoluteUri);

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

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\Extensions\UriExtensions.cs (1)

15private static readonly ImmutableHashSet<string> s_uriWords = ImmutableHashSet.Create(StringComparer.OrdinalIgnoreCase, "uri", "urn", "url");

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

67var ruleIdToComments = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

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

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

RebuildCommandLineTests.cs (1)

29public Dictionary<string, TestableFile> FilePathToStreamMap { get; } = new Dictionary<string, TestableFile>(StringComparer.OrdinalIgnoreCase);

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\CompilationExtensions.cs (2)

46return guids.Contains(WebAppProjectGuidString, StringComparer.OrdinalIgnoreCase) || 47guids.Contains(WebSiteProjectGuidString, StringComparer.OrdinalIgnoreCase);

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

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

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

15private static readonly ImmutableHashSet<string> s_uriWords = ImmutableHashSet.Create(StringComparer.OrdinalIgnoreCase, "uri", "urn", "url");

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

67var ruleIdToComments = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

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\AssemblyLoader\MetadataShadowCopyProvider.cs (1)

369_lazySuppressedFiles ??= new HashSet<string>(StringComparer.OrdinalIgnoreCase);

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

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

Hosting\ObjectFormatter\ObjectFormatterHelpers.cs (1)

192if (StringComparer.OrdinalIgnoreCase.Equals(memberName, member.Name))

Hosting\Resolvers\RuntimeMetadataReferenceResolver.cs (1)

211var set = ImmutableDictionary.CreateBuilder<string, string>(StringComparer.OrdinalIgnoreCase);

ScriptCompiler.cs (1)

18public abstract StringComparer IdentifierComparer { get; }

src\Compilers\Shared\GlobalAssemblyCacheHelpers\FusionAssemblyIdentity.cs (2)

557if (StringComparer.OrdinalIgnoreCase.Equals(candidateCulture, preferredCultureOpt) || 558candidateCulture.Length == 0 && !StringComparer.OrdinalIgnoreCase.Equals(bestCulture, preferredCultureOpt))

CompilationVerifier.cs (2)

431var readersByName = new Dictionary<string, PEReader>(StringComparer.OrdinalIgnoreCase); 958var fullNameSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

Mocks\VirtualizedRelativePathResolver.cs (1)

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

Platform\CoreClr\TestExecutionLoadContext.cs (3)

32_dependencies = dependencies.ToImmutableDictionary(d => d.FullName, StringComparer.Ordinal); 39var comparer = StringComparer.OrdinalIgnoreCase;

TargetFrameworkUtil.cs (2)

168private static readonly ConcurrentDictionary<string, ImmutableArray<PortableExecutableReference>> s_dynamicReferenceMap = new ConcurrentDictionary<string, ImmutableArray<PortableExecutableReference>>(StringComparer.Ordinal); 349var nameSet = new HashSet<string>(getNames(references), StringComparer.OrdinalIgnoreCase);

TestableFileSystem.cs (2)

54public static TestableFileSystem CreateForExistingPaths(IEnumerable<string> existingPaths, StringComparer? comparer = null) 56comparer ??= StringComparer.OrdinalIgnoreCase;

AssemblyUtilitiesTests.cs (3)

76AssertEx.SetEqual(new[] { satelliteFile }, results, StringComparer.OrdinalIgnoreCase); 89AssertEx.SetEqual(new[] { satelliteFile }, results, StringComparer.OrdinalIgnoreCase); 103AssertEx.SetEqual(new[] { satelliteFileDE, satelliteFileFR }, results, StringComparer.OrdinalIgnoreCase);

CachingLookupTests.cs (10)

73return numbers.ToLookup(n => GetKey(n, randomCase), StringComparer.OrdinalIgnoreCase); 77return numbers.ToLookup(n => GetKey(n, randomCase), StringComparer.Ordinal); 154StringComparer comparer = StringComparer.Ordinal; 186StringComparer comparer = StringComparer.OrdinalIgnoreCase; 218StringComparer comparer = StringComparer.OrdinalIgnoreCase; 248StringComparer comparer = StringComparer.OrdinalIgnoreCase;

Collections\ImmutableArrayExtensionsTests.cs (4)

316dict = System.Linq.ImmutableArrayExtensions.ToDictionary(roa, s => s.Split(':').First(), StringComparer.OrdinalIgnoreCase); 328dict = System.Linq.ImmutableArrayExtensions.ToDictionary(roa, s => s.Split(':').First(), s => s.Split(':').Last(), StringComparer.OrdinalIgnoreCase); 342Assert.True(a.SequenceEqual(b, StringComparer.OrdinalIgnoreCase)); 345Assert.False(a.SequenceEqual(c, StringComparer.OrdinalIgnoreCase));

Collections\ImmutableDictionaryBuilderTestBase.cs (1)

281protected abstract IImmutableDictionary<string, TValue> Empty<TValue>(StringComparer comparer);

Collections\ImmutableDictionaryBuilderTestBase.nonnetstandard.cs (1)

21var builder = Empty<int>(StringComparer.OrdinalIgnoreCase)

Collections\ImmutableDictionaryTestBase.cs (2)

225var dictionary = Empty<int>(StringComparer.OrdinalIgnoreCase) 324protected abstract IImmutableDictionary<string, TValue> Empty<TValue>(StringComparer comparer);

Collections\ImmutableSegmentedDictionaryBuilderTest.cs (12)

Collections\ImmutableSegmentedDictionaryTest.cs (28)

Collections\ImmutableSegmentedHashSetBuilderTest.cs (10)

Collections\ImmutableSegmentedHashSetTest.cs (7)

32ImmutableSegmentedHashSet<string>.Empty.WithComparer(StringComparer.Ordinal), 37ImmutableSegmentedHashSet<string>.Empty.WithComparer(StringComparer.OrdinalIgnoreCase), 47.WithComparer(StringComparer.Ordinal) 53var ignoreCaseSet = ordinalSet.WithComparer(StringComparer.OrdinalIgnoreCase); 112var comparer = StringComparer.OrdinalIgnoreCase; 205var set = ImmutableSegmentedHashSet.Create<string>("a").WithComparer(StringComparer.OrdinalIgnoreCase);

Collections\ImmutableSegmentedHashSetTest.nonnetstandard.cs (3)

24EmptyTestHelper(EmptyTyped<string>().WithComparer(StringComparer.OrdinalIgnoreCase), "a", StringComparer.OrdinalIgnoreCase); 30TryGetValueTestHelper(ImmutableSegmentedHashSet<string>.Empty.WithComparer(StringComparer.OrdinalIgnoreCase));

Collections\ImmutableSegmentedListTest.cs (4)

457Assert.Equal(expectedList.IndexOf(newElement), System.Collections.Immutable.ImmutableList.IndexOf(list, newElement.ToUpperInvariant(), StringComparer.OrdinalIgnoreCase)); 464Assert.Equal(expectedList.IndexOf(existingElement), System.Collections.Immutable.ImmutableList.IndexOf(list, existingElement.ToUpperInvariant(), StringComparer.OrdinalIgnoreCase)); 577var comparer = StringComparer.OrdinalIgnoreCase;

FileUtilitiesTests.cs (1)

203Assert.Equal(expected, actual, StringComparer.OrdinalIgnoreCase);

MetadataReferences\AssemblyIdentityDisplayNameTests.cs (1)

136Assert.Equal("goo, Version=0.0.0.0, Culture=neutral, PublicKeyToken=0123456789abcdef", id.GetDisplayName(), StringComparer.OrdinalIgnoreCase);

MetadataReferences\MetadataHelpersTests.cs (5)

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

src\Compilers\Shared\GlobalAssemblyCacheHelpers\FusionAssemblyIdentity.cs (2)

557if (StringComparer.OrdinalIgnoreCase.Equals(candidateCulture, preferredCultureOpt) || 558candidateCulture.Length == 0 && !StringComparer.OrdinalIgnoreCase.Equals(bestCulture, preferredCultureOpt))

StrongNameProviderTests.cs (6)

41Assert.Equal(subFilePath, path, StringComparer.OrdinalIgnoreCase); 47Assert.Equal(filePath, path, StringComparer.OrdinalIgnoreCase); 58Assert.Equal(filePath, path, StringComparer.OrdinalIgnoreCase); 65Assert.Equal(filePath, path, StringComparer.OrdinalIgnoreCase); 69Assert.Equal(filePath, path, StringComparer.OrdinalIgnoreCase); 93: base(searchPaths.NullToEmpty(), new VirtualStrongNameFileSystem(new HashSet<string>(existingFullPaths, StringComparer.OrdinalIgnoreCase)))

Symbols\MissingModuleSymbol.vb (1)

203Return Hash.Combine(m_Assembly.GetHashCode(), StringComparer.OrdinalIgnoreCase.GetHashCode(_name))

CompilationContext.vb (1)

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

FindSymbols\FindReferences\DependentProjectsFinder.cs (1)

286var set = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

FindSymbols\FindReferences\FindReferenceCache.cs (2)

86LanguageNames.VisualBasic => StringComparer.OrdinalIgnoreCase, 87LanguageNames.CSharp => StringComparer.Ordinal,

FindSymbols\ReferenceLocation.cs (1)

139if ((compare = StringComparer.OrdinalIgnoreCase.Compare(thisPath, otherPath)) != 0 ||

FindSymbols\SearchQuery.cs (1)

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

FindSymbols\SymbolTree\SymbolTreeInfo.cs (5)

30private static readonly StringComparer s_caseInsensitiveComparer = 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 (8)

Recommendations\AbstractRecommendationServiceRunner.cs (1)

27private readonly StringComparer _stringComparerForLanguage;

Shared\Extensions\IFindReferencesResultExtensions.cs (3)

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

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

56internal static readonly StringComparer OriginalPathComparer = StringComparer.Ordinal; 62internal static readonly StringComparer GeneratedPathComparer = StringComparer.Ordinal; 67internal static readonly (StringComparer Comparer, StringComparison Comparison) SimpleNameComparer = (StringComparer.OrdinalIgnoreCase, StringComparison.OrdinalIgnoreCase);

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

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

src\Compilers\Core\Portable\InternalUtilities\Hash.cs (2)

140internal static int CombineValues(IEnumerable<string?>? values, StringComparer stringComparer, int maxItemsToHash = int.MaxValue) 165internal static int CombineValues(ImmutableArray<string> values, StringComparer stringComparer, int maxItemsToHash = int.MaxValue)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EditorConfig\Parsing\Sections\Section.cs (2)

173StringComparer.OrdinalIgnoreCase.Equals(FilePath, other.FilePath) && 179StringComparer.OrdinalIgnoreCase.GetHashCode(FilePath ?? string.Empty),

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

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

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

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

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

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

44new(() => new HashSet<string>(StringComparer.OrdinalIgnoreCase), 20); 50new(() => new HashSet<string>(StringComparer.Ordinal), 20); 75new(() => new Dictionary<string, T>(StringComparer.OrdinalIgnoreCase), 20);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\EditorConfigValueSerializer.cs (2)

128var map = new BidirectionalMap<string, T>(entries, StringComparer.OrdinalIgnoreCase); 129var alternativeMap = ImmutableDictionary<string, T>.Empty.WithComparers(keyComparer: StringComparer.OrdinalIgnoreCase)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\ISyntaxFacts.cs (1)

88StringComparer StringComparer { get; }

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

34var comparer = _options.IgnoreCase 35? StringComparer.OrdinalIgnoreCase 36: StringComparer.Ordinal;

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\NameGenerator.cs (1)

137public static string GenerateUniqueName(string baseName, ISet<string> names, StringComparer comparer)

Workspace\Host\Mef\ExportDynamicFileInfoProviderAttribute.cs (1)

23/// match will be done by <see cref="StringComparer.OrdinalIgnoreCase"/>

Workspace\ProjectSystem\ProjectSystemProject.BatchingDocumentCollection.cs (1)

38private readonly Dictionary<string, DocumentId> _documentPathsToDocumentIds = new(StringComparer.OrdinalIgnoreCase);

Workspace\ProjectSystem\ProjectSystemProject.cs (2)

147private readonly Dictionary<string, string?> _dynamicFilePathMaps = new(StringComparer.OrdinalIgnoreCase); 202StringComparer.Ordinal,

Workspace\ProjectSystem\ProjectSystemProjectFactory.ProjectUpdateState.cs (1)

61ImmutableDictionary<string, ImmutableArray<ProjectId>>.Empty.WithComparers(StringComparer.OrdinalIgnoreCase),

Workspace\Solution\SolutionState.CachingFilePathComparer.cs (2)

32private static readonly StringComparer s_comparer = StringComparer.OrdinalIgnoreCase;

MSBuild\MSBuildProjectLoader.cs (2)

46Properties = ImmutableDictionary.Create<string, string>(StringComparer.OrdinalIgnoreCase); 68Properties = ImmutableDictionary.Create<string, string>(StringComparer.OrdinalIgnoreCase);

MSBuild\MSBuildProjectLoader.SolutionFilterReader.cs (1)

56var filterProjects = ImmutableHashSet.CreateBuilder<string>(StringComparer.OrdinalIgnoreCase);

MSBuild\ProjectFileExtensionRegistry.cs (1)

25_extensionToLanguageMap = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)

src\Compilers\Shared\NamedPipeUtil.cs (1)

64StringComparer.OrdinalIgnoreCase.Equals(serverIdentity.name, clientIdentity.name) &&

MSBuild\ProjectFile\CommandLineArgumentReader.cs (1)

157private static readonly ImmutableDictionary<string, string> s_debugTypeValues = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)

src\Compilers\Core\Portable\CaseInsensitiveComparison.cs (1)

283public static StringComparer Comparer => s_comparer;

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

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

src\Compilers\Core\Portable\InternalUtilities\Hash.cs (2)

140internal static int CombineValues(IEnumerable<string?>? values, StringComparer stringComparer, int maxItemsToHash = int.MaxValue) 165internal static int CombineValues(ImmutableArray<string> values, StringComparer stringComparer, int maxItemsToHash = int.MaxValue)

src\Compilers\Shared\NamedPipeUtil.cs (1)

64StringComparer.OrdinalIgnoreCase.Equals(serverIdentity.name, clientIdentity.name) &&

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

44new(() => new HashSet<string>(StringComparer.OrdinalIgnoreCase), 20); 50new(() => new HashSet<string>(StringComparer.Ordinal), 20); 75new(() => new Dictionary<string, T>(StringComparer.OrdinalIgnoreCase), 20);

FileSet.cs (1)

26var builder = ImmutableDictionary.CreateBuilder<string, object>(StringComparer.OrdinalIgnoreCase);

SolutionGeneration.cs (1)

66var files = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

VisualStudioMSBuildWorkspaceTests.cs (1)

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

SolutionTests\SolutionTests.cs (5)

4632Assert.Equal("test5.cs", syntaxTrees[0].FilePath, StringComparer.OrdinalIgnoreCase); 4633Assert.Equal("test4.cs", syntaxTrees[1].FilePath, StringComparer.OrdinalIgnoreCase); 4634Assert.Equal("test3.cs", syntaxTrees[2].FilePath, StringComparer.OrdinalIgnoreCase); 4635Assert.Equal("test2.cs", syntaxTrees[3].FilePath, StringComparer.OrdinalIgnoreCase); 4636Assert.Equal("test1.cs", syntaxTrees[4].FilePath, StringComparer.OrdinalIgnoreCase);

UtilityTest\ImmutableDictionaryExtensionsTests.cs (2)

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

TypeRef.cs (2)

61var comparer = StringComparer.Ordinal;

DataFrameColumnCollection.cs (1)

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

src\InstallDotNetCore.cs (1)

92properties = proj.AllEvaluatedProperties.ToLookup(p => p.Name, StringComparer.OrdinalIgnoreCase);

PipelinesLogger.cs (3)

49_ignoredTargets = new HashSet<string>(ignoredTargets, StringComparer.OrdinalIgnoreCase); 319internal static StringComparer Comparer => StringComparer.OrdinalIgnoreCase;

ArtifactSet.cs (4)

27.OrderBy(p => p.Id, StringComparer.OrdinalIgnoreCase) 28.ThenBy(p => p.Version, StringComparer.OrdinalIgnoreCase) 31.OrderBy(b => b.Id, StringComparer.OrdinalIgnoreCase) 34.OrderBy(b => b.Id, StringComparer.OrdinalIgnoreCase)

MSBuildListSplitter.cs (2)

15return new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 23var values = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

XElementParsingExtensions.cs (1)

36.ThenBy(pair => pair.Key, StringComparer.OrdinalIgnoreCase)

GenerateNuSpec.cs (5)

266return manifestFiles.OrderBy(f => f.Target, StringComparer.OrdinalIgnoreCase).ToList(); 274orderby fr.ItemSpec, StringComparer.Ordinal 314orderby dependency.Id, StringComparer.Ordinal 326))).OrderBy(s => s?.TargetFramework?.GetShortFolderName(), StringComparer.Ordinal) 344orderby reference.File, StringComparer.Ordinal

HarvestPackage.cs (4)

274var livePackageFiles = new Dictionary<string, PackageItem>(StringComparer.OrdinalIgnoreCase); 510_pathsToExclude = new HashSet<string>(PathsToExclude.NullAsEmpty().Select(NormalizePath), StringComparer.OrdinalIgnoreCase); 522_pathsToInclude = PathsToInclude.NullAsEmpty().ToDictionary(i => NormalizePath(i.ItemSpec), i=> i, StringComparer.OrdinalIgnoreCase); 605return extension != null && extension.Length > 0 && s_includedExtensions.Contains(extension, StringComparer.OrdinalIgnoreCase);

PackageIndex.cs (1)

33public HashSet<string> IndexSources { get; set; } = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

UpdatePackageIndex.cs (1)

97_packageIdsToInclude = new HashSet<string>(PackageIds.Select(i => i.ItemSpec), StringComparer.OrdinalIgnoreCase);

MSBuildListSplitter.cs (1)

14Dictionary<string, string> values = new(StringComparer.OrdinalIgnoreCase);

OptProf\IbcEntry.cs (2)

60return StringComparer.OrdinalIgnoreCase.Equals(ext, ".dll") || 61StringComparer.OrdinalIgnoreCase.Equals(ext, ".exe");

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

Analyzers\BaseAnalyzer.cs (1)

29if (StringComparer.OrdinalIgnoreCase.Equals(line.ToString(), GetType().Name))

Analyzers\MembersMustExistAnalyzer.cs (1)

23private HashSet<string> _apisToEnsureExist = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

Analyzers\PinvokeAnalyzer.cs (2)

67private HashSet<string> _isNotSupportedOnWin7 = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 72Dictionary<string, string> parsedPinvokes = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

GenPartialFacadeSourceGenerator.cs (2)

40if (distinctSeeds.Count() != seedNames.Distinct(StringComparer.InvariantCultureIgnoreCase).Count()) 66var dictionary = new Dictionary<string, string>(StringComparer.Ordinal);

src\UpdatePackageVersionTask.cs (2)

59else if (StringComparer.OrdinalIgnoreCase.Equals(VersionKind, "release")) 63else if (StringComparer.OrdinalIgnoreCase.Equals(VersionKind, "prerelease"))

VerifyClosure.cs (3)

42private HashSet<string> otherFiles = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 43private Dictionary<string, Version> ignoredReferences = new Dictionary<string, Version>(StringComparer.OrdinalIgnoreCase); 352var nodeIds = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

src\CreateFrameworkListFile.cs (3)

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

src\FileUtilities.cs (1)

18StringComparer.OrdinalIgnoreCase);

src\Microsoft.DotNet.PackageTesting\VerifyClosure.cs (3)

42private HashSet<string> otherFiles = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 43private Dictionary<string, Version> ignoredReferences = new Dictionary<string, Version>(StringComparer.OrdinalIgnoreCase); 352var nodeIds = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

src\ValidateFileVersions.cs (1)

22var fileVersions = new Dictionary<string, FileVersionData>(StringComparer.OrdinalIgnoreCase);

src\Hash.cs (1)

119internal static int CombineValues(IEnumerable<string> values, StringComparer stringComparer, int maxItemsToHash = int.MaxValue)

src\SignToolConstants.cs (2)

38public static readonly HashSet<string> SignableExtensions = new HashSet<string>(StringComparer.OrdinalIgnoreCase) 125new HashSet<string>(StringComparer.OrdinalIgnoreCase)

src\SignToolTask.cs (4)

313var map = new Dictionary<string, List<AdditionalCertificateInformation>>(StringComparer.OrdinalIgnoreCase); 408private readonly HashSet<string> specialExtensions = new HashSet<string>(StringComparer.OrdinalIgnoreCase) 415var map = new Dictionary<string, List<SignInfo>>(StringComparer.OrdinalIgnoreCase); 462var map = new Dictionary<string, List<SignInfo>>(StringComparer.OrdinalIgnoreCase);

SignToolTests.cs (2)

2834var needContent = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) 2873var needContent = new Dictionary<string, (string, string[])>(StringComparer.OrdinalIgnoreCase)

src\UsageReport\WritePackageUsageData.cs (1)

196StringComparer.OrdinalIgnoreCase);

src\UsageReport\WriteUsageReports.cs (2)

69StringComparer.OrdinalIgnoreCase); 91var poisonNupkgFilenames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

src\UsageReport\XmlParsingHelpers.cs (2)

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

Languages\Language.cs (1)

56_languages = new Dictionary<string, Language>(StringComparer.OrdinalIgnoreCase)

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

Tasks\GatherXlf.cs (1)

30HashSet<string> outputPaths = new(StringComparer.OrdinalIgnoreCase);

XlfDocumentTests.cs (3)

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

AsyncCollectionAssertsTests.cs (2)

442 Assert.Distinct(list, StringComparer.Ordinal); 450 var ex = Record.Exception(() => Assert.Distinct(list, StringComparer.OrdinalIgnoreCase));

CollectionAssertsTests.cs (10)

DictionaryAssertsTests.cs (6)

18 var dictionary = new Dictionary<string, int>(StringComparer.InvariantCultureIgnoreCase) 28 Assert.Equal(42, Assert.Contains("FORTY-two", dictionary.ToImmutableDictionary(StringComparer.InvariantCultureIgnoreCase))); 29 Assert.Equal(42, Assert.Contains("FORTY-two", (IImmutableDictionary<string, int>)dictionary.ToImmutableDictionary(StringComparer.InvariantCultureIgnoreCase))); 88 var dictionary = new Dictionary<string, int>(StringComparer.InvariantCultureIgnoreCase) 111 assertFailure(() => Assert.DoesNotContain("FORTY-two", dictionary.ToImmutableDictionary(StringComparer.InvariantCultureIgnoreCase))); 112 assertFailure(() => Assert.DoesNotContain("FORTY-two", (IImmutableDictionary<string, int>)dictionary.ToImmutableDictionary(StringComparer.InvariantCultureIgnoreCase)));

SetAssertsTests.cs (8)

17 var set = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "forty-two" }; 21 Assert.Contains("FORTY-two", set.ToSortedSet(StringComparer.OrdinalIgnoreCase)); 26 Assert.Contains("FORTY-two", set.ToImmutableHashSet(StringComparer.OrdinalIgnoreCase)); 27 Assert.Contains("FORTY-two", set.ToImmutableSortedSet(StringComparer.OrdinalIgnoreCase)); 84 var set = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "forty-two" }; 101 assertFailure(() => Assert.DoesNotContain("FORTY-two", set.ToSortedSet(StringComparer.OrdinalIgnoreCase))); 106 assertFailure(() => Assert.DoesNotContain("FORTY-two", set.ToImmutableHashSet(StringComparer.OrdinalIgnoreCase))); 107 assertFailure(() => Assert.DoesNotContain("FORTY-two", set.ToImmutableSortedSet(StringComparer.OrdinalIgnoreCase)));

AlphabeticalOrderer.cs (1)

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

AdditionalPropertiesDictionary{TValue}.cs (3)

33_dictionary = new(StringComparer.OrdinalIgnoreCase); 39_dictionary = new(dictionary, StringComparer.OrdinalIgnoreCase); 46_dictionary = new(collection, StringComparer.OrdinalIgnoreCase);

ChatCompletion\ChatFinishReason.cs (2)

37public bool Equals(ChatFinishReason other) => StringComparer.OrdinalIgnoreCase.Equals(Value, other.Value); 40public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

ChatCompletion\ChatRole.cs (1)

85=> StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

SpeechToText\SpeechToTextResponseUpdateKind.cs (1)

87=> StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

src\Shared\JsonSchemaExporter\JsonSchemaExporter.ReflectionHelpers.cs (1)

413public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Name);

Functions\AIFunctionArgumentsTests.cs (12)

175var comparer = StringComparer.OrdinalIgnoreCase; 191var comparer = StringComparer.OrdinalIgnoreCase; 207var comparer = StringComparer.OrdinalIgnoreCase; 239var comparer = StringComparer.OrdinalIgnoreCase; 263var comparer = StringComparer.OrdinalIgnoreCase; 291var originalDict = new Dictionary<string, object?>(StringComparer.Ordinal) 298var args = new AIFunctionArguments(originalDict, StringComparer.OrdinalIgnoreCase);

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

17var comparer = comparisonType switch 19StringComparison.CurrentCulture => StringComparer.CurrentCulture, 20StringComparison.CurrentCultureIgnoreCase => StringComparer.CurrentCultureIgnoreCase, 21StringComparison.InvariantCulture => StringComparer.InvariantCulture, 22StringComparison.InvariantCultureIgnoreCase => StringComparer.InvariantCultureIgnoreCase, 23StringComparison.Ordinal => StringComparer.Ordinal, 24StringComparison.OrdinalIgnoreCase => StringComparer.OrdinalIgnoreCase,

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

17var comparer = comparisonType switch 19StringComparison.CurrentCulture => StringComparer.CurrentCulture, 20StringComparison.CurrentCultureIgnoreCase => StringComparer.CurrentCultureIgnoreCase, 21StringComparison.InvariantCulture => StringComparer.InvariantCulture, 22StringComparison.InvariantCultureIgnoreCase => StringComparer.InvariantCultureIgnoreCase, 23StringComparison.Ordinal => StringComparer.Ordinal, 24StringComparison.OrdinalIgnoreCase => StringComparer.OrdinalIgnoreCase,

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

17var comparer = comparisonType switch 19StringComparison.CurrentCulture => StringComparer.CurrentCulture, 20StringComparison.CurrentCultureIgnoreCase => StringComparer.CurrentCultureIgnoreCase, 21StringComparison.InvariantCulture => StringComparer.InvariantCulture, 22StringComparison.InvariantCultureIgnoreCase => StringComparer.InvariantCultureIgnoreCase, 23StringComparison.Ordinal => StringComparer.Ordinal, 24StringComparison.OrdinalIgnoreCase => StringComparer.OrdinalIgnoreCase,

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)

Internal\TagSet.cs (1)

41Array.Sort(tags, StringComparer.InvariantCulture);

ConfigurationProvider.cs (1)

24Data = new Dictionary<string, string?>(StringComparer.OrdinalIgnoreCase);

InternalConfigurationRootExtensions.cs (1)

29.Distinct(StringComparer.OrdinalIgnoreCase)

ConfigurationBinder.cs (2)

230StringComparer.OrdinalIgnoreCase); 583HashSet<string> propertyNames = new(StringComparer.OrdinalIgnoreCase);

CommandLineConfigurationProvider.cs (2)

43var data = new Dictionary<string, string?>(StringComparer.OrdinalIgnoreCase); 140var switchMappingsCopy = new Dictionary<string, string>(switchMappings.Count, StringComparer.OrdinalIgnoreCase);

EnvironmentVariablesConfigurationProvider.cs (1)

64var data = new Dictionary<string, string?>(StringComparer.OrdinalIgnoreCase);

FileConfigurationProvider.cs (2)

63Data = new Dictionary<string, string?>(StringComparer.OrdinalIgnoreCase); 105Data = new Dictionary<string, string?>(StringComparer.OrdinalIgnoreCase);

IniStreamConfigurationProvider.cs (1)

28var data = new Dictionary<string, string?>(StringComparer.OrdinalIgnoreCase);

JsonConfigurationFileParser.cs (1)

16private readonly Dictionary<string, string?> _data = new Dictionary<string, string?>(StringComparer.OrdinalIgnoreCase);

KeyPerFileConfigurationProvider.cs (1)

60var data = new Dictionary<string, string?>(StringComparer.OrdinalIgnoreCase);

ConfigurationProviderTestBase.cs (63)

XmlStreamConfigurationProvider.cs (2)

94var children = new Dictionary<string, List<XmlConfigurationElement>>(StringComparer.OrdinalIgnoreCase); 257Dictionary<string, string?> configuration = new(StringComparer.OrdinalIgnoreCase);

CollectionExtensions.netcoreapp.cs (1)

15return collection.ToDictionary(l => l.Name, StringComparer.OrdinalIgnoreCase);

DependencyContext.cs (2)

86return StringComparer.OrdinalIgnoreCase.Equals(x?.Name, y?.Name); 91return StringComparer.OrdinalIgnoreCase.GetHashCode(obj.Name);

DefaultHealthCheckService.cs (2)

62var entries = new Dictionary<string, HealthReportEntry>(StringComparer.OrdinalIgnoreCase); 165var distinctRegistrations = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

HealthCheckRegistration.cs (2)

68Tags = new HashSet<string>(tags ?? Array.Empty<string>(), StringComparer.OrdinalIgnoreCase); 120Tags = new HashSet<string>(tags ?? Array.Empty<string>(), StringComparer.OrdinalIgnoreCase);

Linux\Resources\HardcodedValueFileSystem.cs (1)

27_fileContent = fileContent.ToDictionary(static x => x.Key.FullName, static y => y.Value, StringComparer.OrdinalIgnoreCase);

Linux\Resources\TestResources.cs (1)

15private static readonly Dictionary<string, string> _files = new(StringComparer.OrdinalIgnoreCase)

EmbeddedFileProviderTests.cs (1)

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

PhysicalFilesWatcher.cs (2)

29private readonly ConcurrentDictionary<string, ChangeTokenInfo> _filePathTokenLookup = new(StringComparer.OrdinalIgnoreCase); 30private readonly ConcurrentDictionary<string, ChangeTokenInfo> _wildcardTokenLookup = new(StringComparer.OrdinalIgnoreCase);

PollingWildCardChangeToken.cs (1)

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

FilePatternMatch.cs (1)

73value != null ? StringComparer.OrdinalIgnoreCase.GetHashCode(value) : 0;

Util\StringComparisonHelper.cs (7)

10public static StringComparer GetStringComparer(StringComparison comparisonType) => comparisonType switch 12StringComparison.CurrentCulture => StringComparer.CurrentCulture, 13StringComparison.CurrentCultureIgnoreCase => StringComparer.CurrentCultureIgnoreCase, 14StringComparison.Ordinal => StringComparer.Ordinal, 15StringComparison.OrdinalIgnoreCase => StringComparer.OrdinalIgnoreCase, 16StringComparison.InvariantCulture => StringComparer.InvariantCulture, 17StringComparison.InvariantCultureIgnoreCase => StringComparer.InvariantCultureIgnoreCase,

DefaultHttpClientFactory.cs (1)

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

DependencyInjection\HttpClientBuilderExtensions.cs (1)

584var sensitiveHeaders = new HashSet<string>(redactedLoggedHeaderNames, StringComparer.OrdinalIgnoreCase);

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\HttpHeadersReader.cs (2)

32_requestHeadersToLog = options.RequestHeadersDataClasses.ToFrozenDictionary(StringComparer.OrdinalIgnoreCase); 33_responseHeadersToLog = options.ResponseHeadersDataClasses.ToFrozenDictionary(StringComparer.OrdinalIgnoreCase);

Logging\Internal\HttpRequestBodyReader.cs (1)

38_readableRequestContentTypes = requestOptions.RequestBodyContentTypes.ToFrozenSet(StringComparer.OrdinalIgnoreCase);

Logging\Internal\HttpRequestReader.cs (1)

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

Logging\Internal\HttpResponseBodyReader.cs (1)

37_readableResponseContentTypes = responseOptions.ResponseBodyContentTypes.ToFrozenSet(StringComparer.OrdinalIgnoreCase);

Logging\MediaTypeCollectionExtensionsTest.cs (4)

27var collection = new HashSet<string>(_readableContentTypes, StringComparer.OrdinalIgnoreCase).ToFrozenSet(StringComparer.OrdinalIgnoreCase); 44var collection = new HashSet<string>(_readableContentTypes, StringComparer.OrdinalIgnoreCase).ToFrozenSet(StringComparer.OrdinalIgnoreCase);

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

Helpers\ConfigurationStubFactory.cs (1)

40Data = new Dictionary<string, string?>(data, StringComparer.OrdinalIgnoreCase);

Routing\RoutingStrategyTest.cs (1)

192Data = new Dictionary<string, string?>(data, StringComparer.OrdinalIgnoreCase);

LoggerFactory.cs (1)

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

ConsoleLoggerProvider.cs (1)

102var cd = new ConcurrentDictionary<string, ConsoleFormatter>(StringComparer.OrdinalIgnoreCase);

LoggerMessageGenerator.Parser.cs (2)

645HashSet<string> shadowedNames = new(StringComparer.Ordinal); 876public readonly Dictionary<string, string> TemplateMap = new(StringComparer.OrdinalIgnoreCase);

TraceSourceLoggerProvider.cs (1)

20private readonly ConcurrentDictionary<string, DiagnosticsTraceSource> _sources = new ConcurrentDictionary<string, DiagnosticsTraceSource>(StringComparer.OrdinalIgnoreCase);

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

18= new StringSegmentComparer(StringComparison.Ordinal, StringComparer.Ordinal); 24= new StringSegmentComparer(StringComparison.OrdinalIgnoreCase, StringComparer.OrdinalIgnoreCase); 26private StringSegmentComparer(StringComparison comparison, StringComparer comparer) 33private StringComparer Comparer { get; }

Http\ResolvingHttpDelegatingHandler.cs (1)

115if (options.AllowAllSchemes || options.AllowedSchemes.Contains(scheme, StringComparer.OrdinalIgnoreCase))

ServiceDiscoveryDestinationResolver.cs (1)

115if (_options.AllowAllSchemes || _options.AllowedSchemes.Contains(scheme, StringComparer.OrdinalIgnoreCase))

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

160bool parameterInTemplate = lm.Templates.Contains(lp.TagName, StringComparer.OrdinalIgnoreCase) || 161lm.Templates.Contains(lp.ParameterNameWithAtIfNeeded, StringComparer.OrdinalIgnoreCase) || 162lm.Templates.Contains($"@{lp.ParameterName}", StringComparer.OrdinalIgnoreCase); 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);

Handlers\HybridWebView\FileExtensionContentTypeProvider.cs (1)

30 : this(new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)

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

Visuals\VisualTypeConverter.cs (1)

28 var mappings = new Dictionary<string, IVisual>(StringComparer.OrdinalIgnoreCase);

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

ColorDesignTypeConverter.cs (1)

170 knowValuesSet = new HashSet<string>(knownValues, StringComparer.OrdinalIgnoreCase);

VisibilityDesignTypeConverter.cs (1)

10 private static readonly HashSet<string> supportedValues = new HashSet<string>(validValues, StringComparer.OrdinalIgnoreCase);

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

Text\TextColors.cs (1)

9 public static Dictionary<string, string> StandardColors = new(StringComparer.OrdinalIgnoreCase)

Renderer\SimpleCssParser.cs (1)

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

ColorTable.cs (1)

17 var colors = new Dictionary<string, SKColor>(StringComparer.OrdinalIgnoreCase);

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)

Extension\ModuleExtension.cs (2)

257foreach (var (key, value) in stateDict.OrderBy(x => x.Key, StringComparer.OrdinalIgnoreCase)) 275foreach (var (key, value) in stateDict.OrderBy(x => x.Key, StringComparer.OrdinalIgnoreCase))

MLImage.cs (1)

427private static readonly Dictionary<string, SKEncodedImageFormat> _extensionToEncodingFormat = new Dictionary<string, SKEncodedImageFormat>(StringComparer.OrdinalIgnoreCase)

Model\TiktokenTokenizer.cs (2)

1043new Dictionary<string, ModelEncoding>(StringComparer.OrdinalIgnoreCase) 1215private static readonly ConcurrentDictionary<string, (Dictionary<ReadOnlyMemory<byte>, int> encoder, Dictionary<StringSpanOrdinalKey, (int Id, string Token)> vocab, Dictionary<int, ReadOnlyMemory<byte>> decoder)> _tiktokenCache = new(StringComparer.OrdinalIgnoreCase);

Microsoft\VisualBasic\Collection.vb (2)

340m_KeyedNodesHash = New Generic.Dictionary(Of String, Node)(StartingHashCapacity, StringComparer.Create(CultureInfo, ignoreCase:=True)) 342m_KeyedNodesHash = New Generic.Dictionary(Of String, Node)(StringComparer.Create(CultureInfo, ignoreCase:=True))

DocumentationComments\VisualStudioDocumentationProvider.cs (1)

67=> StringComparer.OrdinalIgnoreCase.GetHashCode(_filePath);

DocumentOutline\DocumentSymbolDataViewModelSorter.cs (1)

53=> StringComparer.OrdinalIgnoreCase.Compare(x.Data.Name, y.Data.Name);

EditorConfigSettings\SettingsEditorFactory.cs (1)

71if (!workspace.CurrentSolution.Projects.Any(p => p.AnalyzerConfigDocuments.Any(editorconfig => StringComparer.OrdinalIgnoreCase.Equals(editorconfig.FilePath, filePath))))

GenerateType\GenerateTypeDialogViewModel.cs (1)

368if (this.FullFilePath.Split(['\\'], StringSplitOptions.RemoveEmptyEntries).Any(s => _reservedKeywords.Contains(s, StringComparer.OrdinalIgnoreCase)))

ProjectSystem\Extensions\ProjectExtensions.cs (2)

45while (currentItems.FindItem(folderName, StringComparer.OrdinalIgnoreCase) != null) 54public static ProjectItem? FindItemByPath(this EnvDTE.Project project, string itemFilePath, StringComparer comparer)

ProjectSystem\Extensions\ProjectItemExtensions.cs (1)

13public static ProjectItem FindItem(this ProjectItem item, string itemName, StringComparer comparer)

ProjectSystem\Extensions\ProjectItemsExtensions.cs (4)

16public static ProjectItem FindItem(this ProjectItems items, string itemName, StringComparer comparer) 21var item = items.FindItem(folderName, StringComparer.OrdinalIgnoreCase); 26=> NameGenerator.GenerateUniqueName(itemName, extension, n => items.FindItem(n, StringComparer.OrdinalIgnoreCase) == null); 32var foundItem = items.FindItem(n, StringComparer.OrdinalIgnoreCase);

ProjectSystem\MetadataReferences\VisualStudioFrameworkAssemblyPathResolverFactory.cs (1)

136if (StringComparer.OrdinalIgnoreCase.Equals(frameworkName.Identifier, ".NETCore") &&

ProjectSystem\MetadataReferences\VisualStudioMetadataReferenceManager.cs (1)

59private readonly Dictionary<string, (DateTime lastWriteTime, AssemblyMetadata metadata)> _metadataCache = new(StringComparer.OrdinalIgnoreCase);

ProjectSystem\OpenTextBufferProvider.cs (1)

48private ImmutableDictionary<string, ITextBuffer> _monikerToTextBufferMap = ImmutableDictionary<string, ITextBuffer>.Empty.WithComparers(StringComparer.OrdinalIgnoreCase);

ProjectSystem\RuleSets\RuleSetEventHandler.cs (2)

87var ruleSetRenames = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 184var ruleSetDeletions = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

ProjectSystem\VisualStudioWorkspaceImpl.AddMetadataReferenceUndoUnit.cs (1)

36.FirstOrDefault(p => StringComparer.OrdinalIgnoreCase.Equals(p.FilePath, _filePath));

ProjectSystem\VisualStudioWorkspaceImpl.cs (3)

626if (StringComparer.OrdinalIgnoreCase.Equals(reference.Path, filePath)) 834var folderItem = items.FirstOrDefault(p => StringComparer.OrdinalIgnoreCase.Compare(p.Name, folder) == 0); 1295var projectItemForDocument = dteProject.FindItemByPath(document.FilePath, StringComparer.OrdinalIgnoreCase);

ProjectSystem\VisualStudioWorkspaceImpl.RemoveMetadataReferenceUndoUnit.cs (1)

35.FirstOrDefault(p => StringComparer.OrdinalIgnoreCase.Equals(p.FilePath!, _filePath));

Snippets\AbstractSnippetInfoService.cs (2)

216return new HashSet<string>(updatedSnippets.Select(s => s.Shortcut), StringComparer.OrdinalIgnoreCase) 217.ToImmutableHashSet(StringComparer.OrdinalIgnoreCase);

src\Compilers\Core\Portable\FileKey.cs (1)

46StringComparer.OrdinalIgnoreCase.GetHashCode(this.FullPath),

UnusedReferences\Dialog\UnusedReferencesTableProvider.ColumnDefinitions.cs (1)

341public ImageEntryBucket(ImageMoniker imageMoniker, string name, object? tooltip = null, StringComparer? comparer = null, bool expandedByDefault = true)

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

DocumentOutline\DocumentOutlineTests.cs (1)

108SortOption.Name => sortedSymbols.OrderBy(static x => x.Data.Name, StringComparer.OrdinalIgnoreCase),

ProjectSystemShim\CPS\SourceFileHandlingTests.cs (21)

Client\RemoteLanguageServiceWorkspaceHost.cs (2)

37private ImmutableDictionary<string, ProjectId> _loadedProjects = ImmutableDictionary.Create<string, ProjectId>(StringComparer.OrdinalIgnoreCase); 38private ImmutableDictionary<string, ProjectInfo> _loadedProjectInfo = ImmutableDictionary.Create<string, ProjectInfo>(StringComparer.OrdinalIgnoreCase);

Implementation\XamlProjectService.cs (1)

38private readonly ConcurrentDictionary<string, DocumentId> _documentIds = new ConcurrentDictionary<string, DocumentId>(StringComparer.OrdinalIgnoreCase);

AssemblyNameExtension.cs (1)

489int hash = StringComparer.OrdinalIgnoreCase.GetHashCode(this.Name);

CommandLineSwitches.cs (2)

599commandLineA.Sort(StringComparer.OrdinalIgnoreCase); 600commandLineB.Sort(StringComparer.OrdinalIgnoreCase);

CommunicationsUtilities.cs (1)

412Dictionary<string, string> table = new Dictionary<string, string>(vars.Count, StringComparer.OrdinalIgnoreCase);

CopyOnWriteDictionary.cs (2)

44private static readonly ImmutableDictionary<string, V> OrdinalIgnoreCaseComparerDictionaryPrototype = ImmutableDictionary.Create<string, V>(StringComparer.OrdinalIgnoreCase); 92: keyComparer == StringComparer.OrdinalIgnoreCase

CoreCLRAssemblyLoader.cs (2)

22private readonly Dictionary<string, Assembly> _pathsToAssemblies = new Dictionary<string, Assembly>(StringComparer.OrdinalIgnoreCase); 24private readonly HashSet<string> _dependencyPaths = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

EscapingUtilities.cs (1)

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

FileUtilities.cs (4)

67internal static readonly StringComparer PathComparer = GetIsFileSystemCaseSensitive() ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase; 133private static readonly ConcurrentDictionary<string, bool> FileExistenceCache = new ConcurrentDictionary<string, bool>(StringComparer.OrdinalIgnoreCase);

Modifiers.cs (1)

72private static readonly HashSet<string> s_tableOfItemSpecModifiers = new HashSet<string>(All, StringComparer.OrdinalIgnoreCase);

MSBuildNameIgnoreCaseComparer.cs (1)

190return StringComparer.OrdinalIgnoreCase.GetHashCode(obj.Substring(start, length));

OutOfProcTaskAppDomainWrapperBase.cs (1)

360IDictionary<string, Object> finalParameterValues = new Dictionary<string, Object>(StringComparer.OrdinalIgnoreCase);

OutOfProcTaskHostNode.cs (3)

1051updatedEnvironment = new Dictionary<string, string>(environment, StringComparer.OrdinalIgnoreCase); 1111updatedEnvironment ??= new Dictionary<string, string>(environment, StringComparer.OrdinalIgnoreCase); 1150s_mismatchedEnvironmentValues = new Dictionary<string, KeyValuePair<string, string>>(StringComparer.OrdinalIgnoreCase);

TaskHostConfiguration.cs (7)

199_taskParameters = new Dictionary<string, TaskParameter>(StringComparer.OrdinalIgnoreCase); 415translator.TranslateDictionary(ref _buildProcessEnvironment, StringComparer.OrdinalIgnoreCase); 441translator.TranslateDictionary(ref _taskParameters, StringComparer.OrdinalIgnoreCase, TaskParameter.FactoryForDeserialization); 443translator.TranslateDictionary(ref _globalParameters, StringComparer.OrdinalIgnoreCase); 449collectionFactory: count => new HashSet<string>(count, StringComparer.OrdinalIgnoreCase)); 456collectionFactory: count => new HashSet<string>(count, StringComparer.OrdinalIgnoreCase)); 463collectionFactory: count => new HashSet<string>(count, StringComparer.OrdinalIgnoreCase));

TaskHostTaskComplete.cs (4)

120_taskOutputParameters = new Dictionary<string, TaskParameter>(StringComparer.OrdinalIgnoreCase); 198_taskOutputParameters = new Dictionary<string, TaskParameter>(StringComparer.OrdinalIgnoreCase); 244translator.TranslateDictionary(ref _taskOutputParameters, StringComparer.OrdinalIgnoreCase, TaskParameter.FactoryForDeserialization); 245translator.TranslateDictionary(ref _buildProcessEnvironment, StringComparer.OrdinalIgnoreCase);

TaskParameter.cs (7)

302escapedMetadata = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 320escapedMetadata = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 429escapedGenericWrappedMetadata = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 453translator.TranslateDictionary(ref escapedGenericWrappedMetadata, StringComparer.OrdinalIgnoreCase); 474translator.TranslateDictionary(ref escapedMetadata, StringComparer.OrdinalIgnoreCase); 852_customEscapedMetadata ??= new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 922IDictionary<string, string> clonedMetadata = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

TypeLoader.cs (3)

311_typeNameToType = new(StringComparer.OrdinalIgnoreCase); 312_publicTypeNameToType = new Dictionary<string, Type>(StringComparer.OrdinalIgnoreCase); 313_publicTypeNameToLoadedType = new(StringComparer.OrdinalIgnoreCase);

XMake.cs (3)

3281ISet<string> warningSwitches = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 3559HashSet<string> extensionsToIgnore = new HashSet<string>(projectsExtensionsToIgnore ?? [], StringComparer.OrdinalIgnoreCase); 3773Dictionary<string, string> properties = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

XMakeAttributes.cs (3)

106private static readonly HashSet<string> KnownSpecialTaskAttributesIgnoreCase = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { condition, continueOnError, msbuildRuntime, msbuildArchitecture, xmlns }; 110private static readonly HashSet<string> ValidMSBuildRuntimeValues = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { MSBuildRuntimeValues.clr2, MSBuildRuntimeValues.clr4, MSBuildRuntimeValues.currentRuntime, MSBuildRuntimeValues.net, MSBuildRuntimeValues.any }; 112private static readonly HashSet<string> ValidMSBuildArchitectureValues = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { MSBuildArchitectureValues.x86, MSBuildArchitectureValues.x64, MSBuildArchitectureValues.arm64, MSBuildArchitectureValues.currentArchitecture, MSBuildArchitectureValues.any };

AssemblyNameExtension.cs (1)

489int hash = StringComparer.OrdinalIgnoreCase.GetHashCode(this.Name);

BinaryTranslator.cs (2)

767public void TranslateDictionary(ref Dictionary<string, DateTime> dictionary, StringComparer comparer) 1568public void TranslateDictionary(ref Dictionary<string, DateTime> dictionary, StringComparer comparer)

BuildExceptionBase.cs (1)

136customKeyedSerializedData = new Dictionary<string, string?>(count, StringComparer.CurrentCulture);

CommunicationsUtilities.cs (1)

303Dictionary<string, string> table = new Dictionary<string, string>(200, StringComparer.OrdinalIgnoreCase); // Razzle has 150 environment variables

EscapingUtilities.cs (1)

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

FileUtilities.cs (4)

67internal static readonly StringComparer PathComparer = GetIsFileSystemCaseSensitive() ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase; 133private static readonly ConcurrentDictionary<string, bool> FileExistenceCache = new ConcurrentDictionary<string, bool>(StringComparer.OrdinalIgnoreCase);

ITranslator.cs (1)

325void TranslateDictionary(ref Dictionary<string, DateTime> dictionary, StringComparer comparer);

Modifiers.cs (1)

72private static readonly HashSet<string> s_tableOfItemSpecModifiers = new HashSet<string>(All, StringComparer.OrdinalIgnoreCase);

OutOfProcTaskAppDomainWrapperBase.cs (1)

360IDictionary<string, Object> finalParameterValues = new Dictionary<string, Object>(StringComparer.OrdinalIgnoreCase);

OutOfProcTaskHostNode.cs (3)

1051updatedEnvironment = new Dictionary<string, string>(environment, StringComparer.OrdinalIgnoreCase); 1111updatedEnvironment ??= new Dictionary<string, string>(environment, StringComparer.OrdinalIgnoreCase); 1150s_mismatchedEnvironmentValues = new Dictionary<string, KeyValuePair<string, string>>(StringComparer.OrdinalIgnoreCase);

TaskHostConfiguration.cs (7)

199_taskParameters = new Dictionary<string, TaskParameter>(StringComparer.OrdinalIgnoreCase); 415translator.TranslateDictionary(ref _buildProcessEnvironment, StringComparer.OrdinalIgnoreCase); 441translator.TranslateDictionary(ref _taskParameters, StringComparer.OrdinalIgnoreCase, TaskParameter.FactoryForDeserialization); 443translator.TranslateDictionary(ref _globalParameters, StringComparer.OrdinalIgnoreCase); 447collectionFactory: count => new HashSet<string>(StringComparer.OrdinalIgnoreCase)); 454collectionFactory: count => new HashSet<string>(StringComparer.OrdinalIgnoreCase)); 461collectionFactory: count => new HashSet<string>(StringComparer.OrdinalIgnoreCase));

TaskHostTaskComplete.cs (4)

120_taskOutputParameters = new Dictionary<string, TaskParameter>(StringComparer.OrdinalIgnoreCase); 198_taskOutputParameters = new Dictionary<string, TaskParameter>(StringComparer.OrdinalIgnoreCase); 244translator.TranslateDictionary(ref _taskOutputParameters, StringComparer.OrdinalIgnoreCase, TaskParameter.FactoryForDeserialization); 245translator.TranslateDictionary(ref _buildProcessEnvironment, StringComparer.OrdinalIgnoreCase);

TaskParameter.cs (7)

302escapedMetadata = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 320escapedMetadata = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 429escapedGenericWrappedMetadata = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 453translator.TranslateDictionary(ref escapedGenericWrappedMetadata, StringComparer.OrdinalIgnoreCase); 474translator.TranslateDictionary(ref escapedMetadata, StringComparer.OrdinalIgnoreCase); 852_customEscapedMetadata ??= new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 922IDictionary<string, string> clonedMetadata = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

TypeLoader.cs (2)

228_typeNameToType = new Concurrent.ConcurrentDictionary<string, Type>(StringComparer.OrdinalIgnoreCase); 229_publicTypeNameToType = new Dictionary<string, Type>(StringComparer.OrdinalIgnoreCase);

XMakeAttributes.cs (3)

106private static readonly HashSet<string> KnownSpecialTaskAttributesIgnoreCase = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { condition, continueOnError, msbuildRuntime, msbuildArchitecture, xmlns }; 110private static readonly HashSet<string> ValidMSBuildRuntimeValues = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { MSBuildRuntimeValues.clr2, MSBuildRuntimeValues.clr4, MSBuildRuntimeValues.currentRuntime, MSBuildRuntimeValues.net, MSBuildRuntimeValues.any }; 112private static readonly HashSet<string> ValidMSBuildArchitectureValues = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { MSBuildArchitectureValues.x86, MSBuildArchitectureValues.x64, MSBuildArchitectureValues.arm64, MSBuildArchitectureValues.currentArchitecture, MSBuildArchitectureValues.any };

src\libraries\shims\mscorlib\ref\mscorlib.cs (1)

1085[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.StringComparer))]

Startup.cs (1)

73foreach (var key in vars.Keys.Cast<string>().OrderBy(key => key, StringComparer.OrdinalIgnoreCase))

netstandard.cs (1)

2019[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.StringComparer))]

MS\Internal\Tasks\IncrementalCompileAnalyzer.cs (1)

391HashSet<string> localMarkupPages = new HashSet<string>(_mcPass1.PageMarkup.Select(x => x.GetMetadata(SharedStrings.FullPath)), StringComparer.OrdinalIgnoreCase);

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

842Dictionary<string, SpecialBracketCharacters> cache = new Dictionary<string, SpecialBracketCharacters>(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))

src\Microsoft.DotNet.Wpf\src\Shared\System\Windows\Markup\ReflectionHelper.cs (2)

60_cachedMetadataLoadContextAssemblies = new Dictionary<string, Assembly>(StringComparer.OrdinalIgnoreCase); 61_cachedMetadataLoadContextAssembliesByNameNoExtension = new Dictionary<string, Assembly>(StringComparer.OrdinalIgnoreCase);

MS\Internal\FontCache\FamilyCollection.cs (1)

473Dictionary<string, Text.TextInterface.Font> faces = new Dictionary<string, Text.TextInterface.Font>(StringComparer.OrdinalIgnoreCase);

MS\Internal\FontCache\FontResourceCache.cs (1)

82folderResourceMap = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);

MS\Internal\Resources\ContentFileHelper.cs (1)

63contentFiles = new HashSet<string>(assemblyAttributes.Length, StringComparer.OrdinalIgnoreCase);

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

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

MS\Internal\IO\Packaging\XamlFilter.cs (1)

102_lcidDictionary = new Dictionary<string, uint>(StringComparer.OrdinalIgnoreCase);

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

51_defaultComparer = StringComparer.Create(_defaultCulture, true);

System\Windows\Markup\ParserContext.cs (1)

842Dictionary<string, SpecialBracketCharacters> cache = new Dictionary<string, SpecialBracketCharacters>(StringComparer.OrdinalIgnoreCase);

System\Windows\ThemeMode.cs (1)

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

Replay.cs (2)

151var outputSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 225var hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

src\Compilers\Shared\NamedPipeUtil.cs (1)

64StringComparer.OrdinalIgnoreCase.Equals(serverIdentity.name, clientIdentity.name) &&

CompilerPackage.cs (1)

68var filesToWrite = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

src\RoslynAnalyzers\Utilities\Compiler\Extensions\CompilationExtensions.cs (2)

46return guids.Contains(WebAppProjectGuidString, StringComparer.OrdinalIgnoreCase) || 47guids.Contains(WebSiteProjectGuidString, StringComparer.OrdinalIgnoreCase);

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

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

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

15private static readonly ImmutableHashSet<string> s_uriWords = ImmutableHashSet.Create(StringComparer.OrdinalIgnoreCase, "uri", "urn", "url");

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

67var ruleIdToComments = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

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

UseEndpointRoutingStartup.cs (1)

39foreach (var endpoint in dataSource.Endpoints.OfType<RouteEndpoint>().OrderBy(e => e.RoutePattern.RawText, StringComparer.OrdinalIgnoreCase))

UseEndpointRoutingStartup.cs (1)

45foreach (var endpoint in dataSource.Endpoints.OfType<RouteEndpoint>().OrderBy(e => e.RoutePattern.RawText, StringComparer.OrdinalIgnoreCase))

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

67var ruleIdToComments = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

Program.cs (1)

23StringComparer.OrdinalIgnoreCase,

Http\ClientCredentialTypeTests.4.1.0.cs (1)

127Assert.Equal("100-Continue", expectHeader, StringComparer.OrdinalIgnoreCase);

Https\HttpsTests.4.1.0.cs (1)

438Assert.Equal("100-Continue", expectHeader, StringComparer.OrdinalIgnoreCase);

JsonSchemaExporter\JsonSchemaExporter.ReflectionHelpers.cs (1)

413public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Name);

ConnectionList.cs (1)

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

ConnectionList.cs (1)

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

Template.cs (1)

16StringComparer.OrdinalIgnoreCase);

Microsoft\CSharp\CSharpCodeGenerator.cs (1)

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

Microsoft\VisualBasic\VBCodeGenerator.cs (1)

2237var importList = new SortedSet<string>(StringComparer.OrdinalIgnoreCase);

src\libraries\Common\src\System\IO\TempFileCollection.cs (1)

41_files = new Hashtable(StringComparer.OrdinalIgnoreCase);

System\CodeDom\CodeNamespaceImportCollection.cs (1)

12private readonly Dictionary<string, CodeNamespaceImport> _keys = new Dictionary<string, CodeNamespaceImport>(StringComparer.OrdinalIgnoreCase);

System\CodeDom\Compiler\CodeDomProvider.cs (2)

16private static readonly Dictionary<string, CompilerInfo> s_compilerLanguages = new Dictionary<string, CompilerInfo>(StringComparer.OrdinalIgnoreCase); 17private static readonly Dictionary<string, CompilerInfo> s_compilerExtensions = new Dictionary<string, CompilerInfo>(StringComparer.OrdinalIgnoreCase);

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

205(ReferenceEquals(comparer, EqualityComparer<TKey>.Default) || ReferenceEquals(comparer, StringComparer.Ordinal) || ReferenceEquals(comparer, StringComparer.OrdinalIgnoreCase))) 232KeyAnalyzer.AnalysisResults analysis = KeyAnalyzer.Analyze(keys, ReferenceEquals(stringComparer, StringComparer.OrdinalIgnoreCase), minLength, maxLength);

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

136(ReferenceEquals(comparer, EqualityComparer<T>.Default) || ReferenceEquals(comparer, StringComparer.Ordinal) || ReferenceEquals(comparer, StringComparer.OrdinalIgnoreCase))) 164KeyAnalyzer.AnalysisResults analysis = KeyAnalyzer.Analyze(entries, ReferenceEquals(stringComparer, StringComparer.OrdinalIgnoreCase), minLength, maxLength);

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

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

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

23Debug.Assert(comparer == EqualityComparer<string>.Default || comparer == StringComparer.Ordinal || comparer == StringComparer.OrdinalIgnoreCase); 29_ignoreCase = ReferenceEquals(comparer, StringComparer.OrdinalIgnoreCase); 96if (StringComparer.OrdinalIgnoreCase.Equals(key, keys[index]))

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

21Debug.Assert(comparer == EqualityComparer<string>.Default || comparer == StringComparer.Ordinal || comparer == StringComparer.OrdinalIgnoreCase); 26_ignoreCase = ReferenceEquals(comparer, StringComparer.OrdinalIgnoreCase); 91if (StringComparer.OrdinalIgnoreCase.Equals(item, items[index]))

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

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

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

27private protected override bool Equals(string? x, string? y) => StringComparer.OrdinalIgnoreCase.Equals(x, y);

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

27private protected override bool Equals(string? x, string? y) => StringComparer.OrdinalIgnoreCase.Equals(x, y);

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

25private protected override bool Equals(string? x, string? y) => StringComparer.OrdinalIgnoreCase.Equals(x, y);

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

25private protected override bool Equals(string? x, string? y) => StringComparer.OrdinalIgnoreCase.Equals(x, y);

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

25private protected override bool Equals(string? x, string? y) => StringComparer.OrdinalIgnoreCase.Equals(x, y);

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

25private protected override bool Equals(string? x, string? y) => StringComparer.OrdinalIgnoreCase.Equals(x, y);

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

26private protected override bool Equals(string? x, string? y) => StringComparer.OrdinalIgnoreCase.Equals(x, y);

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

26private protected override bool Equals(string? x, string? y) => StringComparer.OrdinalIgnoreCase.Equals(x, y);

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

24private protected override bool Equals(string? x, string? y) => StringComparer.OrdinalIgnoreCase.Equals(x, y);

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

24private protected override bool Equals(string? x, string? y) => StringComparer.OrdinalIgnoreCase.Equals(x, y);

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

24private protected override bool Equals(string? x, string? y) => StringComparer.OrdinalIgnoreCase.Equals(x, y);

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

24private protected override bool Equals(string? x, string? y) => StringComparer.OrdinalIgnoreCase.Equals(x, y);

System\Collections\Specialized\CollectionsUtil.cs (3)

19return new Hashtable(StringComparer.CurrentCultureIgnoreCase); 24return new Hashtable(capacity, StringComparer.CurrentCultureIgnoreCase); 29return new Hashtable(d, StringComparer.CurrentCultureIgnoreCase);

System\Collections\Specialized\HybridDictionary.cs (7)

53hashtable = new Hashtable(initialSize, StringComparer.OrdinalIgnoreCase); 111list = new ListDictionary(caseInsensitive ? StringComparer.OrdinalIgnoreCase : null); 117private ListDictionary List => list ??= new ListDictionary(caseInsensitive ? StringComparer.OrdinalIgnoreCase : null); 126newTable = new Hashtable(InitialHashtableSize, StringComparer.OrdinalIgnoreCase); 236list = new ListDictionary(caseInsensitive ? StringComparer.OrdinalIgnoreCase : null); 306list ??= new ListDictionary(caseInsensitive ? StringComparer.OrdinalIgnoreCase : null); 317list ??= new ListDictionary(caseInsensitive ? StringComparer.OrdinalIgnoreCase : null);

System\Collections\Specialized\NameObjectCollectionBase.cs (1)

35private static readonly StringComparer s_defaultComparer = CultureInfo.InvariantCulture.CompareInfo.GetStringComparer(CompareOptions.IgnoreCase);

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

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

Microsoft\Internal\StringComparers.cs (4)

10public static StringComparer ContractName 12get { return StringComparer.Ordinal; } 15public static StringComparer MetadataKeyNames 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"/>,

src\libraries\Common\src\System\Drawing\ColorTable.cs (1)

16var colors = new Dictionary<string, Color>(StringComparer.OrdinalIgnoreCase);

System\ComponentModel\ComponentResourceManager.cs (3)

116if (resources == null || (resources.Comparer.Equals(StringComparer.OrdinalIgnoreCase) != IgnoreCase)) 231sd = new SortedList<string, object?>(StringComparer.OrdinalIgnoreCase); 235sd = new SortedList<string, object?>(StringComparer.Ordinal);

System\ComponentModel\PropertyDescriptorCollection.cs (1)

186_cachedFoundProperties = new Hashtable(StringComparer.OrdinalIgnoreCase);

src\libraries\Common\src\System\IO\TempFileCollection.cs (1)

41_files = new Hashtable(StringComparer.OrdinalIgnoreCase);

System\Configuration\BaseConfigurationRecord.cs (1)

3417_children ??= new Hashtable(StringComparer.OrdinalIgnoreCase);

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\ConnectionStringSettingsCollection.cs (1)

12: base(StringComparer.OrdinalIgnoreCase)

System\Configuration\DictionarySectionHandler.cs (1)

32res = new Hashtable(StringComparer.OrdinalIgnoreCase);

System\Configuration\KeyValueConfigurationCollection.cs (1)

12base(StringComparer.OrdinalIgnoreCase)

System\Configuration\MgmtConfigurationRecord.cs (1)

302_locationTags ??= new Hashtable(StringComparer.OrdinalIgnoreCase);

System\Configuration\NameValueSectionHandler.cs (1)

33result = new ReadOnlyNameValueCollection(StringComparer.OrdinalIgnoreCase);

System\Configuration\PropertyInformationCollection.cs (1)

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

System\Configuration\Provider\ProviderCollection.cs (1)

15_hashtable = new Hashtable(10, StringComparer.OrdinalIgnoreCase);

System\Configuration\ProviderSettings.cs (1)

69_propertyNameCollection = new NameValueCollection(StringComparer.Ordinal);

System\Configuration\ProviderSettingsCollection.cs (1)

12base(StringComparer.OrdinalIgnoreCase)

System\Configuration\SettingsPropertyCollection.cs (1)

15_hashtable = new Hashtable(10, StringComparer.CurrentCultureIgnoreCase);

System\Configuration\SettingsPropertyValueCollection.cs (1)

16_indices = new Hashtable(10, StringComparer.CurrentCultureIgnoreCase);

System\TerminalFormatStrings.cs (1)

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

src\libraries\Common\src\System\Data\Common\DbConnectionOptions.Common.cs (1)

151(0 == StringComparer.OrdinalIgnoreCase.Compare(strvalue, strconst));

System\Data\Common\DbConnectionStringBuilder.cs (4)

62values = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase); 409Hashtable descriptors = new Hashtable(StringComparer.OrdinalIgnoreCase); 505if (StringComparer.OrdinalIgnoreCase.Equals(DbConnectionStringKeywords.Password, keyword) || 506StringComparer.OrdinalIgnoreCase.Equals(DbConnectionStringSynonyms.Pwd, keyword))

System\Data\DataTable.cs (2)

83private StringComparer? _hashCodeProvider; 3223_hashCodeProvider = StringComparer.Create(Locale, true);

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

Common\System\Data\Common\DbConnectionStringCommon.cs (18)

src\libraries\Common\src\System\Data\Common\DbConnectionOptions.Common.cs (1)

151(0 == StringComparer.OrdinalIgnoreCase.Compare(strvalue, strconst));

System\Data\Odbc\OdbcConnectionStringbuilder.cs (1)

28private static readonly Dictionary<string, Keywords> s_keywords = new Dictionary<string, Keywords>(2, StringComparer.OrdinalIgnoreCase)

System\Diagnostics\DsesActivitySourceListener.cs (3)

74var allSources = _listenToActivitySourceNames ??= new(StringComparer.OrdinalIgnoreCase); 245hash = ((hash << 5) + hash) + StringComparer.OrdinalIgnoreCase.GetHashCode(obj.activitySourceName); 246hash = ((hash << 5) + hash) + (obj.activityName == null ? 0 : StringComparer.OrdinalIgnoreCase.GetHashCode(obj.activityName));

System\Diagnostics\ProcessStartInfo.cs (2)

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

src\libraries\Common\src\System\Drawing\ColorTable.cs (1)

16var colors = new Dictionary<string, Color>(StringComparer.OrdinalIgnoreCase);

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\Linq\OrderedEnumerable.cs (1)

101comparer = (IComparer<TKey>)StringComparer.CurrentCulture;

System\Linq\OrderBy.cs (1)

245comparer = (IComparer<TKey>)StringComparer.CurrentCulture;

src\libraries\Common\src\System\Net\CredentialCacheKey.cs (1)

77StringComparer.OrdinalIgnoreCase.GetHashCode(AuthenticationType) ^

System\Net\Http\Headers\AuthenticationHeaderValue.cs (1)

86int result = StringComparer.OrdinalIgnoreCase.GetHashCode(_scheme);

System\Net\Http\Headers\CacheControlHeaderValue.cs (5)

314HeaderUtilities.AreEqualCollections(_noCacheHeaders, other._noCacheHeaders, StringComparer.OrdinalIgnoreCase) && 315HeaderUtilities.AreEqualCollections(_privateHeaders, other._privateHeaders, StringComparer.OrdinalIgnoreCase) && 325(_noCacheHeaders is null ? 0 : _noCacheHeaders.GetHashCode(StringComparer.OrdinalIgnoreCase)), 326(_privateHeaders is null ? 0 : _privateHeaders.GetHashCode(StringComparer.OrdinalIgnoreCase)), 599public int GetHashCode(StringComparer comparer)

System\Net\Http\Headers\ContentDispositionHeaderValue.cs (1)

175return StringComparer.OrdinalIgnoreCase.GetHashCode(_dispositionType) ^ NameValueHeaderValue.GetHashCode(_parameters);

System\Net\Http\Headers\ContentRangeHeaderValue.cs (1)

103StringComparer.OrdinalIgnoreCase.GetHashCode(_unit),

System\Net\Http\Headers\GenericHeaderParser.cs (2)

15internal static readonly GenericHeaderParser HostParser = new GenericHeaderParser(false, ParseHost, StringComparer.OrdinalIgnoreCase); 16internal static readonly GenericHeaderParser TokenListParser = new GenericHeaderParser(true, ParseTokenList, StringComparer.OrdinalIgnoreCase);

System\Net\Http\Headers\HeaderDescriptor.cs (1)

54public override int GetHashCode() => _descriptor is KnownHeader knownHeader ? knownHeader.GetHashCode() : StringComparer.OrdinalIgnoreCase.GetHashCode(_descriptor);

System\Net\Http\Headers\KnownHeaders.cs (1)

385if (candidate != null && StringComparer.OrdinalIgnoreCase.Equals(name, candidate.Name))

System\Net\Http\Headers\MediaTypeHeaderValue.cs (1)

144return StringComparer.OrdinalIgnoreCase.GetHashCode(_mediaType!) ^ NameValueHeaderValue.GetHashCode(_parameters);

System\Net\Http\Headers\NameValueHeaderValue.cs (2)

64int nameHashCode = StringComparer.OrdinalIgnoreCase.GetHashCode(_name); 75return nameHashCode ^ StringComparer.OrdinalIgnoreCase.GetHashCode(_value);

System\Net\Http\Headers\ProductHeaderValue.cs (2)

75int result = StringComparer.OrdinalIgnoreCase.GetHashCode(_name); 79result ^= StringComparer.OrdinalIgnoreCase.GetHashCode(_version);

System\Net\Http\Headers\RangeHeaderValue.cs (1)

99int result = StringComparer.OrdinalIgnoreCase.GetHashCode(_unit);

System\Net\Http\Headers\StringWithQualityHeaderValue.cs (1)

62HashCode.Combine(StringComparer.OrdinalIgnoreCase.GetHashCode(_value), _quality);

System\Net\Http\Headers\TransferCodingHeaderValue.cs (1)

136return StringComparer.OrdinalIgnoreCase.GetHashCode(_value) ^ NameValueHeaderValue.GetHashCode(_parameters);

System\Net\Http\Headers\ViaHeaderValue.cs (3)

113StringComparer.OrdinalIgnoreCase.GetHashCode(_protocolVersion), 114StringComparer.OrdinalIgnoreCase.GetHashCode(_receivedBy), 115_protocolName is null ? 0 : StringComparer.OrdinalIgnoreCase.GetHashCode(_protocolName),

System\Net\Http\Headers\WarningHeaderValue.cs (1)

111StringComparer.OrdinalIgnoreCase.GetHashCode(_agent),

System\Net\Http\HttpMethod.cs (1)

63_hashcode = StringComparer.OrdinalIgnoreCase.GetHashCode(_method);

System\Net\Http\SocketsHttpHandler\AuthenticationHelper.cs (3)

48if (StringComparer.OrdinalIgnoreCase.Equals(scheme, ahv.Scheme)) 71if (StringComparer.OrdinalIgnoreCase.Equals(NegotiateScheme, ahv.Scheme) || StringComparer.OrdinalIgnoreCase.Equals(NtlmScheme, ahv.Scheme))

System\Net\Http\SocketsHttpHandler\AuthenticationHelper.Digest.cs (1)

238internal readonly Dictionary<string, string> Parameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

System\Net\Mail\MailAddress.cs (1)

282return StringComparer.InvariantCultureIgnoreCase.GetHashCode(ToString());

System\Net\Mail\MailHeaderInfo.cs (1)

74var headers = new Dictionary<string, int>((int)MailHeaderID.ZMaxEnumValue + 1, StringComparer.OrdinalIgnoreCase);

System\Net\Mime\ContentDisposition.cs (1)

251public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(ToString());

System\Net\Mime\ContentType.cs (1)

215public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(ToString());

System\Net\Mime\HeaderCollection.cs (1)

17internal HeaderCollection() : base(StringComparer.OrdinalIgnoreCase)

src\libraries\Common\src\System\Net\CredentialCacheKey.cs (1)

77StringComparer.OrdinalIgnoreCase.GetHashCode(AuthenticationType) ^

System\Net\Cookie.cs (4)

636StringComparer.OrdinalIgnoreCase.GetHashCode(Name), 637StringComparer.Ordinal.GetHashCode(Value), 638StringComparer.Ordinal.GetHashCode(Path), 639StringComparer.OrdinalIgnoreCase.GetHashCode(DomainKey),

System\Net\CredentialCache.cs (2)

366StringComparer.OrdinalIgnoreCase.GetHashCode(AuthenticationType) ^ 367StringComparer.OrdinalIgnoreCase.GetHashCode(Host) ^

System\Net\DnsEndPoint.cs (2)

40StringComparer.OrdinalIgnoreCase.Equals(_host, dnsComparand._host); 46StringComparer.OrdinalIgnoreCase.GetHashCode(_host));

System\Net\HeaderInfoTable.cs (1)

87var headers = new Hashtable(Items * 2, StringComparer.OrdinalIgnoreCase)

System\Net\WebHeaderCollection.cs (1)

53private NameValueCollection InnerCollection => _innerCollection ??= new NameValueCollection(ApproxHighAvgNumHeaders, StringComparer.OrdinalIgnoreCase);

src\libraries\System.Private.CoreLib\src\Internal\Runtime\InteropServices\ComponentActivator.cs (2)

24private static readonly Dictionary<string, IsolatedComponentLoadContext> s_assemblyLoadContexts = new Dictionary<string, IsolatedComponentLoadContext>(StringComparer.InvariantCulture); 26private static readonly HashSet<string> s_loadedInDefaultContext = new HashSet<string>(StringComparer.InvariantCulture);

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

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

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\CultureData.cs (1)

152new Dictionary<string, string>(255, StringComparer.OrdinalIgnoreCase)

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

8public static StringComparer GetStringComparer(this CompareInfo compareInfo, CompareOptions options) 14return StringComparer.Ordinal; 19return StringComparer.OrdinalIgnoreCase;

src\libraries\System.Private.CoreLib\src\System\Resources\ResourceSet.cs (1)

217caseTable = new Dictionary<string, object?>(copyOfTable.Count, StringComparer.OrdinalIgnoreCase);

src\libraries\System.Private.CoreLib\src\System\Resources\RuntimeResourceSet.cs (1)

317caseInsensitiveTable = new Dictionary<string, ResourceLocator>(StringComparer.OrdinalIgnoreCase);

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\OSPlatform.cs (1)

52return Name == null ? 0 : StringComparer.OrdinalIgnoreCase.GetHashCode(Name);

src\libraries\System.Private.CoreLib\src\System\Runtime\Loader\AssemblyDependencyResolver.cs (1)

96_assemblyPaths = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

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

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\String.Comparison.cs (1)

763public int GetHashCode(StringComparison comparisonType) => StringComparer.FromComparison(comparisonType).GetHashCode(this);

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

src\libraries\System.Private.CoreLib\src\System\Text\EncodingTable.cs (1)

18private static readonly Hashtable s_nameToCodePage = Hashtable.Synchronized(new Hashtable(StringComparer.OrdinalIgnoreCase));

src\libraries\System.Private.CoreLib\src\System\TimeZoneInfo.cs (3)

876public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(_id); 2041cachedData._timeZonesUsingAlternativeIds ??= new Dictionary<string, TimeZoneInfo>(StringComparer.OrdinalIgnoreCase); 2131cachedData._systemTimeZones ??= new Dictionary<string, TimeZoneInfo>(StringComparer.OrdinalIgnoreCase)

src\libraries\System.Private.CoreLib\src\System\TimeZoneInfo.Unix.cs (1)

291cachedData._systemTimeZones ??= new Dictionary<string, TimeZoneInfo>(StringComparer.OrdinalIgnoreCase)

System\Uri.cs (1)

1539return StringComparer.OrdinalIgnoreCase.GetHashCode(remoteUrl);

System\Xml\Xsl\XsltOld\HtmlProps.cs (2)

57Hashtable table = new Hashtable(71, StringComparer.OrdinalIgnoreCase); 168Hashtable table = new Hashtable(26, StringComparer.OrdinalIgnoreCase);

System\Reflection\PathAssemblyResolver.cs (1)

25private readonly Dictionary<string, List<string>> _fileToPaths = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);

src\libraries\Common\src\System\Resources\ResourceWriter.cs (2)

55_caseInsensitiveDups = new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase); 74_caseInsensitiveDups = new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase);

src\libraries\System.Private.CoreLib\src\System\Resources\RuntimeResourceSet.cs (1)

317caseInsensitiveTable = new Dictionary<string, ResourceLocator>(StringComparer.OrdinalIgnoreCase);

src\libraries\Common\src\System\Resources\ResourceWriter.cs (2)

55_caseInsensitiveDups = new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase); 74_caseInsensitiveDups = new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase);

artifacts\obj\System.Runtime\Debug\net10.0\System.Runtime.Forwards.cs (1)

772[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.StringComparer))]

System\Runtime\Caching\FileChangeNotificationSystem.cs (1)

92_dirMonitors = Hashtable.Synchronized(new Hashtable(StringComparer.OrdinalIgnoreCase));

System.Runtime.Extensions.cs (1)

28[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.StringComparer))]

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

48_clrNamespaces = new Dictionary<string, string?>(StringComparer.OrdinalIgnoreCase); 1519Dictionary<string, object?> fragments = new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase);

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

52return _memberNames ??= new HashSet<string>(StringComparer.OrdinalIgnoreCase);

System\Security\Cryptography\CryptoConfig.cs (4)

41private static readonly ConcurrentDictionary<string, Type> appNameHT = new ConcurrentDictionary<string, Type>(StringComparer.OrdinalIgnoreCase); 42private static readonly ConcurrentDictionary<string, string> appOidHT = new ConcurrentDictionary<string, string>(StringComparer.OrdinalIgnoreCase); 54Dictionary<string, string> ht = new Dictionary<string, string>(capacity, StringComparer.OrdinalIgnoreCase); 118Dictionary<string, object> ht = new Dictionary<string, object>(capacity: capacity, comparer: StringComparer.OrdinalIgnoreCase);

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

16new ConcurrentDictionary<string, string>(StringComparer.OrdinalIgnoreCase); 99new Dictionary<string, string>(FriendlyNameToOidCount, StringComparer.OrdinalIgnoreCase); 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\FindPal.cs (1)

16new Dictionary<string, X509KeyUsageFlags>(NamedKeyUsageFlagsCount, StringComparer.OrdinalIgnoreCase)

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

31if (!StringComparer.OrdinalIgnoreCase.Equals(oid.Value, maybeOid)) 79FindCore(subjectDistinguishedName, static (subjectDistinguishedName, cert) => StringComparer.OrdinalIgnoreCase.Equals(subjectDistinguishedName, cert.Subject)); 96FindCore(issuerDistinguishedName, static (issuerDistinguishedName, cert) => StringComparer.OrdinalIgnoreCase.Equals(issuerDistinguishedName, cert.Issuer)); 173if (StringComparer.OrdinalIgnoreCase.Equals(templateName, decodedName)) 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\ServiceModel\Syndication\SyndicationFeed.cs (1)

17StringComparer.OrdinalIgnoreCase

System\Text\EncodingTable.cs (1)

12private static readonly Dictionary<string, int> s_nameToCodePageCache = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);

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

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

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

240StringComparer comparer = options?.PropertyNameCaseInsensitive ?? false 241? StringComparer.OrdinalIgnoreCase 242: StringComparer.Ordinal;

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

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

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

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

JsonSourceGenerator.Parser.cs (2)

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\Web\HttpUtility.cs (1)

46: base(StringComparer.OrdinalIgnoreCase)

System\Resources\AssemblyNamesTypeResolutionService.cs (1)

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

System\Windows\Forms\Controls\PropertyGrid\PropertyGridInternal\GridEntryComparer.cs (1)

11=> StringComparer.CurrentCulture.Compare(x?.ToString(), y?.ToString());

System\ComponentModel\Design\MenuCommandService.cs (1)

259Dictionary<string, int> buildVerbs = new(verbCount, StringComparer.OrdinalIgnoreCase);

System\ComponentModel\Design\Serialization\CodeDomDesignerLoader.cs (3)

419? StringComparer.InvariantCultureIgnoreCase 420: StringComparer.InvariantCulture); 1035HashSet<string> memberHash = new(StringComparer.CurrentCultureIgnoreCase);

System\ComponentModel\Design\Serialization\DesignerSerializationManager.cs (2)

781_instancesByName ??= new(StringComparer.CurrentCulture); 925_instancesByName = new(StringComparer.CurrentCulture);

System\Resources\Tools\StronglyTypedResourceBuilder.cs (4)

165Dictionary<string, ResourceData> resourceTypes = new(StringComparer.InvariantCultureIgnoreCase); 271Dictionary<string, ResourceData> resourceList = new(StringComparer.InvariantCultureIgnoreCase); 865reverseFixupTable = new(0, StringComparer.InvariantCultureIgnoreCase); 866SortedList<string, ResourceData> cleanedResourceList = new(resourceList.Count, StringComparer.InvariantCultureIgnoreCase);

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

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

Windows\Win32\System\Ole\ClassPropertyDispatchAdapter.cs (1)

25private readonly Dictionary<string, int> _reverseLookup = new(StringComparer.OrdinalIgnoreCase);

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

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

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

4709yield return new object[] { StringComparer.CurrentCulture }; 4732TreeViewNodeSorter = StringComparer.CurrentCulture

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

System\Xaml\XamlSchemaContext.cs (1)

589Dictionary<string, SpecialBracketCharacters> map = new Dictionary<string, SpecialBracketCharacters>(StringComparer.OrdinalIgnoreCase);

TagHelpers\PrettyTagHelper.cs (1)

14new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)

TaskUsageLogger.cs (1)

79_assemblyLocationsByName = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

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\CompilationExtensions.cs (2)

46return guids.Contains(WebAppProjectGuidString, StringComparer.OrdinalIgnoreCase) || 47guids.Contains(WebSiteProjectGuidString, StringComparer.OrdinalIgnoreCase);

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

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

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

15private static readonly ImmutableHashSet<string> s_uriWords = ImmutableHashSet.Create(StringComparer.OrdinalIgnoreCase, "uri", "urn", "url");

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

67var ruleIdToComments = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

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

CodeAnalysisDictionary.cs (2)

53_recognizedWords = new HashSet<string>(recognizedWords, StringComparer.OrdinalIgnoreCase); 54_unrecognizedWords = new HashSet<string>(unrecognizedWords, StringComparer.OrdinalIgnoreCase);

src\RoslynAnalyzers\Utilities\Compiler\Extensions\CompilationExtensions.cs (2)

46return guids.Contains(WebAppProjectGuidString, StringComparer.OrdinalIgnoreCase) || 47guids.Contains(WebSiteProjectGuidString, StringComparer.OrdinalIgnoreCase);

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

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

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

15private static readonly ImmutableHashSet<string> s_uriWords = ImmutableHashSet.Create(StringComparer.OrdinalIgnoreCase, "uri", "urn", "url");

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

67var ruleIdToComments = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

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\Shared\NamedPipeUtil.cs (1)

64StringComparer.OrdinalIgnoreCase.Equals(serverIdentity.name, clientIdentity.name) &&

src\Compilers\Shared\NamedPipeUtil.cs (1)

64StringComparer.OrdinalIgnoreCase.Equals(serverIdentity.name, clientIdentity.name) &&

System\ComponentModel\GroupDescriptionTests.cs (22)

ObjectModel\Build.cs (1)

26private readonly ConcurrentDictionary<string, string> _taskToAssemblyMap = new ConcurrentDictionary<string, string>(StringComparer.OrdinalIgnoreCase);

ObjectModel\Project.cs (1)

29private readonly ConcurrentDictionary<string, Target> _targetNameToTargetMap = new ConcurrentDictionary<string, Target>(StringComparer.OrdinalIgnoreCase);

PropertyBag.cs (1)

27private readonly Dictionary<string, string> _properties = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

common\AssemblyResolution\DependencyContextAssemblyCache.cs (10)

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

97return StringComparer.OrdinalIgnoreCase.Equals(x.Name, y.Name); 102return StringComparer.OrdinalIgnoreCase.GetHashCode(obj.Name);

Utility\TransformFactory.cs (1)

18readonly Dictionary<string, Transform> availableTransforms = new Dictionary<string, Transform>(StringComparer.OrdinalIgnoreCase);