OrdinalIgnoreCase

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

Otlp\Model\ColorGenerator.cs (1)

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

src\Shared\StringComparers.cs (8)

Dashboard\DashboardLifecycleHook.cs (1)

42private static readonly HashSet<string> s_suppressAutomaticConfigurationCopy = new HashSet<string>(StringComparer.OrdinalIgnoreCase)

src\Shared\SecretsStore.cs (1)

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

src\Shared\StringComparers.cs (8)

src\Shared\StringComparers.cs (8)

src\Shared\StringComparers.cs (8)

src\Shared\StringComparers.cs (8)

src\Shared\StringComparers.cs (8)

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

src\Shared\StringComparers.cs (8)

src\Shared\StringComparers.cs (8)

src\Shared\StringComparers.cs (8)

src\Shared\StringComparers.cs (8)

src\Shared\StringComparers.cs (8)

src\Shared\StringComparers.cs (8)

Utils\StringComparersTests.cs (2)

107yield return (StringComparer.OrdinalIgnoreCase, nameof(StringComparer.OrdinalIgnoreCase));

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

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)

CompilerNuGetCheckerUtil.cs (1)

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

14public static readonly StringComparer StringComparer = StringComparer.OrdinalIgnoreCase;

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

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

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

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

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

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

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

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

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

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

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

FakeHttpClient.cs (1)

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

Internal\DefaultAntiforgeryTokenGenerator.cs (1)

154var comparer = StringComparer.OrdinalIgnoreCase;

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

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

BrowserManagerConfiguration.cs (3)

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

PersistentState\PersistentServicesRegistry.cs (1)

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

Reflection\ComponentProperties.cs (3)

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

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

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

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

Rendering\RenderTreeBuilderTest.cs (10)

HtmlRendering\StaticHtmlRenderer.HtmlWriting.cs (1)

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

JSComponents\JSComponentInterop.cs (1)

202ParameterInfoByName = new(StringComparer.OrdinalIgnoreCase);

Hosting\WebAssemblyHostConfiguration.cs (1)

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

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

311OperatingSystem.IsWindows() ? StringComparer.OrdinalIgnoreCase : 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\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);

Internal\GrpcProtocolConstants.cs (1)

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

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

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

WebHostBuilder.cs (1)

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

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

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

RequestDelegateFactory.cs (2)

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

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

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

115public ISet<string> AdditionalRequestHeaders { get; } = new SortedSet<string>(StringComparer.OrdinalIgnoreCase);

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

Abstractions\ActionDescriptor.cs (1)

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

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)

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

10public static readonly StringArrayComparer OrdinalIgnoreCase = new StringArrayComparer(StringComparer.OrdinalIgnoreCase);

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

ApplicationModels\AttributeRouteModelTests.cs (30)

ApplicationModels\ControllerActionDescriptorProviderTests.cs (11)

Formatters\JsonOutputFormatterTestBase.cs (1)

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

Infrastructure\ActionSelectionTableTest.cs (25)

Infrastructure\ActionSelectorTest.cs (20)

ModelBinding\CompositeValueProviderTest.cs (1)

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

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

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)

BsonTempDataSerializer.cs (2)

53return new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase); 59StringComparer.OrdinalIgnoreCase);

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

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

ApplicationParts\RazorCompiledItemFeatureProvider.cs (1)

23.GroupBy(i => i.Identifier, StringComparer.OrdinalIgnoreCase)

Compilation\DefaultViewCompiler.cs (1)

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

TagHelpers\UrlResolutionTagHelper.cs (1)

58new(StringComparer.OrdinalIgnoreCase)

RuntimeViewCompiler.cs (1)

65StringComparer.OrdinalIgnoreCase);

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

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

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

OptionTagHelper.cs (1)

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

SelectTagHelper.cs (1)

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

TextAreaTagHelper.cs (1)

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

ValidationMessageTagHelper.cs (1)

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

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

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

HtmlHelper.cs (2)

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

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

Services\OpenApiDocumentService.cs (1)

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

src\Shared\ParameterBindingMethodCache.cs (1)

720return StringComparer.OrdinalIgnoreCase.GetHashCode(Name);

OutputCacheEntryFormatter.cs (2)

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

OutputCacheKeyProvider.cs (2)

349Array.Sort(newArray, StringComparer.OrdinalIgnoreCase); 358public static QueryKeyComparer OrdinalIgnoreCase { get; } = new QueryKeyComparer(StringComparer.OrdinalIgnoreCase);

OutputCacheOptions.cs (2)

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

RequestDecompressionOptions.cs (1)

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

ResponseCachingKeyProvider.cs (1)

197public static QueryKeyComparer OrdinalIgnoreCase { get; } = new QueryKeyComparer(StringComparer.OrdinalIgnoreCase);

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

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

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

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

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

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\test\Http3\Http3InMemory.cs (1)

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

AdaptiveCapacityDictionaryTests.cs (16)

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

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

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

RedisHubLifetimeManager.cs (1)

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

Proxying\SpaProxy.cs (3)

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

FileExtensionContentTypeProvider.cs (1)

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

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\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\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\Infrastructure\EditorConfig\EditorConfigFile.cs (1)

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

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

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

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

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); 2677return DistinctWithComparer(expander, elementLocation, includeNullEntries, functionName, itemsOfType, arguments, StringComparer.OrdinalIgnoreCase);

Evaluation\IntrinsicFunctions.cs (1)

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

Evaluation\ItemSpec.cs (1)

581options == MatchOnMetadataOptions.CaseInsensitive || FileUtilities.PathComparison == StringComparison.OrdinalIgnoreCase ? StringComparer.OrdinalIgnoreCase :

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

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

266keyComparer: StringComparer.OrdinalIgnoreCase, 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 (9)

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

288var availableStaticMethods = new ConcurrentDictionary<string, Tuple<string, Type>>(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);

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

FileUtilities.cs (2)

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

BackEnd\BuildManager_Tests.cs (1)

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

BackEnd\BuildRequestConfiguration_Tests.cs (13)

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

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)

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)

Collections\OMcollections_tests.cs (4)

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

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

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)

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

ImmutableFilesTimestampCache.cs (1)

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

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

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

43private readonly Dictionary<string, XmlNode> _cultures = new Dictionary<string, XmlNode>(StringComparer.OrdinalIgnoreCase); 427var folders = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 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);

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

FileIO\GetFileHash.cs (1)

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

FileMatcher.cs (4)

FileUtilities.cs (2)

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

176_runtimePackAssets = RuntimePackAssets.ToDictionary(p => p.ItemSpec, StringComparer.OrdinalIgnoreCase); 510var outputAssembliesMap = outputAssemblies.ToDictionary(p => Path.GetFullPath(p.ItemSpec), StringComparer.OrdinalIgnoreCase);

ResolveProjectBase.cs (1)

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

ResolveSDKReference.cs (7)

30private static readonly Dictionary<string, string> PlatformAliases = new(StringComparer.OrdinalIgnoreCase) 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);

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

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

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

FileMatcher.cs (4)

FileUtilities.cs (2)

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

Collections\IdentifierCollection.cs (1)

28StringComparer.OrdinalIgnoreCase);

CommandLine\AnalyzerConfigSet.cs (1)

333var comparer = StringComparer.OrdinalIgnoreCase;

Compilation\Compilation.cs (1)

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

DiagnosticAnalyzer\AnalyzerAssemblyLoader.cs (1)

67internal static readonly (StringComparer Comparer, StringComparison Comparison) SimpleNameComparer = (StringComparer.OrdinalIgnoreCase, StringComparison.OrdinalIgnoreCase);

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

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

Emit\DebugDocumentsBuilder.cs (1)

31StringComparer.OrdinalIgnoreCase);

FileKey.cs (1)

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

FileSystem\PathUtilities.cs (1)

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

MetadataReader\PEAssembly.cs (1)

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

MetadataReader\PEModule.cs (1)

3820var caseInsensitiveMap = new Dictionary<string, (string OriginalName, int FirstIndex, int SecondIndex)>(StringComparer.OrdinalIgnoreCase);

MetadataReference\AssemblyIdentityComparer.cs (2)

20get { return StringComparer.OrdinalIgnoreCase; } 25get { return StringComparer.OrdinalIgnoreCase; }

RuleSet\RuleSet.cs (1)

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

SourceGeneration\AdditionalSourcesCollection.cs (1)

23private static readonly StringComparer s_hintNameComparer = StringComparer.OrdinalIgnoreCase;

MetaAnalyzers\DiagnosticDescriptorCreationAnalyzer_ReleaseTracking.cs (1)

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

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

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

RestrictedInternalsVisibleToAnalyzer.cs (1)

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

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

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

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

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

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

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

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

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

44new(() => new HashSet<string>(StringComparer.OrdinalIgnoreCase), 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\SymbolKey\SymbolKey.SymbolKeyComparer.cs (1)

35? StringComparer.OrdinalIgnoreCase

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

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

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

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

CommandLine\CSharpCompiler.cs (1)

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

CSharpParseOptions.cs (1)

166features?.ToImmutableDictionary(StringComparer.OrdinalIgnoreCase)

Symbols\MissingModuleSymbol.cs (1)

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

Symbols\Source\SourceAssemblySymbol.cs (2)

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

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

SourceGeneration\AdditionalSourcesCollectionTests.cs (1)

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

Compilation\CompilationAPITests.cs (2)

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

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

EmitMetadataTestBase.cs (1)

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

SymbolUtilities.cs (1)

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

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

139return StringComparer.OrdinalIgnoreCase.Equals(left.Name, right.Name) && 148return Hash.Combine(StringComparer.OrdinalIgnoreCase.GetHashCode(style.Name), 174return StringComparer.OrdinalIgnoreCase.Equals(left!.Name, right!.Name) && 182return Hash.Combine(StringComparer.OrdinalIgnoreCase.GetHashCode(symbolSpecification.Name),

SignatureHelp\Controller.Session_UpdateModel.cs (2)

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

Utilities\BloomFilterTests.cs (2)

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

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

VisualBasic\MemberSignatureParser.cs (1)

16internal static readonly StringComparer StringComparer = StringComparer.OrdinalIgnoreCase;

VisualBasicParsingTests.cs (1)

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

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

44return StringComparer.OrdinalIgnoreCase.Equals(

CodeLens\LocationComparer.cs (1)

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

Completion\CompletionItem.cs (2)

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

Completion\FileSystemCompletionHelper.cs (1)

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

Completion\Providers\AbstractInternalsVisibleToCompletionProvider.cs (1)

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

EditAndContinue\ActiveStatementsMap.cs (1)

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

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

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

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

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

Interactive\Core\InteractiveHostPlatformInfo.cs (1)

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

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

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

HostWorkspace\FileWatching\LspFileChangeWatcher.cs (1)

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

HostWorkspace\ProjectDependencyHelper.cs (2)

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

Logging\LspLogMessageLoggerProvider.cs (1)

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

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

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

DeclarePublicApiFix.cs (1)

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

RebuildCommandLineTests.cs (1)

29public Dictionary<string, TestableFile> FilePathToStreamMap { get; } = new Dictionary<string, TestableFile>(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\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);

Hosting\AssemblyLoader\MetadataShadowCopyProvider.cs (1)

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

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

345int comparisonResult = StringComparer.OrdinalIgnoreCase.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);

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

Platform\CoreClr\TestExecutionLoadContext.cs (1)

39var comparer = StringComparer.OrdinalIgnoreCase;

TargetFrameworkUtil.cs (1)

349var nameSet = new HashSet<string>(getNames(references), StringComparer.OrdinalIgnoreCase);

TestableFileSystem.cs (1)

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

73return numbers.ToLookup(n => GetKey(n, randomCase), StringComparer.OrdinalIgnoreCase); 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.nonnetstandard.cs (1)

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

Collections\ImmutableDictionaryTestBase.cs (1)

225var dictionary = Empty<int>(StringComparer.OrdinalIgnoreCase)

Collections\ImmutableSegmentedDictionaryBuilderTest.cs (9)

Collections\ImmutableSegmentedDictionaryTest.cs (16)

Collections\ImmutableSegmentedHashSetBuilderTest.cs (10)

Collections\ImmutableSegmentedHashSetTest.cs (4)

37ImmutableSegmentedHashSet<string>.Empty.WithComparer(StringComparer.OrdinalIgnoreCase), 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 (3)

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

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

FindSymbols\FindReferences\DependentProjectsFinder.cs (1)

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

FindSymbols\FindReferences\FindReferenceCache.cs (1)

86LanguageNames.VisualBasic => StringComparer.OrdinalIgnoreCase,

FindSymbols\ReferenceLocation.cs (1)

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

FindSymbols\SyntaxTree\SyntaxTreeIndex_Create.cs (4)

363Debug.Assert(identifiers.Comparer == StringComparer.OrdinalIgnoreCase); 364Debug.Assert(escapedIdentifiers.Comparer == StringComparer.OrdinalIgnoreCase); 379Debug.Assert(identifiers.Comparer == StringComparer.OrdinalIgnoreCase); 380Debug.Assert(escapedIdentifiers.Comparer == StringComparer.OrdinalIgnoreCase);

Shared\Extensions\IFindReferencesResultExtensions.cs (1)

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

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

67internal static readonly (StringComparer Comparer, StringComparison Comparison) SimpleNameComparer = (StringComparer.OrdinalIgnoreCase, StringComparison.OrdinalIgnoreCase);

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

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

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

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

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

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

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

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

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

44new(() => new HashSet<string>(StringComparer.OrdinalIgnoreCase), 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\SymbolKey\SymbolKey.SymbolKeyComparer.cs (1)

35? StringComparer.OrdinalIgnoreCase

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

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

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

147private readonly Dictionary<string, string?> _dynamicFilePathMaps = new(StringComparer.OrdinalIgnoreCase);

Workspace\ProjectSystem\ProjectSystemProjectFactory.ProjectUpdateState.cs (1)

61ImmutableDictionary<string, ImmutableArray<ProjectId>>.Empty.WithComparers(StringComparer.OrdinalIgnoreCase),

Workspace\Solution\SolutionState.CachingFilePathComparer.cs (1)

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

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

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

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

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

44new(() => new HashSet<string>(StringComparer.OrdinalIgnoreCase), 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);

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

33var emptyIgnoreCase = ImmutableDictionary<string, int>.Empty.WithComparers(keyComparer: StringComparer.OrdinalIgnoreCase);

src\InstallDotNetCore.cs (1)

92properties = proj.AllEvaluatedProperties.ToLookup(p => p.Name, StringComparer.OrdinalIgnoreCase);

PipelinesLogger.cs (2)

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

266return manifestFiles.OrderBy(f => f.Target, StringComparer.OrdinalIgnoreCase).ToList();

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

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

73StringComparer.OrdinalIgnoreCase);

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

Languages\Language.cs (1)

56_languages = new Dictionary<string, Language>(StringComparer.OrdinalIgnoreCase)

Tasks\GatherXlf.cs (1)

30HashSet<string> outputPaths = new(StringComparer.OrdinalIgnoreCase);

AsyncCollectionAssertsTests.cs (1)

450 var ex = Record.Exception(() => Assert.Distinct(list, StringComparer.OrdinalIgnoreCase));

CollectionAssertsTests.cs (7)

329 IEnumerable<string> set = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "Hi there" }; 338 IEnumerable<string> set = new ReadOnlySet<string>(StringComparer.OrdinalIgnoreCase, "Hi there"); 367 IEnumerable<string> set = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "Hi there" }; 484 var ex = Record.Exception(() => Assert.Distinct(list, StringComparer.OrdinalIgnoreCase)); 548 IEnumerable<string> set = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "Hi there" }; 566 IEnumerable<string> set = new ReadOnlySet<string>(StringComparer.OrdinalIgnoreCase, "Hi there"); 604 IEnumerable<string> set = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "Hi there" };

SetAssertsTests.cs (8)

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

175var comparer = StringComparer.OrdinalIgnoreCase; 191var comparer = StringComparer.OrdinalIgnoreCase; 207var comparer = StringComparer.OrdinalIgnoreCase; 239var comparer = StringComparer.OrdinalIgnoreCase; 263var comparer = StringComparer.OrdinalIgnoreCase; 298var args = new AIFunctionArguments(originalDict, StringComparer.OrdinalIgnoreCase);

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

24StringComparison.OrdinalIgnoreCase => StringComparer.OrdinalIgnoreCase,

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

24StringComparison.OrdinalIgnoreCase => StringComparer.OrdinalIgnoreCase,

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

24StringComparison.OrdinalIgnoreCase => StringComparer.OrdinalIgnoreCase,

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

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)

PhysicalFilesWatcher.cs (2)

29private readonly ConcurrentDictionary<string, ChangeTokenInfo> _filePathTokenLookup = new(StringComparer.OrdinalIgnoreCase); 30private readonly ConcurrentDictionary<string, ChangeTokenInfo> _wildcardTokenLookup = new(StringComparer.OrdinalIgnoreCase);

FilePatternMatch.cs (1)

73value != null ? StringComparer.OrdinalIgnoreCase.GetHashCode(value) : 0;

Util\StringComparisonHelper.cs (1)

15StringComparison.OrdinalIgnoreCase => StringComparer.OrdinalIgnoreCase,

DependencyInjection\HttpClientBuilderExtensions.cs (1)

584var sensitiveHeaders = new HashSet<string>(redactedLoggedHeaderNames, StringComparer.OrdinalIgnoreCase);

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

Helpers\ConfigurationStubFactory.cs (1)

40Data = new Dictionary<string, string?>(data, StringComparer.OrdinalIgnoreCase);

Routing\RoutingStrategyTest.cs (1)

192Data = new Dictionary<string, string?>(data, StringComparer.OrdinalIgnoreCase);

ConsoleLoggerProvider.cs (1)

102var cd = new ConcurrentDictionary<string, ConsoleFormatter>(StringComparer.OrdinalIgnoreCase);

LoggerMessageGenerator.Parser.cs (1)

876public readonly Dictionary<string, string> TemplateMap = new(StringComparer.OrdinalIgnoreCase);

TraceSourceLoggerProvider.cs (1)

20private readonly ConcurrentDictionary<string, DiagnosticsTraceSource> _sources = new ConcurrentDictionary<string, DiagnosticsTraceSource>(StringComparer.OrdinalIgnoreCase);

StringSegmentComparer.cs (1)

24= new StringSegmentComparer(StringComparison.OrdinalIgnoreCase, StringComparer.OrdinalIgnoreCase);

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

Parsing\Parser.cs (3)

160bool parameterInTemplate = lm.Templates.Contains(lp.TagName, StringComparer.OrdinalIgnoreCase) || 161lm.Templates.Contains(lp.ParameterNameWithAtIfNeeded, StringComparer.OrdinalIgnoreCase) || 162lm.Templates.Contains($"@{lp.ParameterName}", StringComparer.OrdinalIgnoreCase);

Handlers\HybridWebView\FileExtensionContentTypeProvider.cs (1)

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

Visuals\VisualTypeConverter.cs (1)

28 var mappings = new Dictionary<string, IVisual>(StringComparer.OrdinalIgnoreCase);

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

Text\TextColors.cs (1)

9 public static Dictionary<string, string> StandardColors = new(StringComparer.OrdinalIgnoreCase)

ColorTable.cs (1)

17 var colors = new Dictionary<string, SKColor>(StringComparer.OrdinalIgnoreCase);

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

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

45while (currentItems.FindItem(folderName, StringComparer.OrdinalIgnoreCase) != null)

ProjectSystem\Extensions\ProjectItemsExtensions.cs (3)

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

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

FileUtilities.cs (2)

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

CommunicationsUtilities.cs (1)

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

FileUtilities.cs (2)

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

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

Startup.cs (1)

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

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\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\IO\Packaging\XamlFilter.cs (1)

102_lcidDictionary = new Dictionary<string, uint>(StringComparer.OrdinalIgnoreCase);

System\Windows\Markup\ParserContext.cs (1)

842Dictionary<string, SpecialBracketCharacters> cache = new Dictionary<string, SpecialBracketCharacters>(StringComparer.OrdinalIgnoreCase);

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

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

Template.cs (1)

16StringComparer.OrdinalIgnoreCase);

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

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

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

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

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

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

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

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

src\libraries\Common\src\System\Drawing\ColorTable.cs (1)

16var colors = new Dictionary<string, Color>(StringComparer.OrdinalIgnoreCase);

System\ComponentModel\ComponentResourceManager.cs (2)

116if (resources == null || (resources.Comparer.Equals(StringComparer.OrdinalIgnoreCase) != IgnoreCase)) 231sd = new SortedList<string, object?>(StringComparer.OrdinalIgnoreCase);

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

15_hashtable = new Hashtable(10, StringComparer.OrdinalIgnoreCase);

System\Configuration\ProviderSettingsCollection.cs (1)

12base(StringComparer.OrdinalIgnoreCase)

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

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

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

src\libraries\Common\src\System\Drawing\ColorTable.cs (1)

16var colors = new Dictionary<string, Color>(StringComparer.OrdinalIgnoreCase);

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

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

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

636StringComparer.OrdinalIgnoreCase.GetHashCode(Name), 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\System\Collections\Generic\NonRandomizedStringEqualityComparer.cs (2)

25private static readonly NonRandomizedStringEqualityComparer WrappedAroundStringComparerOrdinalIgnoreCase = new OrdinalIgnoreCaseComparer(StringComparer.OrdinalIgnoreCase); 162if (ReferenceEquals(comparer, StringComparer.OrdinalIgnoreCase))

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

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

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

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

41StringComparison.OrdinalIgnoreCase => OrdinalIgnoreCase, 77/// then <paramref name="comparer"/> behaves identically to <see cref="OrdinalIgnoreCase"/> when passed to the

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

System\Runtime\Caching\FileChangeNotificationSystem.cs (1)

92_dirMonitors = Hashtable.Synchronized(new Hashtable(StringComparer.OrdinalIgnoreCase));

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

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

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

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

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

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

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\Nodes\JsonObject.IDictionary.cs (1)

241? StringComparer.OrdinalIgnoreCase

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

63_enumFieldInfoIndex = new(StringComparer.OrdinalIgnoreCase);

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

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

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

System\Web\HttpUtility.cs (1)

46: base(StringComparer.OrdinalIgnoreCase)

System\ComponentModel\Design\MenuCommandService.cs (1)

259Dictionary<string, int> buildVerbs = new(verbCount, StringComparer.OrdinalIgnoreCase);

Windows\Win32\System\Ole\ClassPropertyDispatchAdapter.cs (1)

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

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\RoslynAnalyzers\Utilities\Compiler\Extensions\CompilationExtensions.cs (2)

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

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

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

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)

64managedAssemblyCache = new ConcurrentDictionary<string, Assembly>(StringComparer.OrdinalIgnoreCase); 73.ToDictionaryIgnoringDuplicateKeys(tuple => tuple.Item1, tuple => tuple.Item2, StringComparer.OrdinalIgnoreCase); 76internalDiagnosticsMessageSink.OnMessage(new _DiagnosticMessage($"[DependencyContextAssemblyCache..ctor] Managed assembly map: [{string.Join(",", managedAssemblyMap.Keys.Select(k => $"'{k}'").OrderBy(k => k, StringComparer.OrdinalIgnoreCase))}]")); 79unmanagedAssemblyCache = new ConcurrentDictionary<string, string>(StringComparer.OrdinalIgnoreCase); 87.ToDictionaryIgnoringDuplicateKeys(tuple => tuple.Item1, tuple => tuple.Item2, StringComparer.OrdinalIgnoreCase); 90internalDiagnosticsMessageSink.OnMessage(new _DiagnosticMessage($"[DependencyContextAssemblyCache..ctor] Unmanaged assembly map: [{string.Join(",", unmanagedAssemblyMap.Keys.Select(k => $"'{k}'").OrderBy(k => k, StringComparer.OrdinalIgnoreCase))}]")); 253internalDiagnosticsMessageSink.OnMessage(new _DiagnosticMessage($"[DependencyContextAssemblyCache.ResolveManagedAssembly] Resolving '{assemblyName}', found a resolved path, but could not map a filename in [{string.Join(",", assemblies.OrderBy(k => k, StringComparer.OrdinalIgnoreCase).Select(k => $"'{k}'"))}]")); 259internalDiagnosticsMessageSink.OnMessage(new _DiagnosticMessage($"[DependencyContextAssemblyCache.ResolveManagedAssembly] Resolving '{assemblyName}', found in dependency map, but unable to resolve a path in [{string.Join(",", assetGroup.AssetPaths.OrderBy(k => k, StringComparer.OrdinalIgnoreCase).Select(k => $"'{k}'"))}]")); 286internalDiagnosticsMessageSink.OnMessage(new _DiagnosticMessage($"[DependencyContextAssemblyCache.ResolveUnmanagedLibrary] Found a resolved path, but could not map a filename in [{string.Join(",", assemblies.OrderBy(k => k, StringComparer.OrdinalIgnoreCase).Select(k => $"'{k}'"))}]")); 291internalDiagnosticsMessageSink.OnMessage(new _DiagnosticMessage($"[DependencyContextAssemblyCache.ResolveUnmanagedLibrary] Found in dependency map, but unable to resolve a path in [{string.Join(",", assetGroup.AssetPaths.OrderBy(k => k, StringComparer.OrdinalIgnoreCase).Select(k => $"'{k}'"))}]"));

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