OrdinalIgnoreCase

1615 references to OrdinalIgnoreCase

AnalyzerRunner (4)

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

aspire (9)

src\Shared\StringComparers.cs (9)

Aspire.Azure.Messaging.EventHubs.Tests (2)

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

Aspire.Azure.Security.KeyVault.Tests (2)

MockTransport.cs (2)

Aspire.Dashboard (10)

Otlp\Model\ColorGenerator.cs (1)

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

src\Shared\StringComparers.cs (9)

Aspire.Hosting (11)

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

Aspire.Hosting.Analyzers (9)

src\Shared\StringComparers.cs (9)

Aspire.Hosting.Azure (9)

src\Shared\StringComparers.cs (9)

Aspire.Hosting.Azure.PostgreSQL (9)

src\Shared\StringComparers.cs (9)

Aspire.Hosting.Azure.Sql (9)

src\Shared\StringComparers.cs (9)

Aspire.Hosting.Azure.Tests (9)

src\Shared\StringComparers.cs (9)

Aspire.Hosting.Azure.WebPubSub (1)

AzureWebPubSubResource.cs (1)

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

Aspire.Hosting.Docker (3)

DockerComposeServiceResource.cs (3)

21private static readonly HashSet<string> s_shellExecutables = new(StringComparer.OrdinalIgnoreCase) 222var ports = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 223var expose = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

Aspire.Hosting.Kubernetes (2)

Extensions\ResourceExtensions.cs (2)

76var processedKeys = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 107var processedKeys = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

Aspire.Hosting.Milvus (9)

src\Shared\StringComparers.cs (9)

Aspire.Hosting.MongoDB (9)

src\Shared\StringComparers.cs (9)

Aspire.Hosting.MySql (9)

src\Shared\StringComparers.cs (9)

Aspire.Hosting.Oracle (9)

src\Shared\StringComparers.cs (9)

Aspire.Hosting.PostgreSQL (9)

src\Shared\StringComparers.cs (9)

Aspire.Hosting.Qdrant (9)

src\Shared\StringComparers.cs (9)

Aspire.Hosting.SqlServer (9)

src\Shared\StringComparers.cs (9)

Aspire.Hosting.Tests (2)

Utils\StringComparersTests.cs (2)

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

Aspire.Hosting.Yarp (2)

ConfigurationBuilder\YarpCluster.cs (1)

54Destinations = new Dictionary<string, DestinationConfig>(StringComparer.OrdinalIgnoreCase)

ConfigurationBuilder\YarpRoute.cs (1)

163var transform = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

Aspire.Hosting.Yarp.Tests (2)

YarpConfigGeneratorTests.cs (2)

120Destinations = new Dictionary<string, DestinationConfig>(StringComparer.OrdinalIgnoreCase) 198Destinations = new Dictionary<string, DestinationConfig>(StringComparer.OrdinalIgnoreCase)

Aspire.Microsoft.Data.SqlClient (1)

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

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

Aspire.Microsoft.EntityFrameworkCore.SqlServer (1)

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

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

Aspire.Playground.Tests (1)

Infrastructure\DistributedApplicationExtensions.cs (1)

106return Task.WhenAll(applicationModel.Resources.Select(r => app.ResourceNotifications.WaitForResourceAsync(r.Name, r => targetStates?.Contains(r.Snapshot.State?.Text, StringComparer.OrdinalIgnoreCase) is true || r.Snapshot.IsHidden, cancellationToken)));

AzureAppServicesHostingStartupSample (1)

Startup.cs (1)

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

AzureAppServicesSample (1)

Startup.cs (1)

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

BinaryFormatTests (2)

FormatTests\FormattedObject\HashTableTests.cs (2)

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

BuildBoss (2)

CompilerNuGetCheckerUtil.cs (1)

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

ProjectKey.cs (1)

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

BuildValidator (1)

FileNameEqualityComparer.cs (1)

14public static readonly StringComparer StringComparer = StringComparer.OrdinalIgnoreCase;

ConfigurationSchemaGenerator (1)

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

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

Crossgen2Tasks (2)

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

csc (1)

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

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

DefaultBuilder.SampleApp (1)

Startup.cs (1)

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

dotnet-openapi (1)

Commands\BaseCommand.cs (1)

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

dotnet-svcutil-lib (22)

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

dotnet-user-secrets (1)

Internal\SecretsStore.cs (1)

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

GenerateAnalyzerNuspec (1)

Program.cs (1)

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

GenerateDocumentationAndConfigFiles (13)

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

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

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

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

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

129var map = new BidirectionalMap<string, T>(entries, StringComparer.OrdinalIgnoreCase); 130var 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\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (1)

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

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

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

HealthChecksSample (1)

Program.cs (1)

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

http2cat (1)

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

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

IIS.FunctionalTests (1)

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

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

IIS.LongTests (1)

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

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

IIS.NewHandler.FunctionalTests (1)

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

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

IIS.NewShim.FunctionalTests (1)

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

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

IISExpress.FunctionalTests (1)

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

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

IISSample (1)

Startup.cs (1)

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

illink (1)

Linker\AssemblyResolver.cs (1)

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

ILLink.Tasks (1)

LinkTask.cs (1)

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

Infrastructure.Common (3)

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

InMemory.FunctionalTests (151)

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)

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

installer.tasks (3)

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)

Interop.FunctionalTests (1)

Http3\Http3RequestTests.cs (1)

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

Metrics (12)

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

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

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

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

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

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

35? StringComparer.OrdinalIgnoreCase

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

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

Metrics.Legacy (12)

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

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

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

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

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

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

35? StringComparer.OrdinalIgnoreCase

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

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

Microsoft.Arcade.Test.Common (1)

FakeHttpClient.cs (1)

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

Microsoft.AspNetCore.Antiforgery (1)

Internal\DefaultAntiforgeryTokenGenerator.cs (1)

154var comparer = StringComparer.OrdinalIgnoreCase;

Microsoft.AspNetCore.App.Analyzers (5)

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

Microsoft.AspNetCore.Authentication.Core.Test (1)

AuthenticationSchemeProviderTests.cs (1)

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

Microsoft.AspNetCore.Authorization (1)

AuthorizationOptions.cs (1)

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

Microsoft.AspNetCore.BrowserTesting (3)

BrowserManagerConfiguration.cs (3)

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

Microsoft.AspNetCore.Components (22)

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

RenderTree\Renderer.cs (1)

43private readonly object _activityLinksStore = new Dictionary<string, CategoryLink>(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)

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

src\Shared\Components\ComponentsActivityLinkStore.cs (1)

34? new Dictionary<string, CategoryLink>(StringComparer.OrdinalIgnoreCase)

Microsoft.AspNetCore.Components.Endpoints (4)

Discovery\PageComponentBuilder.cs (1)

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

src\Shared\Components\ComponentsActivityLinkStore.cs (1)

34? new Dictionary<string, CategoryLink>(StringComparer.OrdinalIgnoreCase)

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

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

Microsoft.AspNetCore.Components.Server (1)

src\Shared\Components\ComponentsActivityLinkStore.cs (1)

34? new Dictionary<string, CategoryLink>(StringComparer.OrdinalIgnoreCase)

Microsoft.AspNetCore.Components.Tests (10)

Rendering\RenderTreeBuilderTest.cs (10)

Microsoft.AspNetCore.Components.Web (2)

HtmlRendering\StaticHtmlRenderer.HtmlWriting.cs (1)

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

JSComponents\JSComponentInterop.cs (1)

202ParameterInfoByName = new(StringComparer.OrdinalIgnoreCase);

Microsoft.AspNetCore.Components.WebAssembly (3)

.packages\microsoft.dotnet.hotreload.agent\10.0.100-preview.7.25358.102\contentFiles\cs\net6.0\MetadataUpdateHandlerInvoker.cs (1)

323var visited = new HashSet<string>(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);

Microsoft.AspNetCore.Components.WebView (2)

FileExtensionContentTypeProvider.cs (1)

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

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

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

Microsoft.AspNetCore.DataProtection.Tests (2)

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

Microsoft.AspNetCore.Diagnostics.Middleware (5)

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

Microsoft.AspNetCore.Grpc.JsonTranscoding (1)

Internal\GrpcProtocolConstants.cs (1)

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

Microsoft.AspNetCore.HeaderParsing (2)

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

Microsoft.AspNetCore.HeaderPropagation (1)

HeaderPropagationMiddleware.cs (1)

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

Microsoft.AspNetCore.HeaderPropagation.Tests (1)

HeaderPropagationMessageHandlerTest.cs (1)

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

Microsoft.AspNetCore.Hosting (4)

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

Microsoft.AspNetCore.Http (8)

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

Microsoft.AspNetCore.Http.Abstractions (13)

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

Microsoft.AspNetCore.Http.Abstractions.Tests (1)

RouteValueDictionaryTests.cs (1)

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

Microsoft.AspNetCore.Http.Connections (1)

Internal\HttpConnectionDispatcher.cs (1)

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

Microsoft.AspNetCore.Http.Extensions (3)

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

Microsoft.AspNetCore.Http.Microbenchmarks (6)

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

Microsoft.AspNetCore.Http.RequestDelegateGenerator (1)

StaticRouteHandlerModel\Model\ParameterLookupKey.cs (1)

23return StringComparer.OrdinalIgnoreCase.GetHashCode(Name);

Microsoft.AspNetCore.Http.Tests (5)

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)

Microsoft.AspNetCore.HttpLogging (3)

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

Microsoft.AspNetCore.Identity.EntityFrameworkCore.Test (1)

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

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

Microsoft.AspNetCore.Identity.FunctionalTests (1)

Pages\Account\ExternalLogin.cs (1)

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

Microsoft.AspNetCore.Identity.InMemory.Test (1)

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

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

Microsoft.AspNetCore.Identity.Test (1)

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

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

Microsoft.AspNetCore.InternalTesting (1)

Tracing\CollectingEventListener.cs (1)

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

Microsoft.AspNetCore.InternalTesting.Tests (1)

AlphabeticalOrderer.cs (1)

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

Microsoft.AspNetCore.Mvc.Abstractions (2)

Abstractions\ActionDescriptor.cs (1)

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

src\Shared\ParameterBindingMethodCache.cs (1)

720return StringComparer.OrdinalIgnoreCase.GetHashCode(Name);

Microsoft.AspNetCore.Mvc.ApiExplorer (1)

DefaultApiDescriptionProvider.cs (1)

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

Microsoft.AspNetCore.Mvc.Core (29)

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

Microsoft.AspNetCore.Mvc.Core.Test (119)

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)

Microsoft.AspNetCore.Mvc.Core.TestCommon (1)

SimpleValueProvider.cs (1)

18: base(StringComparer.OrdinalIgnoreCase)

Microsoft.AspNetCore.Mvc.FunctionalTests (5)

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)

Microsoft.AspNetCore.Mvc.NewtonsoftJson (2)

BsonTempDataSerializer.cs (2)

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

Microsoft.AspNetCore.Mvc.NewtonsoftJson.Test (1)

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

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

Microsoft.AspNetCore.Mvc.Razor (8)

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)

Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation (1)

RuntimeViewCompiler.cs (1)

65StringComparer.OrdinalIgnoreCase);

Microsoft.AspNetCore.Mvc.RazorPages (6)

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

Microsoft.AspNetCore.Mvc.RazorPages.Test (8)

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)

Microsoft.AspNetCore.Mvc.TagHelpers (12)

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)

Microsoft.AspNetCore.Mvc.TagHelpers.Test (8)

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

Microsoft.AspNetCore.Mvc.ViewFeatures (17)

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

Microsoft.AspNetCore.Mvc.ViewFeatures.Test (1)

CookieTempDataProviderTest.cs (1)

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

Microsoft.AspNetCore.OpenApi (2)

Services\OpenApiDocumentService.cs (1)

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

Microsoft.AspNetCore.OutputCaching (6)

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

Microsoft.AspNetCore.RequestDecompression (1)

RequestDecompressionOptions.cs (1)

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

Microsoft.AspNetCore.ResponseCaching (1)

ResponseCachingKeyProvider.cs (1)

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

Microsoft.AspNetCore.ResponseCompression (3)

ResponseCompressionProvider.cs (3)

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

Microsoft.AspNetCore.Rewrite (1)

ApacheModRewrite\FlagParser.cs (1)

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

Microsoft.AspNetCore.Routing (37)

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)

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

Microsoft.AspNetCore.Routing.Abstractions (2)

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

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

Microsoft.AspNetCore.Routing.Tests (1)

DecisionTreeBuilderTest.cs (1)

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

Microsoft.AspNetCore.Server.HttpSys (5)

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

Microsoft.AspNetCore.Server.HttpSys.FunctionalTests (7)

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

Microsoft.AspNetCore.Server.IIS (4)

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

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

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

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

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

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

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

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

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

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

Microsoft.AspNetCore.Shared.Tests (28)

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)

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

Microsoft.AspNetCore.SignalR.Core (3)

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

Microsoft.AspNetCore.SignalR.StackExchangeRedis (1)

RedisHubLifetimeManager.cs (1)

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

Microsoft.AspNetCore.SpaServices.Extensions (3)

Proxying\SpaProxy.cs (3)

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

Microsoft.AspNetCore.StaticFiles (1)

FileExtensionContentTypeProvider.cs (1)

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

Microsoft.AspNetCore.WebUtilities (3)

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

Microsoft.Build.Framework (9)

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

Microsoft.Build.Tasks.CodeAnalysis (1)

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

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

Microsoft.Build.Tasks.CodeAnalysis.Sdk (1)

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

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

Microsoft.Build.Tasks.CodeAnalysis.UnitTests (1)

TestUtilities\SimpleTaskItem.cs (1)

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

Microsoft.Cci.Extensions (27)

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

Microsoft.CodeAnalysis (20)

Collections\IdentifierCollection.cs (1)

28StringComparer.OrdinalIgnoreCase);

CommandLine\AnalyzerConfigSet.cs (1)

333var comparer = StringComparer.OrdinalIgnoreCase;

Compilation\Compilation.cs (1)

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

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

MetadataReader\PEModule.cs (1)

3808var 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;

Microsoft.CodeAnalysis.Analyzers (14)

MetaAnalyzers\DiagnosticDescriptorCreationAnalyzer_ReleaseTracking.cs (1)

252StringComparer comparer = StringComparer.OrdinalIgnoreCase;

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

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

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

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

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

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

35? StringComparer.OrdinalIgnoreCase

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

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

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

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

Microsoft.CodeAnalysis.AnalyzerUtilities (12)

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

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

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

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

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

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

35? StringComparer.OrdinalIgnoreCase

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

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

Microsoft.CodeAnalysis.BannedApiAnalyzers (14)

RestrictedInternalsVisibleToAnalyzer.cs (1)

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

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

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

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

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

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

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

35? StringComparer.OrdinalIgnoreCase

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

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

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

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

Microsoft.CodeAnalysis.CodeStyle (15)

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

255userExclusions.Contains(id, StringComparer.OrdinalIgnoreCase)) 807userIdExclusions.Contains(id, StringComparer.OrdinalIgnoreCase) || 808category?.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\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)

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

35? StringComparer.OrdinalIgnoreCase

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

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

Microsoft.CodeAnalysis.CodeStyle.Fixes (2)

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

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

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

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

Microsoft.CodeAnalysis.CSharp (5)

CommandLine\CSharpCompiler.cs (1)

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

CSharpParseOptions.cs (1)

166features?.ToImmutableDictionary(StringComparer.OrdinalIgnoreCase)

Symbols\MissingModuleSymbol.cs (1)

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

Symbols\Source\SourceAssemblySymbol.cs (2)

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

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

CommandLineTests.cs (2)

8496}, StringComparer.OrdinalIgnoreCase); 8506}, StringComparer.OrdinalIgnoreCase);

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

Completion\CompletionProviders\LoadDirectiveCompletionProviderTests.cs (1)

29=> StringComparer.OrdinalIgnoreCase;

Completion\CompletionProviders\ReferenceDirectiveCompletionProviderTests.cs (1)

32=> StringComparer.OrdinalIgnoreCase;

Microsoft.CodeAnalysis.CSharp.Emit.UnitTests (4)

Emit\EmitMetadataTests.cs (4)

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

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

SourceGeneration\AdditionalSourcesCollectionTests.cs (1)

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

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

Compilation\CompilationAPITests.cs (2)

501Assert.Equal("mscorlib", assemblySmb.Name, StringComparer.OrdinalIgnoreCase); 1198Assert.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);

Microsoft.CodeAnalysis.CSharp.Test.Utilities (2)

EmitMetadataTestBase.cs (1)

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

SymbolUtilities.cs (1)

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

Microsoft.CodeAnalysis.EditorFeatures (6)

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;

Microsoft.CodeAnalysis.EditorFeatures.UnitTests (2)

Utilities\BloomFilterTests.cs (2)

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

Microsoft.CodeAnalysis.ExpressionEvaluator.ExpressionCompiler (1)

MetadataUtilities.cs (1)

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

Microsoft.CodeAnalysis.ExpressionEvaluator.FunctionResolver (3)

MetadataResolver.cs (2)

39_stringComparer = ignoreCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal; 282var comparer = _ignoreCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;

VisualBasic\MemberSignatureParser.cs (1)

16internal static readonly StringComparer StringComparer = StringComparer.OrdinalIgnoreCase;

Microsoft.CodeAnalysis.ExpressionEvaluator.FunctionResolver.UnitTests (1)

VisualBasicParsingTests.cs (1)

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

Microsoft.CodeAnalysis.Extensions.Package (1)

Symbols\INamedTypeSymbolExtensions.cs (1)

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

Microsoft.CodeAnalysis.ExternalAccess.FSharp (2)

VS\IFSharpWorkspaceProjectContextFactory.cs (2)

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

Microsoft.CodeAnalysis.Features (32)

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

CodeRefactorings\CodeRefactoringService.cs (2)

316StringComparer.OrdinalIgnoreCase.Equals(DocumentExtension, other.DocumentExtension); 321return (Language, DocumentKind, StringComparer.OrdinalIgnoreCase.GetHashCode(DocumentExtension)).GetHashCode();

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)

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

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

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

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

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

Microsoft.CodeAnalysis.InteractiveHost (2)

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;

Microsoft.CodeAnalysis.LanguageServer (4)

HostWorkspace\FileWatching\LspFileChangeWatcher.cs (1)

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

HostWorkspace\ProjectDependencyHelper.cs (2)

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

Logging\LspLogMessageLoggerProvider.cs (1)

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

Microsoft.CodeAnalysis.LanguageServer.Protocol (4)

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)

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

Protocol\DocumentUri.cs (1)

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

Microsoft.CodeAnalysis.PerformanceSensitiveAnalyzers (13)

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

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

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

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

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

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

35? StringComparer.OrdinalIgnoreCase

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

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

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

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

Microsoft.CodeAnalysis.PublicApiAnalyzers (12)

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

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

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

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

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

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

35? StringComparer.OrdinalIgnoreCase

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

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

Microsoft.CodeAnalysis.PublicApiAnalyzers.CodeFixes (1)

DeclarePublicApiFix.cs (1)

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

Microsoft.CodeAnalysis.Rebuild.UnitTests (1)

RebuildCommandLineTests.cs (1)

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

Microsoft.CodeAnalysis.ResxSourceGenerator (12)

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

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

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

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

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

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

35? StringComparer.OrdinalIgnoreCase

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

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

Microsoft.CodeAnalysis.Scripting (6)

Hosting\AssemblyLoader\MetadataShadowCopyProvider.cs (1)

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

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

344int comparisonResult = StringComparer.OrdinalIgnoreCase.Compare(x.Name, y.Name);

Hosting\ObjectFormatter\ObjectFormatterHelpers.cs (1)

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

Hosting\Resolvers\RuntimeMetadataReferenceResolver.cs (1)

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

Microsoft.CodeAnalysis.Test.Utilities (7)

CompilationVerifier.cs (2)

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

Platform\Desktop\RuntimeAssemblyManager.cs (3)

72_fullNameToAssemblyDataMap = new Dictionary<string, AssemblyData>(StringComparer.OrdinalIgnoreCase); 82_preloadedSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 239fullMatch = _preloadedSet.Contains(id.SimpleName) || StringComparer.OrdinalIgnoreCase.Equals(id.FullName, assemblyData.Id.FullName);

TargetFrameworkUtil.cs (1)

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

TestableFileSystem.cs (1)

56comparer ??= StringComparer.OrdinalIgnoreCase;

Microsoft.CodeAnalysis.UnitTests (68)

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

315dict = System.Linq.ImmutableArrayExtensions.ToDictionary(roa, s => s.Split(':').First(), StringComparer.OrdinalIgnoreCase); 327dict = System.Linq.ImmutableArrayExtensions.ToDictionary(roa, s => s.Split(':').First(), s => s.Split(':').Last(), StringComparer.OrdinalIgnoreCase); 341Assert.True(a.SequenceEqual(b, StringComparer.OrdinalIgnoreCase)); 344Assert.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)

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

Microsoft.CodeAnalysis.VisualBasic (1)

Symbols\MissingModuleSymbol.vb (1)

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

Microsoft.CodeAnalysis.Workspaces (26)

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

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

35? StringComparer.OrdinalIgnoreCase

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

593var comparer = caseSensitive ? StringComparer.Ordinal : 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)

134private 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;

Microsoft.CodeAnalysis.Workspaces.MSBuild (5)

MSBuild\MSBuildProjectLoader.cs (2)

45Properties = ImmutableDictionary.Create<string, string>(StringComparer.OrdinalIgnoreCase); 67Properties = ImmutableDictionary.Create<string, string>(StringComparer.OrdinalIgnoreCase);

MSBuild\ProjectFileExtensionRegistry.cs (1)

26_extensionToLanguageMap = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)

MSBuild\SolutionFileReader.SolutionFilterReader.cs (1)

50var filterProjects = ImmutableHashSet.CreateBuilder<string>(StringComparer.OrdinalIgnoreCase);

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

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

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

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)

66StringComparer.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);

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

FileSet.cs (1)

26var builder = ImmutableDictionary.CreateBuilder<string, object>(StringComparer.OrdinalIgnoreCase);

SolutionGeneration.cs (1)

68var files = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

Microsoft.CodeAnalysis.Workspaces.UnitTests (6)

SolutionTests\SolutionTests.cs (5)

4655Assert.Equal("test5.cs", syntaxTrees[0].FilePath, StringComparer.OrdinalIgnoreCase); 4656Assert.Equal("test4.cs", syntaxTrees[1].FilePath, StringComparer.OrdinalIgnoreCase); 4657Assert.Equal("test3.cs", syntaxTrees[2].FilePath, StringComparer.OrdinalIgnoreCase); 4658Assert.Equal("test2.cs", syntaxTrees[3].FilePath, StringComparer.OrdinalIgnoreCase); 4659Assert.Equal("test1.cs", syntaxTrees[4].FilePath, StringComparer.OrdinalIgnoreCase);

UtilityTest\ImmutableDictionaryExtensionsTests.cs (1)

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

Microsoft.DotNet.Arcade.Sdk (1)

src\InstallDotNetCore.cs (1)

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

Microsoft.DotNet.ArcadeLogging (2)

PipelinesLogger.cs (2)

49_ignoredTargets = new HashSet<string>(ignoredTargets, StringComparer.OrdinalIgnoreCase); 319internal static StringComparer Comparer => StringComparer.OrdinalIgnoreCase;

Microsoft.DotNet.Build.Manifest (7)

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)

Microsoft.DotNet.Build.Tasks.Packaging (7)

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

Microsoft.DotNet.Build.Tasks.Templating (1)

MSBuildListSplitter.cs (1)

14Dictionary<string, string> values = new(StringComparer.OrdinalIgnoreCase);

Microsoft.DotNet.Build.Tasks.VisualStudio (2)

OptProf\IbcEntry.cs (2)

60return StringComparer.OrdinalIgnoreCase.Equals(ext, ".dll") || 61StringComparer.OrdinalIgnoreCase.Equals(ext, ".exe");

Microsoft.DotNet.CodeAnalysis (4)

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

Microsoft.DotNet.NuGetRepack.Tasks (2)

src\UpdatePackageVersionTask.cs (2)

59else if (StringComparer.OrdinalIgnoreCase.Equals(VersionKind, "release")) 63else if (StringComparer.OrdinalIgnoreCase.Equals(VersionKind, "prerelease"))

Microsoft.DotNet.PackageTesting (3)

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

Microsoft.DotNet.SharedFramework.Sdk (6)

src\CreateFrameworkListFile.cs (1)

73StringComparer.OrdinalIgnoreCase);

src\FileUtilities.cs (1)

18StringComparer.OrdinalIgnoreCase);

src\Microsoft.DotNet.PackageTesting\VerifyClosure.cs (3)

src\ValidateFileVersions.cs (1)

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

Microsoft.DotNet.SignTool (7)

src\SignToolConstants.cs (2)

38public static readonly HashSet<string> SignableExtensions = new HashSet<string>(StringComparer.OrdinalIgnoreCase) 125new HashSet<string>(StringComparer.OrdinalIgnoreCase)

src\SignToolTask.cs (5)

243var filesToSkip3rdPartyCheck = ItemsToSkip3rdPartyCheck?.Select(i => i.ItemSpec).ToHashSet(StringComparer.OrdinalIgnoreCase); 321var map = new Dictionary<string, List<AdditionalCertificateInformation>>(StringComparer.OrdinalIgnoreCase); 416private readonly HashSet<string> specialExtensions = new HashSet<string>(StringComparer.OrdinalIgnoreCase) 423var map = new Dictionary<string, List<SignInfo>>(StringComparer.OrdinalIgnoreCase); 470var map = new Dictionary<string, List<SignInfo>>(StringComparer.OrdinalIgnoreCase);

Microsoft.DotNet.SignTool.Tests (3)

SignToolTests.cs (3)

1001var noWarn3rdPartySet = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "EmptyPKT.dll" }; 2856var needContent = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) 2896var needContent = new Dictionary<string, (string, string[])>(StringComparer.OrdinalIgnoreCase)

Microsoft.DotNet.SourceBuild.Tasks (3)

src\UsageReport\WritePackageUsageData.cs (1)

196StringComparer.OrdinalIgnoreCase);

src\UsageReport\WriteUsageReports.cs (2)

69StringComparer.OrdinalIgnoreCase); 91var poisonNupkgFilenames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

Microsoft.DotNet.SwaggerGenerator.CodeGenerator (1)

Languages\Language.cs (1)

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

Microsoft.DotNet.XliffTasks (1)

Tasks\GatherXlf.cs (1)

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

Microsoft.DotNet.XUnitAssert.Tests (16)

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)

Microsoft.Extensions.AI.Abstractions (9)

AdditionalPropertiesDictionary{TValue}.cs (3)

33_dictionary = new(StringComparer.OrdinalIgnoreCase); 39_dictionary = new(dictionary, StringComparer.OrdinalIgnoreCase); 48_dictionary = new Dictionary<string, TValue>(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\LegacySupport\StringHash\StringHash.cs (1)

24StringComparison.OrdinalIgnoreCase => StringComparer.OrdinalIgnoreCase,

src\Shared\JsonSchemaExporter\JsonSchemaExporter.ReflectionHelpers.cs (1)

413public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Name);

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

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

Microsoft.Extensions.Configuration (2)

ConfigurationProvider.cs (1)

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

InternalConfigurationRootExtensions.cs (1)

29.Distinct(StringComparer.OrdinalIgnoreCase)

Microsoft.Extensions.Configuration.Binder (2)

ConfigurationBinder.cs (2)

230StringComparer.OrdinalIgnoreCase); 626HashSet<string> propertyNames = new(StringComparer.OrdinalIgnoreCase);

Microsoft.Extensions.Configuration.CommandLine (2)

CommandLineConfigurationProvider.cs (2)

43var data = new Dictionary<string, string?>(StringComparer.OrdinalIgnoreCase); 140var switchMappingsCopy = new Dictionary<string, string>(switchMappings.Count, StringComparer.OrdinalIgnoreCase);

Microsoft.Extensions.Configuration.EnvironmentVariables (1)

EnvironmentVariablesConfigurationProvider.cs (1)

74var data = new Dictionary<string, string?>(StringComparer.OrdinalIgnoreCase);

Microsoft.Extensions.Configuration.FileExtensions (2)

FileConfigurationProvider.cs (2)

63Data = new Dictionary<string, string?>(StringComparer.OrdinalIgnoreCase); 105Data = new Dictionary<string, string?>(StringComparer.OrdinalIgnoreCase);

Microsoft.Extensions.Configuration.Ini (1)

IniStreamConfigurationProvider.cs (1)

28var data = new Dictionary<string, string?>(StringComparer.OrdinalIgnoreCase);

Microsoft.Extensions.Configuration.Json (1)

JsonConfigurationFileParser.cs (1)

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

Microsoft.Extensions.Configuration.KeyPerFile (1)

KeyPerFileConfigurationProvider.cs (1)

60var data = new Dictionary<string, string?>(StringComparer.OrdinalIgnoreCase);

Microsoft.Extensions.Configuration.Xml (2)

XmlStreamConfigurationProvider.cs (2)

94var children = new Dictionary<string, List<XmlConfigurationElement>>(StringComparer.OrdinalIgnoreCase); 257Dictionary<string, string?> configuration = new(StringComparer.OrdinalIgnoreCase);

Microsoft.Extensions.DependencyModel (3)

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

Microsoft.Extensions.Diagnostics.HealthChecks (2)

DefaultHealthCheckService.cs (2)

62var entries = new Dictionary<string, HealthReportEntry>(StringComparer.OrdinalIgnoreCase); 165var distinctRegistrations = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

Microsoft.Extensions.Diagnostics.HealthChecks.Abstractions (2)

HealthCheckRegistration.cs (2)

68Tags = new HashSet<string>(tags ?? Array.Empty<string>(), StringComparer.OrdinalIgnoreCase); 120Tags = new HashSet<string>(tags ?? Array.Empty<string>(), StringComparer.OrdinalIgnoreCase);

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

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)

Microsoft.Extensions.FileProviders.Physical (2)

PhysicalFilesWatcher.cs (2)

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

Microsoft.Extensions.FileSystemGlobbing (2)

FilePatternMatch.cs (1)

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

Util\StringComparisonHelper.cs (1)

15StringComparison.OrdinalIgnoreCase => StringComparer.OrdinalIgnoreCase,

Microsoft.Extensions.Http (1)

DependencyInjection\HttpClientBuilderExtensions.cs (1)

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

Microsoft.Extensions.Http.Diagnostics (4)

Logging\Internal\HttpHeadersReader.cs (2)

32_requestHeadersToLog = options.RequestHeadersDataClasses.ToFrozenDictionary(StringComparer.OrdinalIgnoreCase); 33_responseHeadersToLog = options.ResponseHeadersDataClasses.ToFrozenDictionary(StringComparer.OrdinalIgnoreCase);

Logging\Internal\HttpRequestBodyReader.cs (1)

28_readableRequestContentTypes = requestOptions.RequestBodyContentTypes.ToFrozenSet(StringComparer.OrdinalIgnoreCase);

Logging\Internal\HttpResponseBodyReader.cs (1)

37_readableResponseContentTypes = responseOptions.ResponseBodyContentTypes.ToFrozenSet(StringComparer.OrdinalIgnoreCase);

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

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

Microsoft.Extensions.Http.Resilience.Tests (2)

Helpers\ConfigurationStubFactory.cs (1)

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

Routing\RoutingStrategyTest.cs (1)

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

Microsoft.Extensions.Logging.Console (1)

ConsoleLoggerProvider.cs (1)

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

Microsoft.Extensions.Logging.Generators (1)

LoggerMessageGenerator.Parser.cs (1)

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

Microsoft.Extensions.Logging.TraceSource (1)

TraceSourceLoggerProvider.cs (1)

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

Microsoft.Extensions.Primitives (1)

StringSegmentComparer.cs (1)

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

Microsoft.Extensions.ServiceDiscovery (1)

Http\ResolvingHttpDelegatingHandler.cs (1)

115if (options.AllowAllSchemes || options.AllowedSchemes.Contains(scheme, StringComparer.OrdinalIgnoreCase))

Microsoft.Extensions.ServiceDiscovery.Dns.Tests.Fuzzing (1)

Program.cs (1)

16.OrderBy(f => f.Name, StringComparer.OrdinalIgnoreCase)

Microsoft.Extensions.ServiceDiscovery.Yarp (1)

ServiceDiscoveryDestinationResolver.cs (1)

115if (_options.AllowAllSchemes || _options.AllowedSchemes.Contains(scheme, StringComparer.OrdinalIgnoreCase))

Microsoft.Gen.Logging (3)

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

Microsoft.Maui (1)

Handlers\HybridWebView\FileExtensionContentTypeProvider.cs (1)

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

Microsoft.Maui.Controls (1)

Visuals\VisualTypeConverter.cs (1)

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

Microsoft.Maui.Controls.DesignTools (2)

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

Microsoft.Maui.Graphics (1)

Text\TextColors.cs (1)

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

Microsoft.Maui.Resizetizer (1)

ColorTable.cs (1)

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

Microsoft.ML.GenAI.Core (2)

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

Microsoft.ML.ImageAnalytics (1)

MLImage.cs (1)

427private static readonly Dictionary<string, SKEncodedImageFormat> _extensionToEncodingFormat = new Dictionary<string, SKEncodedImageFormat>(StringComparer.OrdinalIgnoreCase)

Microsoft.ML.Tokenizers (2)

Model\TiktokenTokenizer.cs (2)

1043new Dictionary<string, ModelEncoding>(StringComparer.OrdinalIgnoreCase) 1215private static readonly ConcurrentDictionary<string, (Dictionary<ReadOnlyMemory<byte>, int> encoder, Dictionary<StringSpanOrdinalKey, (int Id, string Token)> vocab, Dictionary<int, ReadOnlyMemory<byte>> decoder)> _tiktokenCache = new(StringComparer.OrdinalIgnoreCase);

Microsoft.VisualStudio.LanguageServices (21)

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)

349if (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)

607if (StringComparer.OrdinalIgnoreCase.Equals(reference.Path, filePath)) 815var folderItem = items.FirstOrDefault(p => StringComparer.OrdinalIgnoreCase.Compare(p.Name, folder) == 0); 1272var 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),

Microsoft.VisualStudio.LanguageServices.CSharp.UnitTests (22)

DocumentOutline\DocumentOutlineTests.cs (1)

108SortOption.Name => sortedSymbols.OrderBy(static x => x.Data.Name, StringComparer.OrdinalIgnoreCase),

ProjectSystemShim\CPS\SourceFileHandlingTests.cs (21)

Microsoft.VisualStudio.LanguageServices.LiveShare (2)

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

Microsoft.VisualStudio.LanguageServices.Xaml (1)

Implementation\XamlProjectService.cs (1)

38private readonly ConcurrentDictionary<string, DocumentId> _documentIds = new ConcurrentDictionary<string, DocumentId>(StringComparer.OrdinalIgnoreCase);

NativeIISSample (1)

Startup.cs (1)

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

PresentationBuildTasks (4)

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

PresentationCore (3)

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

PresentationFramework (2)

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

Replay.cs (2)

149var outputSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 223var hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

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

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

Roslyn.Compilers.Extension (1)

CompilerPackage.cs (1)

68var filesToWrite = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

Roslyn.Diagnostics.Analyzers (13)

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

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

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

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

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

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

35? StringComparer.OrdinalIgnoreCase

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

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

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

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

RoutingSandbox (1)

UseEndpointRoutingStartup.cs (1)

39foreach (var endpoint in dataSource.Endpoints.OfType<RouteEndpoint>().OrderBy(e => e.RoutePattern.RawText, StringComparer.OrdinalIgnoreCase))

RoutingWebSite (1)

UseEndpointRoutingStartup.cs (1)

45foreach (var endpoint in dataSource.Endpoints.OfType<RouteEndpoint>().OrderBy(e => e.RoutePattern.RawText, StringComparer.OrdinalIgnoreCase))

RulesetToEditorconfigConverter (1)

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

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

RunTests (1)

Program.cs (1)

23StringComparer.OrdinalIgnoreCase,

Security.TransportSecurity.IntegrationTests (2)

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

Shared (1)

JsonSchemaExporter\JsonSchemaExporter.ReflectionHelpers.cs (1)

413public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Name);

Swaggatherer (1)

Template.cs (1)

16StringComparer.OrdinalIgnoreCase);

System.CodeDom (5)

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.Immutable (24)

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

System\Collections\Specialized\HybridDictionary.cs (7)

53hashtable = new Hashtable(initialSize, StringComparer.OrdinalIgnoreCase); 111list = new ListDictionary(caseInsensitive ? StringComparer.OrdinalIgnoreCase : null); 117private ListDictionary List => list ??= new ListDictionary(caseInsensitive ? StringComparer.OrdinalIgnoreCase : null); 126newTable = new Hashtable(InitialHashtableSize, StringComparer.OrdinalIgnoreCase); 236list = new ListDictionary(caseInsensitive ? StringComparer.OrdinalIgnoreCase : null); 306list ??= new ListDictionary(caseInsensitive ? StringComparer.OrdinalIgnoreCase : null); 317list ??= new ListDictionary(caseInsensitive ? StringComparer.OrdinalIgnoreCase : null);

System.ComponentModel.TypeConverter (4)

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

System.Configuration.ConfigurationManager (9)

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)

System.Data.Common (5)

src\libraries\Common\src\System\Data\Common\DbConnectionOptions.Common.cs (1)

151(0 == StringComparer.OrdinalIgnoreCase.Compare(strvalue, strconst));

System\Data\Common\DbConnectionStringBuilder.cs (4)

65values = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase); 412Hashtable descriptors = new Hashtable(StringComparer.OrdinalIgnoreCase); 508if (StringComparer.OrdinalIgnoreCase.Equals(DbConnectionStringKeywords.Password, keyword) || 509StringComparer.OrdinalIgnoreCase.Equals(DbConnectionStringSynonyms.Pwd, keyword))

System.Data.Odbc (20)

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

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.Drawing.Primitives (1)

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

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

System.Net.Mail (4)

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)

System.Net.WebHeaderCollection (2)

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

System.Private.CoreLib (17)

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.Private.Uri (1)

System\Uri.cs (1)

1539return StringComparer.OrdinalIgnoreCase.GetHashCode(remoteUrl);

System.Private.Xml (2)

System\Xml\Xsl\XsltOld\HtmlProps.cs (2)

57Hashtable table = new Hashtable(71, StringComparer.OrdinalIgnoreCase); 168Hashtable table = new Hashtable(26, StringComparer.OrdinalIgnoreCase);

System.Reflection.MetadataLoadContext (1)

System\Reflection\PathAssemblyResolver.cs (1)

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

System.Resources.Extensions (3)

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

System.Resources.Writer (2)

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

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

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

System.Runtime.Serialization.Schema (3)

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.ServiceModel.Syndication (1)

System\ServiceModel\Syndication\SyndicationFeed.cs (1)

17StringComparer.OrdinalIgnoreCase

System.Text.Encoding.CodePages (1)

System\Text\EncodingTable.cs (1)

12private static readonly Dictionary<string, int> s_nameToCodePageCache = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);

System.Text.Json (5)

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

281? StringComparer.OrdinalIgnoreCase

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

63_enumFieldInfoIndex = new(StringComparer.OrdinalIgnoreCase);

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

1051public Dictionary<string, (JsonPropertyInfo, int index)> AddedProperties = new(options.PropertyNameCaseInsensitive ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal); 1060public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Name); 1073StringComparer comparer = Options.PropertyNameCaseInsensitive ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;

System.Text.Json.SourceGeneration (1)

JsonSourceGenerator.Parser.cs (1)

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

System.Web.HttpUtility (1)

System\Web\HttpUtility.cs (1)

46: base(StringComparer.OrdinalIgnoreCase)

System.Windows.Forms.Design (1)

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

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

System.Windows.Forms.Primitives (1)

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

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

System.Xaml (1)

System\Xaml\XamlSchemaContext.cs (1)

589Dictionary<string, SpecialBracketCharacters> map = new Dictionary<string, SpecialBracketCharacters>(StringComparer.OrdinalIgnoreCase);

TagHelpersWebSite (1)

TagHelpers\PrettyTagHelper.cs (1)

14new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)

TaskUsageLogger (1)

TaskUsageLogger.cs (1)

79_assemblyLocationsByName = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

Test.Utilities (12)

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

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

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

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

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

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

35? StringComparer.OrdinalIgnoreCase

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

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

Text.Analyzers (15)

CodeAnalysisDictionary.cs (2)

53_recognizedWords = new HashSet<string>(recognizedWords, StringComparer.OrdinalIgnoreCase); 54_unrecognizedWords = new HashSet<string>(unrecognizedWords, StringComparer.OrdinalIgnoreCase);

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

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

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

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

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

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

35? StringComparer.OrdinalIgnoreCase

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

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

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

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

vbc (1)

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

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

VBCSCompiler (1)

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

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

XmlFileLogger (3)

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

xunit.console (13)

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