StringComparer

5 types derived from StringComparer

Microsoft.CodeAnalysis (1)

CaseInsensitiveComparison.cs (1)

87private sealed class OneToOneUnicodeComparer : StringComparer

Microsoft.CodeAnalysis.ExpressionEvaluator.ResultProvider (1)

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

87private sealed class OneToOneUnicodeComparer : StringComparer

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

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

87private sealed class OneToOneUnicodeComparer : StringComparer

System.Private.CoreLib (2)

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

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

3611 references to StringComparer

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

src\Shared\StringComparers.cs (48)

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

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

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

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

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

Otlp\Model\ColorGenerator.cs (1)

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

src\Shared\StringComparers.cs (48)

Utils\GlobalizationHelpers.cs (1)

37OrderedLocalizedCultures = localizedCultureInfos.OrderBy(c => c.NativeName, StringComparer.InvariantCultureIgnoreCase).ToList();

Aspire.Hosting (52)

ApplicationModel\ContainerFileSystemCallbackAnnotation.cs (1)

125foreach (var file in Directory.GetFiles(path, searchPattern, searchOptions).Order(StringComparer.Ordinal))

Dashboard\DashboardLifecycleHook.cs (2)

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

src\Shared\SecretsStore.cs (1)

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

src\Shared\StringComparers.cs (48)

Aspire.Hosting.Analyzers (48)

src\Shared\StringComparers.cs (48)

Aspire.Hosting.Azure (48)

src\Shared\StringComparers.cs (48)

Aspire.Hosting.Azure.PostgreSQL (48)

src\Shared\StringComparers.cs (48)

Aspire.Hosting.Azure.Sql (48)

src\Shared\StringComparers.cs (48)

Aspire.Hosting.Azure.Tests (48)

src\Shared\StringComparers.cs (48)

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

src\Shared\StringComparers.cs (48)

Aspire.Hosting.MongoDB (48)

src\Shared\StringComparers.cs (48)

Aspire.Hosting.MySql (48)

src\Shared\StringComparers.cs (48)

Aspire.Hosting.Oracle (48)

src\Shared\StringComparers.cs (48)

Aspire.Hosting.PostgreSQL (48)

src\Shared\StringComparers.cs (48)

Aspire.Hosting.Qdrant (48)

src\Shared\StringComparers.cs (48)

Aspire.Hosting.Sdk.Tests (2)

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

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

Aspire.Hosting.SqlServer (48)

src\Shared\StringComparers.cs (48)

Aspire.Hosting.Tests (20)

Utils\StringComparersTests.cs (20)

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

Aspire.RuntimeIdentifier.Tool (2)

NuGetUtils.cs (2)

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)

BuildActionTelemetryTable (2)

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

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

BuildBoss (3)

CompilerNuGetCheckerUtil.cs (2)

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

FileNameEqualityComparer.cs (2)

14public static readonly StringComparer StringComparer = StringComparer.OrdinalIgnoreCase;

CodeGenerator (2)

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

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

ConfigurationSchemaGenerator (2)

ConfigSchemaEmitter.cs (1)

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

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

GlobalTool.cs (2)

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

dotnet-svcutil-lib (29)

Bootstrapper\SvcutilBootstrapper.cs (1)

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

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

58_files = new Hashtable(StringComparer.OrdinalIgnoreCase);

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

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

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

3323importList = new SortedList(StringComparer.Ordinal);

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

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

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

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

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

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

FrameworkFork\System.ServiceModel\Internals\System\Runtime\UrlUtility.cs (1)

487: base(StringComparer.OrdinalIgnoreCase)

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

73s_dnsComparer = new ClaimComparer(StringComparer.OrdinalIgnoreCase);

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

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

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

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

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

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

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

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

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

418return StringComparer.OrdinalIgnoreCase.GetHashCode(uriString);

Metadata\MetadataFileNameManager.cs (3)

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

Shared\MSBuildProj.cs (1)

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

Shared\Options\OptionBase.cs (2)

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

Shared\Options\OptionValueParser.cs (1)

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

Shared\ProjectDependency.cs (2)

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

Shared\ProjectPropertyResolver.cs (2)

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

Shared\Utilities\RuntimeEnvironmentHelper.cs (1)

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

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

Program.cs (1)

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

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

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

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

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

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

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

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

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

55return StringComparer.Ordinal.Compare(

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

32_fullNameToTypeMap = new ConcurrentDictionary<string, INamedTypeSymbol?>(StringComparer.Ordinal); 82new(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 (3)

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

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

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

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

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

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

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

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

88StringComparer StringComparer { get; }

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

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

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

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

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

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

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

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

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

Linker\AssemblyResolver.cs (1)

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

Linker\LinkContext.cs (2)

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

ILLink.Tasks (2)

CreateRuntimeRootDescriptorFile.cs (1)

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

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

IOperationGenerator (2)

IOperationClassWriter.cs (2)

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

JwtClientSample (1)

Program.cs (1)

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

Metrics (29)

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

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

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

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

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

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

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

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

55return StringComparer.Ordinal.Compare(

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

32_fullNameToTypeMap = new ConcurrentDictionary<string, INamedTypeSymbol?>(StringComparer.Ordinal); 82new(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 (3)

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

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

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

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

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

88StringComparer StringComparer { get; }

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

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

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

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

Metrics.Legacy (29)

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

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

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

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

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

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

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

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

55return StringComparer.Ordinal.Compare(

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

32_fullNameToTypeMap = new ConcurrentDictionary<string, INamedTypeSymbol?>(StringComparer.Ordinal); 82new(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 (3)

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

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

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

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

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

88StringComparer StringComparer { get; }

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

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

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

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

Microsoft.Analyzers.Local.Tests (1)

InternalReferencedInPublicDocAnalyzerTests.cs (1)

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

Microsoft.Arcade.Test.Common (1)

FakeHttpClient.cs (1)

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

Microsoft.AspNetCore.Analyzer.Testing (1)

TestSource.cs (1)

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

Microsoft.AspNetCore.Antiforgery (3)

Internal\DefaultAntiforgeryTokenGenerator.cs (3)

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

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.Abstractions (5)

AuthenticationOptions.cs (1)

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

AuthenticationProperties.cs (4)

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

Microsoft.AspNetCore.Authentication.Core (2)

AuthenticationHandlerProvider.cs (1)

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

AuthenticationSchemeProvider.cs (1)

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

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

AuthenticationSchemeProviderTests.cs (1)

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

Microsoft.AspNetCore.Authorization (2)

AuthorizationOptions.cs (1)

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

ClaimsAuthorizationRequirement.cs (1)

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

Microsoft.AspNetCore.BrowserTesting (4)

BrowserManager.cs (1)

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

BrowserManagerConfiguration.cs (3)

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

Microsoft.AspNetCore.Components (25)

PersistentState\ComponentStatePersistenceManager.cs (1)

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

PersistentState\PersistentServicesRegistry.cs (1)

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

Reflection\ComponentProperties.cs (4)

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

Reflection\MemberAssignment.cs (1)

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

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

Discovery\PageComponentBuilder.cs (1)

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

Rendering\EndpointHtmlRenderer.EventDispatch.cs (1)

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

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

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

src\Shared\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.Endpoints.Tests (2)

Builder\TestFileProvider\TestFileProvider.cs (2)

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

Microsoft.AspNetCore.Components.Forms (1)

FieldIdentifier.cs (1)

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

Microsoft.AspNetCore.Components.Forms.Tests (2)

EditContextTest.cs (1)

350return StringComparer.Ordinal.GetHashCode(Property);

FieldIdentifierTest.cs (1)

301return StringComparer.Ordinal.GetHashCode(Property);

Microsoft.AspNetCore.Components.Server (3)

ProtectedBrowserStorage\ProtectedBrowserStorage.cs (1)

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

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

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

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

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

Microsoft.AspNetCore.Components.Server.Tests (1)

Circuits\CircuitIdFactoryTest.cs (1)

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

Microsoft.AspNetCore.Components.Tests (10)

Rendering\RenderTreeBuilderTest.cs (10)

Microsoft.AspNetCore.Components.Web (5)

HtmlRendering\StaticHtmlRenderer.HtmlWriting.cs (1)

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

JSComponents\JSComponentConfigurationStore.cs (3)

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

JSComponents\JSComponentInterop.cs (1)

202ParameterInfoByName = new(StringComparer.OrdinalIgnoreCase);

Microsoft.AspNetCore.Components.WebAssembly (4)

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

Http\WebAssemblyHttpRequestMessageExtensions.cs (1)

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

Prerendering\WebAssemblyComponentParameterDeserializer.cs (1)

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

Microsoft.AspNetCore.Components.WebView (4)

FileExtensionContentTypeProvider.cs (1)

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

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

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

Microsoft.AspNetCore.Components.WebView.Test (3)

Infrastructure\ElementNode.cs (3)

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

Microsoft.AspNetCore.Cors (2)

Infrastructure\CorsOptions.cs (1)

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

Infrastructure\CorsPolicy.cs (1)

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

Microsoft.AspNetCore.DataProtection (1)

XmlEncryption\XmlKeyDecryptionOptions.cs (1)

16private readonly Dictionary<string, List<X509Certificate2>> _certs = new Dictionary<string, List<X509Certificate2>>(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 (7)

Logging\HttpLoggingRedactionInterceptor.cs (1)

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

Logging\IncomingHttpRouteUtility.cs (1)

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

Logging\LoggingRedactionOptions.cs (4)

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

Logging\RequestHeadersLogEnricherOptions.cs (1)

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

Microsoft.AspNetCore.Diagnostics.Middleware.Tests (4)

Logging\IncomingHttpRouteUtilityTests.cs (4)

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

Microsoft.AspNetCore.Grpc.JsonTranscoding (4)

Internal\GrpcProtocolConstants.cs (1)

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

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

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

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

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

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

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

Microsoft.AspNetCore.Grpc.JsonTranscoding.Tests (3)

ConverterTests\JsonElementComparer.cs (3)

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

Microsoft.AspNetCore.Grpc.Swagger (1)

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

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

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

Internal\HostingMetrics.cs (1)

131}, StringComparer.OrdinalIgnoreCase);

Internal\WebHostOptions.cs (1)

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

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

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

WebHostBuilder.cs (1)

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

Microsoft.AspNetCore.Hosting.Tests (8)

StaticWebAssets\ManifestStaticWebAssetsFileProviderTests.cs (8)

17var comparer = ManifestStaticWebAssetFileProvider.StaticWebAssetManifest.PathComparer; 103var comparer = ManifestStaticWebAssetFileProvider.StaticWebAssetManifest.PathComparer; 180var comparer = ManifestStaticWebAssetFileProvider.StaticWebAssetManifest.PathComparer; 256var comparer = ManifestStaticWebAssetFileProvider.StaticWebAssetManifest.PathComparer; 365var comparer = ManifestStaticWebAssetFileProvider.StaticWebAssetManifest.PathComparer; 506var comparer = ManifestStaticWebAssetFileProvider.StaticWebAssetManifest.PathComparer; 556var comparer = ManifestStaticWebAssetFileProvider.StaticWebAssetManifest.PathComparer; 613var comparer = ManifestStaticWebAssetFileProvider.StaticWebAssetManifest.PathComparer;

Microsoft.AspNetCore.Http (10)

Builder\ApplicationBuilder.cs (2)

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

Features\QueryFeature.cs (3)

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

HeaderDictionary.cs (1)

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

Internal\RequestCookieCollection.cs (2)

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

QueryCollection.cs (1)

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

Timeouts\RequestTimeoutOptions.cs (1)

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

Microsoft.AspNetCore.Http.Abstractions (16)

HostString.cs (1)

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

HttpMethods.cs (1)

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

HttpProtocol.cs (5)

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

PathString.cs (1)

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

ProblemDetails\HttpValidationProblemDetails.cs (2)

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

ProblemDetails\ProblemDetails.cs (1)

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

Routing\RouteValueDictionary.cs (3)

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

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

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

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

RouteValueDictionaryTests.cs (1)

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

Microsoft.AspNetCore.Http.Connections (2)

Internal\HttpConnectionDispatcher.cs (1)

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

Internal\HttpConnectionManager.cs (1)

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

Microsoft.AspNetCore.Http.Connections.Client (1)

HttpConnection.cs (1)

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

Microsoft.AspNetCore.Http.Extensions (4)

RequestDelegateFactory.cs (2)

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

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

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

src\Shared\ParameterBindingMethodCache.cs (1)

720return StringComparer.OrdinalIgnoreCase.GetHashCode(Name);

Microsoft.AspNetCore.Http.Microbenchmarks (7)

AdaptiveCapacityDictionaryBenchmark.cs (6)

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

ValidatableTypesBenchmark.cs (1)

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

Microsoft.AspNetCore.Http.RequestDelegateGenerator (3)

RequestDelegateGeneratorSources.cs (1)

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

StaticRouteHandlerModel\EndpointHttpMethodComparer.cs (1)

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

StaticRouteHandlerModel\Model\ParameterLookupKey.cs (1)

23return StringComparer.OrdinalIgnoreCase.GetHashCode(Name);

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

HttpLoggingOptions.cs (2)

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

W3CLoggerOptions.cs (2)

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

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

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

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

Microsoft.AspNetCore.JsonPatch.SystemTextJson (1)

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

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

Microsoft.AspNetCore.JsonPatch.SystemTextJson.Tests (8)

Internal\DictionaryAdapterTest.cs (8)

Microsoft.AspNetCore.JsonPatch.Tests (8)

Internal\DictionaryAdapterTest.cs (8)

Microsoft.AspNetCore.Mvc.Abstractions (5)

Abstractions\ActionDescriptor.cs (1)

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

ModelBinding\CompositeBindingSource.cs (1)

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

ModelBinding\Metadata\ModelMetadataIdentity.cs (1)

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

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

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

src\Shared\ParameterBindingMethodCache.cs (1)

720return StringComparer.OrdinalIgnoreCase.GetHashCode(Name);

Microsoft.AspNetCore.Mvc.ApiExplorer (1)

DefaultApiDescriptionProvider.cs (1)

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

Microsoft.AspNetCore.Mvc.Core (38)

ApplicationModels\ActionModel.cs (2)

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

ApplicationModels\ApplicationModelFactory.cs (3)

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

ApplicationModels\AttributeRouteModel.cs (1)

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

ApplicationModels\ControllerActionDescriptorProvider.cs (1)

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

ApplicationModels\ControllerModel.cs (2)

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

ApplicationModels\DefaultApplicationModelProvider.cs (1)

668.Distinct(StringComparer.OrdinalIgnoreCase)

ApplicationParts\ApplicationPartManager.cs (2)

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

BindAttribute.cs (2)

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

Formatters\FormatterMappings.cs (1)

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

Infrastructure\ActionSelectionTable.cs (1)

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

Infrastructure\ControllerActionInvoker.cs (1)

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

Infrastructure\StringArrayComparer.cs (4)

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

ModelBinding\Binders\DictionaryModelBinder.cs (1)

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

ModelBinding\CompositeValueProvider.cs (1)

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

ModelBinding\FormValueProvider.cs (1)

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

ModelBinding\JQueryFormValueProvider.cs (1)

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

ModelBinding\JQueryKeyValuePairNormalizer.cs (1)

22StringComparer.OrdinalIgnoreCase);

ModelBinding\PrefixContainer.cs (2)

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

MvcOptions.cs (1)

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

Routing\AttributeRoute.cs (2)

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

Routing\ControllerActionEndpointDataSource.cs (2)

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

Routing\KnownRouteValueConstraint.cs (1)

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

SerializableError.cs (1)

20: base(StringComparer.OrdinalIgnoreCase)

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

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

ValidationProblemDetails.cs (1)

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

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

ApplicationModels\AttributeRouteModelTests.cs (30)

ApplicationModels\ControllerActionDescriptorProviderTests.cs (13)

ApplicationModels\DefaultApplicationModelProviderTest.cs (3)

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

Controllers\ControllerBinderDelegateProviderTest.cs (22)

Formatters\JsonOutputFormatterTestBase.cs (1)

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

Infrastructure\ActionSelectionTableTest.cs (25)

Infrastructure\ActionSelectorTest.cs (20)

ModelBinding\Binders\DateTimeModelBinderTest.cs (2)

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

ModelBinding\Binders\DictionaryModelBinderTest.cs (4)

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

ModelBinding\Binders\FloatingPointTypeModelBinderTestOfT.cs (5)

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

ModelBinding\Binders\SimpleTypeModelBinderTest.cs (2)

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

ModelBinding\Binders\TryParseTypeModelBinderTest.cs (4)

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

ModelBinding\CompositeValueProviderTest.cs (2)

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

ModelBinding\ModelBinderFactoryTest.cs (1)

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

ModelBinding\PrefixContainerTest.cs (3)

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

ResponseCacheAttributeTest.cs (2)

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

Routing\AttributeRouteTest.cs (10)

Routing\AttributeRoutingTest.cs (2)

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

Routing\ControllerActionEndpointDataSourceTest.cs (13)

Routing\DynamicControllerEndpointMatcherPolicyTest.cs (3)

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

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.IntegrationTests (16)

BodyValidationIntegrationTests.cs (2)

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

ComplexRecordIntegrationTest.cs (5)

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

ComplexTypeIntegrationTestBase.cs (5)

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

SimpleTypeModelBinderIntegrationTest.cs (2)

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

TryValidateModelIntegrationTest.cs (2)

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

Microsoft.AspNetCore.Mvc.NewtonsoftJson (6)

AnnotatedProblemDetails.cs (1)

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

BsonTempDataSerializer.cs (3)

53return new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase); 59StringComparer.OrdinalIgnoreCase); 229var convertedDictionary = new Dictionary<string, TVal?>(StringComparer.Ordinal);

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

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

ValidationProblemDetailsConverter.cs (1)

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

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

NewtonsoftJsonOutputFormatterTest.cs (1)

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

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

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

Microsoft.AspNetCore.Mvc.Razor (17)

ApplicationParts\RazorCompiledItemFeatureProvider.cs (2)

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

Compilation\DefaultViewCompiler.cs (2)

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

RazorPage.cs (4)

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

RazorPageBase.cs (1)

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

RazorViewEngine.cs (1)

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

TagHelpers\UrlResolutionTagHelper.cs (1)

58new(StringComparer.OrdinalIgnoreCase)

ViewLocationCacheKey.cs (6)

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

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

CompilationFailedExceptionFactory.cs (2)

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

RuntimeViewCompiler.cs (2)

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

Microsoft.AspNetCore.Mvc.Razor.Test (36)

RazorPageTest.cs (18)

RazorViewEngineOptionsTest.cs (2)

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

TagHelpers\TagHelperComponentTagHelperTest.cs (2)

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

TagHelpers\UrlResolutionTagHelperTest.cs (14)

Microsoft.AspNetCore.Mvc.RazorPages (7)

ApplicationModels\CompiledPageRouteModelProvider.cs (1)

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

ApplicationModels\PageRouteModel.cs (2)

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

Infrastructure\CompiledPageActionDescriptorProvider.cs (1)

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

Infrastructure\DefaultPageLoader.cs (1)

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

Infrastructure\PageActionEndpointDataSource.cs (1)

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

Infrastructure\PageActionInvoker.cs (1)

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

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

AnchorTagHelper.cs (1)

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

Cache\CacheTagKey.cs (4)

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

ComponentTagHelper.cs (1)

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

FormActionTagHelper.cs (1)

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

FormTagHelper.cs (1)

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

InputTagHelper.cs (5)

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

JavaScriptResources.cs (1)

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

OptionTagHelper.cs (1)

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

SelectTagHelper.cs (1)

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

TagHelperOutputExtensions.cs (1)

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

TextAreaTagHelper.cs (1)

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

ValidationMessageTagHelper.cs (1)

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

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

FormActionTagHelperTest.cs (15)

GlobbingUrlBuilderTest.cs (1)

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

ImageTagHelperTest.cs (1)

78StringComparer.Ordinal);

LinkTagHelperTest.cs (1)

76StringComparer.Ordinal);

ScriptTagHelperTest.cs (1)

75StringComparer.Ordinal);

SelectTagHelperTest.cs (1)

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

TagHelperOutputExtensionsTest.cs (7)

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

TestableHtmlGenerator.cs (1)

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

Microsoft.AspNetCore.Mvc.Testing (1)

WebApplicationFactory.cs (1)

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

Microsoft.AspNetCore.Mvc.ViewFeatures (23)

AttributeDictionary.cs (1)

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

CookieTempDataProvider.cs (1)

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

DefaultEditorTemplates.cs (1)

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

DefaultHtmlGenerator.cs (1)

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

FormContext.cs (3)

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

HtmlHelper.cs (2)

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

Infrastructure\DefaultTempDataSerializer.cs (2)

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

LambdaExpressionComparer.cs (1)

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

Rendering\MultiSelectList.cs (1)

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

SessionStateTempDataProvider.cs (1)

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

TempDataDictionary.cs (4)

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

TemplateRenderer.cs (2)

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

ViewComponents\DefaultViewComponentHelper.cs (1)

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

ViewDataDictionary.cs (2)

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

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

CookieTempDataProviderTest.cs (1)

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

DefaultValidationHtmlAttributeProviderTest.cs (7)

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

ExpressionHelperTest.cs (2)

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

Rendering\HtmlHelperSelectTest.cs (2)

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

ViewComponents\DefaultViewComponentSelectorTest.cs (1)

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

Microsoft.AspNetCore.Mvc.Views.TestCommon (2)

TestFileProvider.cs (2)

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

Microsoft.AspNetCore.OpenApi (3)

Services\OpenApiDocumentService.cs (2)

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

src\Shared\ParameterBindingMethodCache.cs (1)

720return StringComparer.OrdinalIgnoreCase.GetHashCode(Name);

Microsoft.AspNetCore.OutputCaching (11)

OutputCacheEntryFormatter.cs (2)

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

OutputCacheKeyProvider.cs (7)

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

OutputCacheOptions.cs (2)

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

Microsoft.AspNetCore.Owin (3)

OwinEnvironment.cs (3)

558_deletedKeys ??= new HashSet<string>(StringComparer.Ordinal); 609_contextEntries = new Dictionary<string, FeatureMap>(StringComparer.Ordinal); 613_contextEntries = new Dictionary<string, FeatureMap>(_entries, StringComparer.Ordinal);

Microsoft.AspNetCore.RateLimiting (2)

RateLimiterOptions.cs (2)

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

Microsoft.AspNetCore.Razor (1)

TagHelpers\TagHelperAttribute.cs (1)

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

Microsoft.AspNetCore.Razor.Runtime.Test (9)

Runtime\TagHelpers\TagHelperScopeManagerTest.cs (9)

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

Microsoft.AspNetCore.Razor.Test (5)

TagHelpers\TagHelperContextTest.cs (2)

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

TagHelpers\TagHelperOutputTest.cs (3)

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

Microsoft.AspNetCore.RequestDecompression (1)

RequestDecompressionOptions.cs (1)

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

Microsoft.AspNetCore.ResponseCaching (7)

ResponseCachingKeyProvider.cs (6)

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

ResponseCachingMiddleware.cs (1)

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

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

Constraints\HttpMethodRouteConstraint.cs (2)

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

DecisionTree\DecisionTreeBuilder.cs (3)

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

DefaultLinkParser.cs (1)

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

EndpointNameAddressScheme.cs (2)

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

Matching\AcceptsMatcherPolicy.cs (1)

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

Matching\ContentEncodingNegotiationMatcherPolicy.cs (1)

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

Matching\DfaMatcherBuilder.cs (2)

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

Matching\DfaNode.cs (1)

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

Matching\DictionaryJumpTable.cs (1)

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

Matching\HttpMethodDestinationsLookup.cs (1)

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

Matching\HttpMethodMatcherPolicy.cs (4)

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

Matching\NegotiationMatcherPolicy.cs (1)

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

Patterns\RoutePatternFactory.cs (6)

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

Patterns\RoutePatternParser.cs (1)

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

RouteCollection.cs (1)

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

RouteConstraintBuilder.cs (3)

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.Core.Tests (2)

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

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

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

AdaptiveCapacityDictionaryTests.cs (18)

CopyOnWriteDictionaryHolderTest.cs (3)

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

CopyOnWriteDictionaryTest.cs (3)

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

PropertyHelperTest.cs (8)

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

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

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

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

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

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.Client.Core (2)

HubConnection.cs (2)

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

Microsoft.AspNetCore.SignalR.Core (7)

HubConnectionContext.cs (1)

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

HubConnectionStore.cs (1)

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

Internal\DefaultHubDispatcher.cs (1)

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

Internal\DefaultHubProtocolResolver.cs (2)

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

Internal\HubGroupList.cs (1)

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

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

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

Microsoft.AspNetCore.SignalR.Protocols.Json (1)

Protocol\JsonHubProtocol.cs (1)

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

Microsoft.AspNetCore.SignalR.Protocols.MessagePack (1)

Protocol\MessagePackHubProtocolWorker.cs (1)

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

Microsoft.AspNetCore.SignalR.Protocols.NewtonsoftJson (1)

Protocol\NewtonsoftJsonHubProtocol.cs (1)

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

Microsoft.AspNetCore.SignalR.StackExchangeRedis (2)

Internal\RedisSubscriptionManager.cs (1)

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

RedisHubLifetimeManager.cs (1)

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

Microsoft.AspNetCore.SignalR.Tests.Utils (1)

ServerLogScope.cs (1)

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

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.StaticFiles.Tests (1)

StaticFileContextTest.cs (1)

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

Microsoft.AspNetCore.WebSockets (2)

WebSocketMiddleware.cs (2)

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

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

BinaryTranslator.cs (2)

770public void TranslateDictionary(ref Dictionary<string, DateTime> dictionary, StringComparer comparer) 1572public void TranslateDictionary(ref Dictionary<string, DateTime> dictionary, StringComparer comparer)

BuildException\BuildExceptionBase.cs (1)

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

ImmutableFilesTimestampCache.cs (1)

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

ITranslator.cs (1)

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

ProjectStartedEventArgs.cs (1)

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

Sdk\SdkResultItem.cs (4)

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

XamlTypes\ContentType.cs (1)

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

XamlTypes\Rule.cs (2)

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

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

CaseInsensitiveComparison.cs (1)

283public static StringComparer Comparer => s_comparer;

Collections\IdentifierCollection.cs (1)

28StringComparer.OrdinalIgnoreCase);

CommandLine\AnalyzerConfig.cs (2)

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

CommandLine\AnalyzerConfigSet.cs (2)

333var comparer = StringComparer.OrdinalIgnoreCase;

CommandLine\SarifErrorLogger.cs (1)

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

Compilation\Compilation.cs (1)

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

Compilation\CompilationOptions.cs (5)

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

Compilation\DeterministicKeyBuilder.cs (2)

464foreach (var key in options.SpecificDiagnosticOptions.Keys.OrderBy(StringComparer.Ordinal)) 527foreach (var key in features.Keys.OrderBy(StringComparer.Ordinal))

Compilation\ParseOptions.cs (2)

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

DiagnosticAnalyzer\AnalyzerAssemblyLoader.cs (6)

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

DiagnosticAnalyzer\AnalyzerConfigOptions.cs (1)

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

DiagnosticAnalyzer\AnalyzerExecutor.cs (1)

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

DiagnosticAnalyzer\AnalyzerFileReference.cs (3)

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

DiagnosticAnalyzer\SuppressMessageAttributeState.cs (1)

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

Emit\AnonymousTypeKey.cs (4)

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

Emit\CommonPEModuleBuilder.cs (1)

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

Emit\DebugDocumentsBuilder.cs (2)

30StringComparer.Ordinal : 31StringComparer.OrdinalIgnoreCase);

FileKey.cs (1)

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

FileSystem\PathUtilities.cs (3)

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

InternalUtilities\Hash.cs (2)

MetadataReader\MetadataHelpers.cs (1)

778StringComparer nameComparer,

MetadataReader\PEAssembly.cs (1)

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

MetadataReader\PEModule.cs (4)

667internal IEnumerable<IGrouping<string, TypeDefinitionHandle>> GroupTypesByNamespaceOrThrow(StringComparer nameComparer) 696private readonly StringComparer _nameComparer; 698public TypesByNamespaceSortComparer(StringComparer nameComparer) 3808var caseInsensitiveMap = new Dictionary<string, (string OriginalName, int FirstIndex, int SecondIndex)>(StringComparer.OrdinalIgnoreCase);

MetadataReference\AssemblyIdentityComparer.cs (4)

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

PEWriter\MetadataWriter.PortablePdb.cs (1)

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

ReferenceManager\CommonReferenceManager.State.cs (1)

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

RuleSet\RuleSet.cs (1)

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

SourceFileResolver.cs (3)

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

SourceGeneration\AdditionalSourcesCollection.cs (2)

23private static readonly StringComparer s_hintNameComparer = StringComparer.OrdinalIgnoreCase;

StrongName\DesktopStrongNameProvider.cs (2)

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

StrongName\StrongNameFileSystem.cs (2)

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

XmlFileResolver.cs (1)

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

Microsoft.CodeAnalysis.Analyzers (37)

MetaAnalyzers\DiagnosticDescriptorCreationAnalyzer.cs (1)

62StringComparer.Ordinal,

MetaAnalyzers\DiagnosticDescriptorCreationAnalyzer_IdRangeAndCategoryValidation.cs (2)

213StringComparer comparer = StringComparer.Ordinal;

MetaAnalyzers\DiagnosticDescriptorCreationAnalyzer_ReleaseTracking.cs (2)

252StringComparer comparer = StringComparer.OrdinalIgnoreCase;

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

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

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

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

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

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

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

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

55return StringComparer.Ordinal.Compare(

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

32_fullNameToTypeMap = new ConcurrentDictionary<string, INamedTypeSymbol?>(StringComparer.Ordinal); 82new(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 (3)

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

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

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

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

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

88StringComparer StringComparer { get; }

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

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

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

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

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

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

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

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

Microsoft.CodeAnalysis.AnalyzerUtilities (41)

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

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

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

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

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

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

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

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

55return StringComparer.Ordinal.Compare(

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

88StringComparer StringComparer { get; }

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

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

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

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

Microsoft.CodeAnalysis.BannedApiAnalyzers (35)

RestrictedInternalsVisibleToAnalyzer.cs (3)

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

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

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

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

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

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

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

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

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

55return StringComparer.Ordinal.Compare(

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

32_fullNameToTypeMap = new ConcurrentDictionary<string, INamedTypeSymbol?>(StringComparer.Ordinal); 82new(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 (3)

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

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

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

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

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

88StringComparer StringComparer { get; }

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

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

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

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

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

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

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

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

Microsoft.CodeAnalysis.CodeStyle (28)

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

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

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

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

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

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

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

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

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

88StringComparer StringComparer { get; }

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

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

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

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

Microsoft.CodeAnalysis.CodeStyle.Fixes (11)

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

200var comparer = syntaxFacts.StringComparer; 435StringComparer comparer,

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

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

src\Analyzers\Core\CodeFixes\GenerateConstructor\AbstractGenerateConstructorService.cs (1)

183var comparer = syntaxFacts.StringComparer;

src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateParameterizedMemberService.SignatureInfo.cs (1)

125var equalityComparer = syntaxFacts.StringComparer;

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

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

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

251var comparer = syntaxFacts.StringComparer;

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

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

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

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

Microsoft.CodeAnalysis.CSharp (17)

Binder\ImportChain.cs (1)

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

Binder\LookupSymbolsInfo.cs (1)

21: base(StringComparer.Ordinal)

CommandLine\CSharpCompiler.cs (1)

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

Compilation\CSharpDeterministicKeyBuilder.cs (1)

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

CSharpCompilationOptions.cs (2)

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

CSharpParseOptions.cs (1)

166features?.ToImmutableDictionary(StringComparer.OrdinalIgnoreCase)

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (1)

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

SymbolDisplay\SymbolDisplayVisitor.cs (1)

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

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

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

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

230StringComparer.Ordinal,

Symbols\MissingModuleSymbol.cs (1)

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

Symbols\Source\QuickAttributeChecker.cs (2)

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

Symbols\Source\SourceAssemblySymbol.cs (2)

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

Symbols\Source\SourceNamedTypeSymbol_Extension.cs (1)

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

Microsoft.CodeAnalysis.CSharp.CodeStyle (3)

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

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

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

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

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.Emit3.UnitTests (1)

Diagnostics\GetDiagnosticsTests.cs (1)

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

Microsoft.CodeAnalysis.CSharp.Features (4)

Diagnostics\Analyzers\TypeSyntaxSimplifierWalker.cs (1)

24StringComparer.Ordinal,

EncapsulateField\CSharpEncapsulateFieldService.cs (1)

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

QuickInfo\CSharpDiagnosticAnalyzerQuickInfoProviderExtensions.cs (2)

33var stringComparer = StringComparer.Ordinal;

Microsoft.CodeAnalysis.CSharp.Scripting (2)

CSharpScriptCompiler.cs (2)

26public override StringComparer IdentifierComparer => StringComparer.Ordinal;

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

SourceGeneration\AdditionalSourcesCollectionTests.cs (1)

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

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

Compilation\CompilationAPITests.cs (3)

205StringComparer.Ordinal, 501Assert.Equal("mscorlib", assemblySmb.Name, StringComparer.OrdinalIgnoreCase); 1198Assert.Equal("Test1", smb.Identity.Name, StringComparer.OrdinalIgnoreCase);

Compilation\SemanticModelGetSemanticInfoTests.cs (140)

Symbols\AssemblyAndNamespaceTests.cs (2)

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

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

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

Symbols\RequiredMembersTests.cs (1)

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

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.CSharp.WinRT.UnitTests (1)

Metadata\WinMdDumpTest.cs (1)

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

Microsoft.CodeAnalysis.CSharp.Workspaces (5)

Rename\LabelConflictVisitor.cs (1)

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

Rename\LocalConflictVisitor.cs (1)

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

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

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

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

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

Microsoft.CodeAnalysis.EditorFeatures (18)

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

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

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

NavigateTo\NavigateToItemProvider.cs (1)

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

SignatureHelp\Controller.Session_UpdateModel.cs (6)

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

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

Completion\AbstractCompletionProviderTests.cs (1)

428=> StringComparer.Ordinal;

Microsoft.CodeAnalysis.EditorFeatures.UnitTests (6)

Utilities\BloomFilterTests.cs (6)

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

MetadataResolver.cs (6)

27private readonly StringComparer _stringComparer; // for comparing strings 39_stringComparer = ignoreCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal; 282var comparer = _ignoreCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;

VisualBasic\Keywords.cs (1)

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

VisualBasic\MemberSignatureParser.cs (2)

16internal static readonly StringComparer StringComparer = StringComparer.OrdinalIgnoreCase;

VisualBasic\SyntaxKind.cs (1)

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

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

VisualBasicParsingTests.cs (1)

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

Microsoft.CodeAnalysis.ExpressionEvaluator.ResultProvider (1)

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

283public static StringComparer Comparer => s_comparer;

Microsoft.CodeAnalysis.Extensions.Package (5)

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

Symbols\INamedTypeSymbolExtensions.cs (3)

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

AddImport\AbstractAddImportFeatureService.cs (2)

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

AddImport\References\MetadataSymbolReference.cs (2)

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

AddImport\References\Reference.cs (1)

43diff = StringComparer.OrdinalIgnoreCase.Compare(

AddImport\References\SymbolReference.cs (1)

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

AddImport\SymbolResult.cs (1)

44return StringComparer.OrdinalIgnoreCase.Equals(

CodeLens\LocationComparer.cs (1)

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

CodeRefactorings\CodeRefactoringService.cs (2)

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

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

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

Completion\CompletionItem.cs (2)

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

Completion\FileSystemCompletionHelper.cs (2)

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

Completion\Providers\AbstractInternalsVisibleToCompletionProvider.cs (1)

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

ConvertTupleToStruct\AbstractConvertTupleToStructCodeRefactoringProvider.cs (4)

640var comparer = syntaxFacts.StringComparer; 666private static bool AreEquivalent(StringComparer comparer, INamedTypeSymbol tupleType, INamedTypeSymbol childType) 671StringComparer comparer, ImmutableArray<IFieldSymbol> fields1, ImmutableArray<IFieldSymbol> fields2) 753var comparer = document.GetRequiredLanguageService<ISyntaxFactsService>().StringComparer;

EditAndContinue\ActiveStatementsMap.cs (1)

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

EditAndContinue\EditAndContinueMethodDebugInfoReader.cs (1)

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

EmbeddedLanguages\AbstractEmbeddedLanguageFeatureService.cs (4)

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

EmbeddedLanguages\EmbeddedLanguageCommentOptions.cs (1)

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

EmbeddedLanguages\EmbeddedLanguageDetector.cs (1)

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

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

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

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

172var comparer = syntaxFacts.StringComparer; 180StringComparer comparer,

InheritanceMargin\AbstractInheritanceMarginService_Helpers.cs (1)

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

MetadataAsSource\DecompilationMetadataAsSourceFileProvider.cs (3)

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

NavigateTo\NavigateToUtilities.cs (1)

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

PdbSourceDocument\ImplementationAssemblyLookupService.cs (1)

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

PdbSourceDocument\PdbSourceDocumentMetadataAsSourceFileProvider.cs (1)

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

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

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

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

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

200var comparer = syntaxFacts.StringComparer; 435StringComparer comparer,

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

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

src\Analyzers\Core\CodeFixes\GenerateConstructor\AbstractGenerateConstructorService.cs (1)

183var comparer = syntaxFacts.StringComparer;

src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateParameterizedMemberService.SignatureInfo.cs (1)

125var equalityComparer = syntaxFacts.StringComparer;

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

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

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

251var comparer = syntaxFacts.StringComparer;

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

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

Microsoft.CodeAnalysis.InteractiveHost (6)

Interactive\Core\InteractiveHostPlatformInfo.cs (1)

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

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

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

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

Microsoft.CodeAnalysis.LanguageServer (12)

HostWorkspace\FileWatching\LspFileChangeWatcher.cs (3)

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

HostWorkspace\LoadedProject.cs (2)

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

HostWorkspace\ProjectDependencyHelper.cs (2)

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

HostWorkspace\ProjectToLoad.cs (2)

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

Logging\LspLogMessageLoggerProvider.cs (1)

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

Services\ExtensionAssemblyManager.cs (2)

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

Microsoft.CodeAnalysis.LanguageServer.Protocol (9)

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

Protocol\Internal\VSInternalIconMapping.cs (1)

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

Protocol\Internal\VSInternalKindAndModifier.cs (2)

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

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

58var comparer = StringComparer.Ordinal;

Microsoft.CodeAnalysis.PerformanceSensitiveAnalyzers (32)

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

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

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

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

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

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

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

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

55return StringComparer.Ordinal.Compare(

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

32_fullNameToTypeMap = new ConcurrentDictionary<string, INamedTypeSymbol?>(StringComparer.Ordinal); 82new(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 (3)

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

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

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

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

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

88StringComparer StringComparer { get; }

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

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

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

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

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

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

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

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

Microsoft.CodeAnalysis.PublicApiAnalyzers (32)

DeclarePublicApiAnalyzer.cs (1)

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

DeclarePublicApiAnalyzer.Impl.cs (2)

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

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

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

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

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

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

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

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

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

55return StringComparer.Ordinal.Compare(

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

32_fullNameToTypeMap = new ConcurrentDictionary<string, INamedTypeSymbol?>(StringComparer.Ordinal); 82new(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 (3)

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

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

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

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

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

88StringComparer StringComparer { get; }

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

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

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

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

Microsoft.CodeAnalysis.PublicApiAnalyzers.CodeFixes (2)

DeclarePublicApiFix.cs (2)

410var result = StringComparer.OrdinalIgnoreCase.Compare(x, y); 412result = StringComparer.Ordinal.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.Remote.Workspaces (1)

ExportProviderBuilder.cs (1)

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

Microsoft.CodeAnalysis.ResxSourceGenerator (30)

AbstractResxGenerator.cs (1)

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

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

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

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

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

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

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

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

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

55return StringComparer.Ordinal.Compare(

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

32_fullNameToTypeMap = new ConcurrentDictionary<string, INamedTypeSymbol?>(StringComparer.Ordinal); 82new(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 (3)

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

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

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

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

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

88StringComparer StringComparer { get; }

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

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

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

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

Microsoft.CodeAnalysis.Scripting (8)

Hosting\AssemblyLoader\MetadataShadowCopyProvider.cs (1)

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

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

344int comparisonResult = StringComparer.OrdinalIgnoreCase.Compare(x.Name, y.Name); 347comparisonResult = StringComparer.Ordinal.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);

ScriptCompiler.cs (1)

17public abstract StringComparer IdentifierComparer { get; }

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

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

Microsoft.CodeAnalysis.Test.Utilities (10)

CompilationVerifier.cs (2)

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

Mocks\VirtualizedRelativePathResolver.cs (1)

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

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

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

TestableFileSystem.cs (2)

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

Microsoft.CodeAnalysis.UnitTests (100)

AssemblyUtilitiesTests.cs (3)

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

CachingLookupTests.cs (10)

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

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

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

Collections\ImmutableDictionaryBuilderTestBase.nonnetstandard.cs (1)

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

Collections\ImmutableDictionaryTestBase.cs (2)

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

Collections\ImmutableSegmentedDictionaryBuilderTest.cs (12)

Collections\ImmutableSegmentedDictionaryTest.cs (28)

Collections\ImmutableSegmentedHashSetBuilderTest.cs (10)

Collections\ImmutableSegmentedHashSetTest.cs (7)

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

Collections\ImmutableSegmentedHashSetTest.nonnetstandard.cs (3)

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

Collections\ImmutableSegmentedListTest.cs (4)

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

FileUtilitiesTests.cs (1)

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

MetadataReferences\AssemblyIdentityDisplayNameTests.cs (1)

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

MetadataReferences\MetadataHelpersTests.cs (5)

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

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

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

FindSymbols\FindReferences\DependentProjectsFinder.cs (1)

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

FindSymbols\FindReferences\FindReferenceCache.cs (2)

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

FindSymbols\ReferenceLocation.cs (1)

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

FindSymbols\SearchQuery.cs (1)

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

FindSymbols\SymbolTree\SymbolTreeInfo.cs (5)

31private static readonly StringComparer s_caseInsensitiveComparer = 204if (StringComparer.Ordinal.Equals(name, node.Name)) 232if (ignoreCase || StringComparer.Ordinal.Equals(name, node.Name)) 388: StringComparer.Ordinal.Compare(s1, s2); 489if (StringComparer.Ordinal.Equals(derivedName, node.Name))

FindSymbols\SymbolTree\SymbolTreeInfo_Source.cs (1)

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

FindSymbols\SyntaxTree\SyntaxTreeIndex_Create.cs (8)

Recommendations\AbstractRecommendationServiceRunner.cs (1)

27private readonly StringComparer _stringComparerForLanguage;

Shared\Extensions\IFindReferencesResultExtensions.cs (3)

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

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

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

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

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

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

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

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

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

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

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

88StringComparer StringComparer { get; }

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

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

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

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

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

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

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

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

Workspace\Host\Mef\ExportDynamicFileInfoProviderAttribute.cs (1)

23/// match will be done by <see cref="StringComparer.OrdinalIgnoreCase"/>

Workspace\ProjectSystem\ProjectSystemProject.BatchingDocumentCollection.cs (1)

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

Workspace\ProjectSystem\ProjectSystemProject.cs (2)

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

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

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

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

32private static readonly StringComparer s_comparer = StringComparer.OrdinalIgnoreCase;

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

MSBuild\ProjectFile\CommandLineArgumentReader.cs (1)

157private static readonly ImmutableDictionary<string, string> s_debugTypeValues = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)

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

283public static StringComparer Comparer => s_comparer;

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

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

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

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

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

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

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

FileSet.cs (1)

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

SolutionGeneration.cs (1)

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

VisualStudioMSBuildWorkspaceTests.cs (1)

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

Microsoft.CodeAnalysis.Workspaces.UnitTests (7)

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

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

Microsoft.CommonLanguageServerProtocol.Framework.Package (2)

TypeRef.cs (2)

58var comparer = StringComparer.Ordinal;

Microsoft.Data.Analysis (1)

DataFrameColumnCollection.cs (1)

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

Microsoft.DotNet.Arcade.Sdk (1)

src\InstallDotNetCore.cs (1)

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

Microsoft.DotNet.ArcadeLogging (3)

PipelinesLogger.cs (3)

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

GenerateNuSpec.cs (5)

266return manifestFiles.OrderBy(f => f.Target, StringComparer.OrdinalIgnoreCase).ToList(); 274orderby fr.ItemSpec, StringComparer.Ordinal 314orderby dependency.Id, StringComparer.Ordinal 326))).OrderBy(s => s?.TargetFramework?.GetShortFolderName(), StringComparer.Ordinal) 344orderby reference.File, StringComparer.Ordinal

HarvestPackage.cs (4)

274var livePackageFiles = new Dictionary<string, PackageItem>(StringComparer.OrdinalIgnoreCase); 510_pathsToExclude = new HashSet<string>(PathsToExclude.NullAsEmpty().Select(NormalizePath), StringComparer.OrdinalIgnoreCase); 522_pathsToInclude = PathsToInclude.NullAsEmpty().ToDictionary(i => NormalizePath(i.ItemSpec), i=> i, StringComparer.OrdinalIgnoreCase); 605return extension != null && extension.Length > 0 && s_includedExtensions.Contains(extension, StringComparer.OrdinalIgnoreCase);

PackageIndex.cs (1)

33public HashSet<string> IndexSources { get; set; } = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

UpdatePackageIndex.cs (1)

97_packageIdsToInclude = new HashSet<string>(PackageIds.Select(i => i.ItemSpec), StringComparer.OrdinalIgnoreCase);

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

Analyzers\AppContextDefaultsAnalyzer.cs (4)

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

Analyzers\BaseAnalyzer.cs (1)

29if (StringComparer.OrdinalIgnoreCase.Equals(line.ToString(), GetType().Name))

Analyzers\MembersMustExistAnalyzer.cs (1)

23private HashSet<string> _apisToEnsureExist = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

Analyzers\PinvokeAnalyzer.cs (2)

67private HashSet<string> _isNotSupportedOnWin7 = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 72Dictionary<string, string> parsedPinvokes = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

Microsoft.DotNet.GenFacades (2)

GenPartialFacadeSourceGenerator.cs (2)

40if (distinctSeeds.Count() != seedNames.Distinct(StringComparer.InvariantCultureIgnoreCase).Count()) 66var dictionary = new Dictionary<string, string>(StringComparer.Ordinal);

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

src\CreateFrameworkListFile.cs (3)

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

src\FileUtilities.cs (1)

18StringComparer.OrdinalIgnoreCase);

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

src\ValidateFileVersions.cs (1)

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

Microsoft.DotNet.SignTool (8)

src\Hash.cs (1)

119internal static int CombineValues(IEnumerable<string> values, StringComparer stringComparer, int maxItemsToHash = int.MaxValue)

src\SignToolConstants.cs (2)

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

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

src\UsageReport\WritePackageUsageData.cs (1)

196StringComparer.OrdinalIgnoreCase);

src\UsageReport\WriteUsageReports.cs (2)

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

src\UsageReport\XmlParsingHelpers.cs (2)

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

Microsoft.DotNet.SwaggerGenerator.CodeGenerator (1)

Languages\Language.cs (1)

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

Microsoft.DotNet.XliffTasks (5)

Model\XlfDocument.cs (3)

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

Tasks\EnsureAllResourcesTranslated.cs (1)

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

Tasks\GatherXlf.cs (1)

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

Microsoft.DotNet.XliffTasks.Tests (3)

XlfDocumentTests.cs (3)

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

Microsoft.DotNet.XUnitAssert.Tests (26)

AsyncCollectionAssertsTests.cs (2)

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

CollectionAssertsTests.cs (10)

DictionaryAssertsTests.cs (6)

18 var dictionary = new Dictionary<string, int>(StringComparer.InvariantCultureIgnoreCase) 28 Assert.Equal(42, Assert.Contains("FORTY-two", dictionary.ToImmutableDictionary(StringComparer.InvariantCultureIgnoreCase))); 29 Assert.Equal(42, Assert.Contains("FORTY-two", (IImmutableDictionary<string, int>)dictionary.ToImmutableDictionary(StringComparer.InvariantCultureIgnoreCase))); 88 var dictionary = new Dictionary<string, int>(StringComparer.InvariantCultureIgnoreCase) 111 assertFailure(() => Assert.DoesNotContain("FORTY-two", dictionary.ToImmutableDictionary(StringComparer.InvariantCultureIgnoreCase))); 112 assertFailure(() => Assert.DoesNotContain("FORTY-two", (IImmutableDictionary<string, int>)dictionary.ToImmutableDictionary(StringComparer.InvariantCultureIgnoreCase)));

SetAssertsTests.cs (8)

17 var set = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "forty-two" }; 21 Assert.Contains("FORTY-two", set.ToSortedSet(StringComparer.OrdinalIgnoreCase)); 26 Assert.Contains("FORTY-two", set.ToImmutableHashSet(StringComparer.OrdinalIgnoreCase)); 27 Assert.Contains("FORTY-two", set.ToImmutableSortedSet(StringComparer.OrdinalIgnoreCase)); 84 var set = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "forty-two" }; 101 assertFailure(() => Assert.DoesNotContain("FORTY-two", set.ToSortedSet(StringComparer.OrdinalIgnoreCase))); 106 assertFailure(() => Assert.DoesNotContain("FORTY-two", set.ToImmutableHashSet(StringComparer.OrdinalIgnoreCase))); 107 assertFailure(() => Assert.DoesNotContain("FORTY-two", set.ToImmutableSortedSet(StringComparer.OrdinalIgnoreCase)));

Microsoft.DotNet.XUnitExtensions.Tests (1)

AlphabeticalOrderer.cs (1)

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

Microsoft.Extensions.AI.Abstractions (16)

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

17var comparer = comparisonType switch 19StringComparison.CurrentCulture => StringComparer.CurrentCulture, 20StringComparison.CurrentCultureIgnoreCase => StringComparer.CurrentCultureIgnoreCase, 21StringComparison.InvariantCulture => StringComparer.InvariantCulture, 22StringComparison.InvariantCultureIgnoreCase => StringComparer.InvariantCultureIgnoreCase, 23StringComparison.Ordinal => StringComparer.Ordinal, 24StringComparison.OrdinalIgnoreCase => StringComparer.OrdinalIgnoreCase,

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

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

Utilities\AIJsonUtilities.cs (1)

178var entries = obj.OrderBy(e => e.Key, StringComparer.Ordinal).ToArray();

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

Functions\AIFunctionArgumentsTests.cs (12)

175var comparer = StringComparer.OrdinalIgnoreCase; 191var comparer = StringComparer.OrdinalIgnoreCase; 207var comparer = StringComparer.OrdinalIgnoreCase; 239var comparer = StringComparer.OrdinalIgnoreCase; 263var comparer = StringComparer.OrdinalIgnoreCase; 291var originalDict = new Dictionary<string, object?>(StringComparer.Ordinal) 298var args = new AIFunctionArguments(originalDict, StringComparer.OrdinalIgnoreCase);

Microsoft.Extensions.ApiDescription.Client.Tests (28)

GetCurrentOpenApiReferenceTest.cs (2)

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

GetOpenApiReferenceMetadataTest.cs (18)

MetadataSerializerTest.cs (8)

Microsoft.Extensions.Caching.Hybrid (1)

Internal\TagSet.cs (1)

41Array.Sort(tags, StringComparer.InvariantCulture);

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.KeyPerFile.Tests (63)

ConfigurationProviderTestBase.cs (63)

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.Embedded.Tests (1)

EmbeddedFileProviderTests.cs (1)

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

Microsoft.Extensions.FileProviders.Physical (3)

PhysicalFilesWatcher.cs (2)

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

PollingWildCardChangeToken.cs (1)

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

Microsoft.Extensions.FileSystemGlobbing (8)

FilePatternMatch.cs (1)

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

Util\StringComparisonHelper.cs (7)

10public static StringComparer GetStringComparer(StringComparison comparisonType) => comparisonType switch 12StringComparison.CurrentCulture => StringComparer.CurrentCulture, 13StringComparison.CurrentCultureIgnoreCase => StringComparer.CurrentCultureIgnoreCase, 14StringComparison.Ordinal => StringComparer.Ordinal, 15StringComparison.OrdinalIgnoreCase => StringComparer.OrdinalIgnoreCase, 16StringComparison.InvariantCulture => StringComparer.InvariantCulture, 17StringComparison.InvariantCultureIgnoreCase => StringComparer.InvariantCultureIgnoreCase,

Microsoft.Extensions.Http (2)

DefaultHttpClientFactory.cs (1)

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

DependencyInjection\HttpClientBuilderExtensions.cs (1)

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

Microsoft.Extensions.Http.Diagnostics (6)

Http\DownstreamDependencyMetadataManager.cs (1)

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

Logging\Internal\HttpHeadersReader.cs (2)

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

Logging\Internal\HttpRequestBodyReader.cs (1)

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

Logging\Internal\HttpRequestReader.cs (1)

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

Logging\Internal\HttpResponseBodyReader.cs (1)

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

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

Internal\HttpKey.cs (2)

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

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

LoggerFactory.cs (1)

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

Microsoft.Extensions.Logging.Console (1)

ConsoleLoggerProvider.cs (1)

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

Microsoft.Extensions.Logging.Generators (2)

LoggerMessageGenerator.Parser.cs (2)

645HashSet<string> shadowedNames = new(StringComparer.Ordinal); 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.Options (1)

OptionsCache.cs (1)

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

Microsoft.Extensions.Options.SourceGeneration (1)

Emitter.cs (1)

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

Microsoft.Extensions.Primitives (4)

StringSegmentComparer.cs (4)

18= new StringSegmentComparer(StringComparison.Ordinal, StringComparer.Ordinal); 24= new StringSegmentComparer(StringComparison.OrdinalIgnoreCase, StringComparer.OrdinalIgnoreCase); 26private StringSegmentComparer(StringComparison comparison, StringComparer comparer) 33private StringComparer Comparer { get; }

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.Extensions.Telemetry (2)

Latency\Internal\Registry.cs (1)

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

Logging\ExtendedLoggerFactory.cs (1)

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

Microsoft.Gen.Logging (5)

Parsing\Parser.cs (5)

160bool parameterInTemplate = lm.Templates.Contains(lp.TagName, StringComparer.OrdinalIgnoreCase) || 161lm.Templates.Contains(lp.ParameterNameWithAtIfNeeded, StringComparer.OrdinalIgnoreCase) || 162lm.Templates.Contains($"@{lp.ParameterName}", StringComparer.OrdinalIgnoreCase); 481var names = new HashSet<string>(StringComparer.Ordinal); 643HashSet<string> shadowedNames = new(StringComparer.Ordinal);

Microsoft.JSInterop (3)

Infrastructure\DotNetDispatcher.cs (3)

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

Microsoft.Maui (10)

CommandMapper.cs (1)

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

Fonts\FontRegistrar.cs (3)

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

Handlers\HybridWebView\FileExtensionContentTypeProvider.cs (1)

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

HotReload\HotReloadHelper.cs (2)

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

LifecycleEvents\LifecycleEventService.cs (1)

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

PropertyMapper.cs (1)

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

WeakEventManager.cs (1)

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

Microsoft.Maui.Controls (19)

Application\Application.cs (2)

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

AppLinkEntry.cs (1)

15 keyValues = new(StringComparer.Ordinal);

DragAndDrop\DataPackagePropertySet.cs (1)

16 _propertyBag = new(StringComparer.Ordinal);

Internals\NameScope.cs (1)

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

Registrar.cs (2)

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

ResourceDictionary.cs (1)

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

ResourcesExtensions.cs (3)

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

Routing.cs (3)

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

Shell\ShellRouteParameters.cs (1)

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

StyleSheets\Style.cs (1)

17 public IDictionary<string, string> Declarations { get; set; } = new Dictionary<string, string>(StringComparer.Ordinal);

VisualElement\VisualElement.cs (1)

1550 var innerKeys = new HashSet<string>(StringComparer.Ordinal);

Visuals\VisualTypeConverter.cs (1)

28 var mappings = new Dictionary<string, IVisual>(StringComparer.OrdinalIgnoreCase);

VisualStateManager.cs (1)

156 readonly HashSet<string> _names = new HashSet<string>(StringComparer.Ordinal);

Microsoft.Maui.Controls.Build.Tasks (2)

PerformanceProvider.cs (1)

21 readonly Dictionary<string, Statistic> _Statistics = new(StringComparer.Ordinal);

XamlCache.cs (1)

54 GetOrAdd(_resourceNamesInUse, variableDefinition, _ => new HashSet<string>(StringComparer.Ordinal));

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.Controls.Xaml (1)

XamlServiceProvider.cs (1)

286 readonly Dictionary<string, string> namespaces = new Dictionary<string, string>(StringComparer.Ordinal);

Microsoft.Maui.Essentials (4)

Types\Shared\WebUtils.shared.cs (1)

11 var parameters = new Dictionary<string, string>(StringComparer.Ordinal);

VersionTracking\VersionTracking.shared.cs (2)

241 versionTrail = new(StringComparer.Ordinal) 249 versionTrail = new(StringComparer.Ordinal)

WebAuthenticator\WebAuthenticatorResult.shared.cs (1)

76 public Dictionary<string, string> Properties { get; set; } = new(StringComparer.Ordinal);

Microsoft.Maui.Graphics (1)

Text\TextColors.cs (1)

9 public static Dictionary<string, string> StandardColors = new(StringComparer.OrdinalIgnoreCase)

Microsoft.Maui.Graphics.Text.Markdig (1)

Renderer\SimpleCssParser.cs (1)

13 var values = new Dictionary<string, string>(StringComparer.Ordinal);

Microsoft.Maui.Resizetizer (3)

ColorTable.cs (1)

17 var colors = new Dictionary<string, SKColor>(StringComparer.OrdinalIgnoreCase);

ResizetizeImages.cs (1)

107 var attr = new Dictionary<string, string>(StringComparer.Ordinal);

TizenResourceXmlGenerator.cs (1)

10 static readonly IDictionary<string, string> resolutionMap = new Dictionary<string, string>(StringComparer.Ordinal)

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.VisualBasic.Core (2)

Microsoft\VisualBasic\Collection.vb (2)

340m_KeyedNodesHash = New Generic.Dictionary(Of String, Node)(StartingHashCapacity, StringComparer.Create(CultureInfo, ignoreCase:=True)) 342m_KeyedNodesHash = New Generic.Dictionary(Of String, Node)(StringComparer.Create(CultureInfo, ignoreCase:=True))

Microsoft.VisualStudio.LanguageServices (25)

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 (2)

45while (currentItems.FindItem(folderName, StringComparer.OrdinalIgnoreCase) != null) 54public static ProjectItem? FindItemByPath(this EnvDTE.Project project, string itemFilePath, StringComparer comparer)

ProjectSystem\Extensions\ProjectItemExtensions.cs (1)

13public static ProjectItem FindItem(this ProjectItem item, string itemName, StringComparer comparer)

ProjectSystem\Extensions\ProjectItemsExtensions.cs (4)

16public static ProjectItem FindItem(this ProjectItems items, string itemName, StringComparer comparer) 21var item = items.FindItem(folderName, StringComparer.OrdinalIgnoreCase); 26=> NameGenerator.GenerateUniqueName(itemName, extension, n => items.FindItem(n, StringComparer.OrdinalIgnoreCase) == null); 32var foundItem = items.FindItem(n, StringComparer.OrdinalIgnoreCase);

ProjectSystem\MetadataReferences\VisualStudioFrameworkAssemblyPathResolverFactory.cs (1)

136if (StringComparer.OrdinalIgnoreCase.Equals(frameworkName.Identifier, ".NETCore") &&

ProjectSystem\MetadataReferences\VisualStudioMetadataReferenceManager.cs (1)

59private readonly Dictionary<string, (DateTime lastWriteTime, AssemblyMetadata metadata)> _metadataCache = new(StringComparer.OrdinalIgnoreCase);

ProjectSystem\OpenTextBufferProvider.cs (1)

48private ImmutableDictionary<string, ITextBuffer> _monikerToTextBufferMap = ImmutableDictionary<string, ITextBuffer>.Empty.WithComparers(StringComparer.OrdinalIgnoreCase);

ProjectSystem\RuleSets\RuleSetEventHandler.cs (2)

87var ruleSetRenames = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 184var ruleSetDeletions = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

ProjectSystem\VisualStudioWorkspaceImpl.AddMetadataReferenceUndoUnit.cs (1)

36.FirstOrDefault(p => StringComparer.OrdinalIgnoreCase.Equals(p.FilePath, _filePath));

ProjectSystem\VisualStudioWorkspaceImpl.cs (3)

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),

UnusedReferences\Dialog\UnusedReferencesTableProvider.ColumnDefinitions.cs (1)

341public ImageEntryBucket(ImageMoniker imageMoniker, string name, object? tooltip = null, StringComparer? comparer = null, bool expandedByDefault = true)

Microsoft.VisualStudio.LanguageServices.CSharp (15)

CodeModel\CSharpCodeModelService.CodeModelEventCollector.cs (11)

CodeModel\CSharpCodeModelService.cs (4)

3609if (StringComparer.Ordinal.Equals(name, ExtenderNames.PartialMethod)) 3627else if (StringComparer.Ordinal.Equals(name, ExtenderNames.ExtensionMethod)) 3649if (StringComparer.Ordinal.Equals(name, ExtenderNames.AutoImplementedProperty)) 3667if (StringComparer.Ordinal.Equals(name, ExtenderNames.ExternalLocation))

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);

mscorlib (1)

src\libraries\shims\mscorlib\ref\mscorlib.cs (1)

1085[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.StringComparer))]

NativeIISSample (1)

Startup.cs (1)

73foreach (var key in vars.Keys.Cast<string>().OrderBy(key => key, StringComparer.OrdinalIgnoreCase))

netstandard (1)

netstandard.cs (1)

2019[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.StringComparer))]

PresentationBuildTasks (5)

MS\Internal\Tasks\IncrementalCompileAnalyzer.cs (1)

391HashSet<string> localMarkupPages = new HashSet<string>(_mcPass1.PageMarkup.Select(x => x.GetMetadata(SharedStrings.FullPath)), StringComparer.OrdinalIgnoreCase);

src\Microsoft.DotNet.Wpf\src\PresentationFramework\System\Windows\Markup\ParserContext.cs (1)

842Dictionary<string, SpecialBracketCharacters> cache = new Dictionary<string, SpecialBracketCharacters>(StringComparer.OrdinalIgnoreCase);

src\Microsoft.DotNet.Wpf\src\PresentationFramework\System\Windows\Markup\XmlnsCache.cs (1)

87foreach(string assemblyName in _assemblyPathTable.Keys.OfType<string>().OrderBy(s => s, StringComparer.Ordinal))

src\Microsoft.DotNet.Wpf\src\Shared\System\Windows\Markup\ReflectionHelper.cs (2)

60_cachedMetadataLoadContextAssemblies = new Dictionary<string, Assembly>(StringComparer.OrdinalIgnoreCase); 61_cachedMetadataLoadContextAssembliesByNameNoExtension = new Dictionary<string, Assembly>(StringComparer.OrdinalIgnoreCase);

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 (5)

MS\Internal\AppModel\ResourceContainer.cs (1)

322private static readonly Dictionary<string, ResourceManagerWrapper> s_registeredResourceManagers = new(StringComparer.Ordinal);

MS\Internal\IO\Packaging\XamlFilter.cs (1)

102_lcidDictionary = new Dictionary<string, uint>(StringComparer.OrdinalIgnoreCase);

System\Windows\Documents\Speller.cs (1)

51_defaultComparer = StringComparer.Create(_defaultCulture, true);

System\Windows\Markup\ParserContext.cs (1)

842Dictionary<string, SpecialBracketCharacters> cache = new Dictionary<string, SpecialBracketCharacters>(StringComparer.OrdinalIgnoreCase);

System\Windows\ThemeMode.cs (1)

91public override int GetHashCode() => _value != null ? StringComparer.Ordinal.GetHashCode(_value) : 0;

Replay (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 (33)

src\Compilers\Core\Portable\FileSystem\PathUtilities.cs (3)

520var comparer = ignoreCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;

src\Compilers\Core\Portable\InternalUtilities\Hash.cs (2)

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (1)

359ImmutableHashSet.Create(StringComparer.Ordinal, "Add", "AddOrUpdate", "GetOrAdd", "TryAdd", "TryUpdate");

src\RoslynAnalyzers\Utilities\Compiler\RulesetToEditorconfigConverter.cs (1)

67var ruleIdToComments = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

src\RoslynAnalyzers\Utilities\Compiler\SymbolByDisplayStringComparer.cs (1)

55return StringComparer.Ordinal.Compare(

src\RoslynAnalyzers\Utilities\Compiler\WellKnownTypeProvider.cs (2)

32_fullNameToTypeMap = new ConcurrentDictionary<string, INamedTypeSymbol?>(StringComparer.Ordinal); 82new(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 (3)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\EditorConfig\EditorConfigNamingStyleParser.cs (2)

59.ThenBy(item => item.title, StringComparer.OrdinalIgnoreCase) 60.ThenBy(item => item.title, StringComparer.Ordinal);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\ObjectPools\SharedPools.cs (3)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\EditorConfigValueSerializer.cs (2)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\ISyntaxFacts.cs (1)

88StringComparer StringComparer { get; }

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyComparer.cs (3)

34var comparer = _options.IgnoreCase 35? StringComparer.OrdinalIgnoreCase 36: StringComparer.Ordinal;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (3)

593var comparer = caseSensitive ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IMethodSymbolExtensions.cs (2)

33syntaxFacts.IsCaseSensitive ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\NameGenerator.cs (1)

137public static string GenerateUniqueName(string baseName, ISet<string> names, StringComparer comparer)

SymbolDeclaredEventMustBeGeneratedForSourceSymbols.cs (1)

159namedType.GetBaseTypesAndThis().Any(b => SymbolTypesWithExpectedSymbolDeclaredEvent.Contains(b.Name, StringComparer.Ordinal)))

Roslyn.Diagnostics.CSharp.Analyzers (3)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Services\SemanticFacts\CSharpSemanticFacts.cs (1)

138var builder = ImmutableHashSet.CreateBuilder<string>(StringComparer.Ordinal);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Services\SyntaxFacts\CSharpSyntaxFacts.cs (2)

36public StringComparer StringComparer { get; } = StringComparer.Ordinal;

Roslyn.VisualStudio.Next.UnitTests (2)

Services\SolutionServiceTests.cs (2)

102Assert.Equal(Hash.CombineValues(array, StringComparer.Ordinal), compilationOptions.StrongNameProvider.GetHashCode()); 130Assert.Equal(Hash.CombineValues(array, StringComparer.Ordinal), compilationOptions.StrongNameProvider.GetHashCode());

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);

SignalRSamples (1)

ConnectionList.cs (1)

12private readonly ConcurrentDictionary<string, ConnectionContext> _connections = new ConcurrentDictionary<string, ConnectionContext>(StringComparer.Ordinal);

SocialWeather (1)

ConnectionList.cs (1)

13new ConcurrentDictionary<string, ConnectionContext>(StringComparer.Ordinal);

Swaggatherer (1)

Template.cs (1)

16StringComparer.OrdinalIgnoreCase);

System.CodeDom (6)

Microsoft\CSharp\CSharpCodeGenerator.cs (1)

2444var importList = new SortedSet<string>(StringComparer.Ordinal);

Microsoft\VisualBasic\VBCodeGenerator.cs (1)

2237var importList = new SortedSet<string>(StringComparer.OrdinalIgnoreCase);

src\libraries\Common\src\System\IO\TempFileCollection.cs (1)

41_files = new Hashtable(StringComparer.OrdinalIgnoreCase);

System\CodeDom\CodeNamespaceImportCollection.cs (1)

12private readonly Dictionary<string, CodeNamespaceImport> _keys = new Dictionary<string, CodeNamespaceImport>(StringComparer.OrdinalIgnoreCase);

System\CodeDom\Compiler\CodeDomProvider.cs (2)

16private static readonly Dictionary<string, CompilerInfo> s_compilerLanguages = new Dictionary<string, CompilerInfo>(StringComparer.OrdinalIgnoreCase); 17private static readonly Dictionary<string, CompilerInfo> s_compilerExtensions = new Dictionary<string, CompilerInfo>(StringComparer.OrdinalIgnoreCase);

System.Collections.Immutable (30)

System\Collections\Frozen\FrozenDictionary.cs (3)

205(ReferenceEquals(comparer, EqualityComparer<TKey>.Default) || ReferenceEquals(comparer, StringComparer.Ordinal) || ReferenceEquals(comparer, StringComparer.OrdinalIgnoreCase))) 232KeyAnalyzer.AnalysisResults analysis = KeyAnalyzer.Analyze(keys, ReferenceEquals(stringComparer, StringComparer.OrdinalIgnoreCase), minLength, maxLength);

System\Collections\Frozen\FrozenSet.cs (3)

136(ReferenceEquals(comparer, EqualityComparer<T>.Default) || ReferenceEquals(comparer, StringComparer.Ordinal) || ReferenceEquals(comparer, StringComparer.OrdinalIgnoreCase))) 164KeyAnalyzer.AnalysisResults analysis = KeyAnalyzer.Analyze(entries, ReferenceEquals(stringComparer, StringComparer.OrdinalIgnoreCase), minLength, maxLength);

System\Collections\Frozen\String\LengthBuckets.cs (2)

19Debug.Assert(comparer == EqualityComparer<string>.Default || comparer == StringComparer.Ordinal || comparer == StringComparer.OrdinalIgnoreCase);

System\Collections\Frozen\String\LengthBucketsFrozenDictionary.cs (4)

23Debug.Assert(comparer == EqualityComparer<string>.Default || comparer == StringComparer.Ordinal || comparer == StringComparer.OrdinalIgnoreCase); 29_ignoreCase = ReferenceEquals(comparer, StringComparer.OrdinalIgnoreCase); 96if (StringComparer.OrdinalIgnoreCase.Equals(key, keys[index]))

System\Collections\Frozen\String\LengthBucketsFrozenSet.cs (4)

21Debug.Assert(comparer == EqualityComparer<string>.Default || comparer == StringComparer.Ordinal || comparer == StringComparer.OrdinalIgnoreCase); 26_ignoreCase = ReferenceEquals(comparer, StringComparer.OrdinalIgnoreCase); 91if (StringComparer.OrdinalIgnoreCase.Equals(item, items[index]))

System\Collections\Frozen\String\OrdinalStringFrozenDictionary.cs (2)

31Debug.Assert(comparer == EqualityComparer<string>.Default || comparer == StringComparer.Ordinal || comparer == StringComparer.OrdinalIgnoreCase);

System\Collections\Frozen\String\OrdinalStringFrozenDictionary_FullCaseInsensitive.cs (1)

27private protected override bool Equals(string? x, string? y) => StringComparer.OrdinalIgnoreCase.Equals(x, y);

System\Collections\Frozen\String\OrdinalStringFrozenDictionary_FullCaseInsensitiveAscii.cs (1)

27private protected override bool Equals(string? x, string? y) => StringComparer.OrdinalIgnoreCase.Equals(x, y);

System\Collections\Frozen\String\OrdinalStringFrozenDictionary_LeftJustifiedCaseInsensitiveAsciiSubstring.cs (1)

25private protected override bool Equals(string? x, string? y) => StringComparer.OrdinalIgnoreCase.Equals(x, y);

System\Collections\Frozen\String\OrdinalStringFrozenDictionary_LeftJustifiedCaseInsensitiveSubstring.cs (1)

25private protected override bool Equals(string? x, string? y) => StringComparer.OrdinalIgnoreCase.Equals(x, y);

System\Collections\Frozen\String\OrdinalStringFrozenDictionary_RightJustifiedCaseInsensitiveAsciiSubstring.cs (1)

25private protected override bool Equals(string? x, string? y) => StringComparer.OrdinalIgnoreCase.Equals(x, y);

System\Collections\Frozen\String\OrdinalStringFrozenDictionary_RightJustifiedCaseInsensitiveSubstring.cs (1)

25private protected override bool Equals(string? x, string? y) => StringComparer.OrdinalIgnoreCase.Equals(x, y);

System\Collections\Frozen\String\OrdinalStringFrozenSet_FullCaseInsensitive.cs (1)

26private protected override bool Equals(string? x, string? y) => StringComparer.OrdinalIgnoreCase.Equals(x, y);

System\Collections\Frozen\String\OrdinalStringFrozenSet_FullCaseInsensitiveAscii.cs (1)

26private protected override bool Equals(string? x, string? y) => StringComparer.OrdinalIgnoreCase.Equals(x, y);

System\Collections\Frozen\String\OrdinalStringFrozenSet_LeftJustifiedCaseInsensitiveAsciiSubstring.cs (1)

24private protected override bool Equals(string? x, string? y) => StringComparer.OrdinalIgnoreCase.Equals(x, y);

System\Collections\Frozen\String\OrdinalStringFrozenSet_LeftJustifiedCaseInsensitiveSubstring.cs (1)

24private protected override bool Equals(string? x, string? y) => StringComparer.OrdinalIgnoreCase.Equals(x, y);

System\Collections\Frozen\String\OrdinalStringFrozenSet_RightJustifiedCaseInsensitiveAsciiSubstring.cs (1)

24private protected override bool Equals(string? x, string? y) => StringComparer.OrdinalIgnoreCase.Equals(x, y);

System\Collections\Frozen\String\OrdinalStringFrozenSet_RightJustifiedCaseInsensitiveSubstring.cs (1)

24private protected override bool Equals(string? x, string? y) => StringComparer.OrdinalIgnoreCase.Equals(x, y);

System.Collections.NonGeneric (3)

System\Collections\Specialized\CollectionsUtil.cs (3)

19return new Hashtable(StringComparer.CurrentCultureIgnoreCase); 24return new Hashtable(capacity, StringComparer.CurrentCultureIgnoreCase); 29return new Hashtable(d, StringComparer.CurrentCultureIgnoreCase);

System.Collections.Specialized (8)

System\Collections\Specialized\HybridDictionary.cs (7)

53hashtable = new Hashtable(initialSize, StringComparer.OrdinalIgnoreCase); 111list = new ListDictionary(caseInsensitive ? StringComparer.OrdinalIgnoreCase : null); 117private ListDictionary List => list ??= new ListDictionary(caseInsensitive ? StringComparer.OrdinalIgnoreCase : null); 126newTable = new Hashtable(InitialHashtableSize, StringComparer.OrdinalIgnoreCase); 236list = new ListDictionary(caseInsensitive ? StringComparer.OrdinalIgnoreCase : null); 306list ??= new ListDictionary(caseInsensitive ? StringComparer.OrdinalIgnoreCase : null); 317list ??= new ListDictionary(caseInsensitive ? StringComparer.OrdinalIgnoreCase : null);

System\Collections\Specialized\NameObjectCollectionBase.cs (1)

35private static readonly StringComparer s_defaultComparer = CultureInfo.InvariantCulture.CompareInfo.GetStringComparer(CompareOptions.IgnoreCase);

System.ComponentModel.Annotations (1)

System\ComponentModel\DataAnnotations\AssociatedMetadataTypeTypeDescriptor.cs (1)

154HashSet<string> buddyTypeMembers = new HashSet<string>(buddyFields.Concat(buddyProperties), StringComparer.Ordinal);

System.ComponentModel.Composition (37)

Microsoft\Internal\StringComparers.cs (4)

10public static StringComparer ContractName 12get { return StringComparer.Ordinal; } 15public static StringComparer MetadataKeyNames 17get { return StringComparer.Ordinal; }

System\ComponentModel\Composition\ExportAttribute.cs (4)

27/// using <see cref="StringComparer.Ordinal"/>. 58/// using <see cref="StringComparer.Ordinal"/>. 83/// using <see cref="StringComparer.Ordinal"/>. 113/// using <see cref="StringComparer.Ordinal"/>.

System\ComponentModel\Composition\Hosting\ExportProvider.GetExportOverrides.cs (15)

System\ComponentModel\Composition\ImportAttribute.cs (3)

28/// using <see cref="StringComparer.Ordinal"/>. 57/// using <see cref="StringComparer.Ordinal"/>. 81/// using <see cref="StringComparer.Ordinal"/>.

System\ComponentModel\Composition\ImportManyAttribute.cs (3)

28/// using <see cref="StringComparer.Ordinal"/>. 57/// using <see cref="StringComparer.Ordinal"/>. 81/// using <see cref="StringComparer.Ordinal"/>.

System\ComponentModel\Composition\InheritedExportAttribute.cs (4)

26/// using <see cref="StringComparer.Ordinal"/>. 56/// using <see cref="StringComparer.Ordinal"/>. 81/// using <see cref="StringComparer.Ordinal"/>. 111/// using <see cref="StringComparer.Ordinal"/>.

System\ComponentModel\Composition\Primitives\ComposablePart.cs (1)

100/// non-linguistic comparer, such as <see cref="StringComparer.Ordinal"/>,

System\ComponentModel\Composition\Primitives\ComposablePartDefinition.cs (1)

76/// non-linguistic comparer, such as <see cref="StringComparer.Ordinal"/>,

System\ComponentModel\Composition\Primitives\ExportDefinition.cs (1)

108/// non-linguistic comparer, such as <see cref="StringComparer.Ordinal"/>,

System\ComponentModel\Composition\Primitives\ImportDefinition.cs (1)

152/// non-linguistic comparer, such as <see cref="StringComparer.Ordinal"/>,

System.ComponentModel.TypeConverter (5)

src\libraries\Common\src\System\Drawing\ColorTable.cs (1)

16var colors = new Dictionary<string, Color>(StringComparer.OrdinalIgnoreCase);

System\ComponentModel\ComponentResourceManager.cs (3)

116if (resources == null || (resources.Comparer.Equals(StringComparer.OrdinalIgnoreCase) != IgnoreCase)) 231sd = new SortedList<string, object?>(StringComparer.OrdinalIgnoreCase); 235sd = new SortedList<string, object?>(StringComparer.Ordinal);

System\ComponentModel\PropertyDescriptorCollection.cs (1)

186_cachedFoundProperties = new Hashtable(StringComparer.OrdinalIgnoreCase);

System.Configuration.ConfigurationManager (16)

src\libraries\Common\src\System\IO\TempFileCollection.cs (1)

41_files = new Hashtable(StringComparer.OrdinalIgnoreCase);

System\Configuration\BaseConfigurationRecord.cs (1)

3417_children ??= new Hashtable(StringComparer.OrdinalIgnoreCase);

System\Configuration\ConfigurationSectionCollection.cs (1)

16base(StringComparer.Ordinal)

System\Configuration\ConfigurationSectionGroupCollection.cs (1)

17base(StringComparer.Ordinal)

System\Configuration\ConfigurationValues.cs (1)

16internal ConfigurationValues() : base(StringComparer.Ordinal) { }

System\Configuration\ConnectionStringSettingsCollection.cs (1)

12: base(StringComparer.OrdinalIgnoreCase)

System\Configuration\DictionarySectionHandler.cs (1)

32res = new Hashtable(StringComparer.OrdinalIgnoreCase);

System\Configuration\KeyValueConfigurationCollection.cs (1)

12base(StringComparer.OrdinalIgnoreCase)

System\Configuration\MgmtConfigurationRecord.cs (1)

302_locationTags ??= new Hashtable(StringComparer.OrdinalIgnoreCase);

System\Configuration\NameValueSectionHandler.cs (1)

33result = new ReadOnlyNameValueCollection(StringComparer.OrdinalIgnoreCase);

System\Configuration\PropertyInformationCollection.cs (1)

12internal PropertyInformationCollection(ConfigurationElement thisElement) : base(StringComparer.Ordinal)

System\Configuration\Provider\ProviderCollection.cs (1)

15_hashtable = new Hashtable(10, StringComparer.OrdinalIgnoreCase);

System\Configuration\ProviderSettings.cs (1)

69_propertyNameCollection = new NameValueCollection(StringComparer.Ordinal);

System\Configuration\ProviderSettingsCollection.cs (1)

12base(StringComparer.OrdinalIgnoreCase)

System\Configuration\SettingsPropertyCollection.cs (1)

15_hashtable = new Hashtable(10, StringComparer.CurrentCultureIgnoreCase);

System\Configuration\SettingsPropertyValueCollection.cs (1)

16_indices = new Hashtable(10, StringComparer.CurrentCultureIgnoreCase);

System.Data.Common (7)

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\DataTable.cs (2)

83private StringComparer? _hashCodeProvider; 3223_hashCodeProvider = StringComparer.Create(Locale, true);

System.Data.Odbc (27)

Common\System\Data\Common\DBConnectionString.cs (7)

352return ((null == _restrictionValues) || (0 > Array.BinarySearch(_restrictionValues, key, StringComparer.Ordinal))); 398if (0 > Array.BinarySearch(preventusage, allowonly[i], StringComparer.Ordinal)) 421if (0 <= Array.BinarySearch(b, a[i], StringComparer.Ordinal)) 454if (0 > Array.BinarySearch(a, b[i], StringComparer.Ordinal)) 460Array.Sort(restrictionValues, StringComparer.Ordinal); 496Array.Sort(restrictions, StringComparer.Ordinal); 539Debug.Assert(0 >= StringComparer.Ordinal.Compare(restrictionValues[i - 1], restrictionValues[i]));

Common\System\Data\Common\DbConnectionStringCommon.cs (18)

src\libraries\Common\src\System\Data\Common\DbConnectionOptions.Common.cs (1)

151(0 == StringComparer.OrdinalIgnoreCase.Compare(strvalue, strconst));

System\Data\Odbc\OdbcConnectionStringbuilder.cs (1)

28private static readonly Dictionary<string, Keywords> s_keywords = new Dictionary<string, Keywords>(2, StringComparer.OrdinalIgnoreCase)

System.Diagnostics.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.Formats.Nrbf (1)

System\Formats\Nrbf\ClassInfo.cs (1)

55Dictionary<string, int> memberNames = new(StringComparer.Ordinal);

System.Formats.Tar (1)

System\Formats\Tar\TarHelpers.Unix.cs (1)

43=> StringComparer.Ordinal.Compare(y, x);

System.IO.Packaging (1)

System\IO\Packaging\ZipPackage.cs (1)

1371_ignoredItemDictionary = new Dictionary<string, List<string>>(_dictionaryInitialSize, StringComparer.Ordinal);

System.Linq (1)

System\Linq\OrderedEnumerable.cs (1)

101comparer = (IComparer<TKey>)StringComparer.CurrentCulture;

System.Linq.AsyncEnumerable (1)

System\Linq\OrderBy.cs (1)

245comparer = (IComparer<TKey>)StringComparer.CurrentCulture;

System.Net.Mail (5)

System\Net\Mail\MailAddress.cs (1)

282return StringComparer.InvariantCultureIgnoreCase.GetHashCode(ToString());

System\Net\Mail\MailHeaderInfo.cs (1)

74var headers = new Dictionary<string, int>((int)MailHeaderID.ZMaxEnumValue + 1, StringComparer.OrdinalIgnoreCase);

System\Net\Mime\ContentDisposition.cs (1)

251public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(ToString());

System\Net\Mime\ContentType.cs (1)

215public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(ToString());

System\Net\Mime\HeaderCollection.cs (1)

17internal HeaderCollection() : base(StringComparer.OrdinalIgnoreCase)

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 (39)

src\libraries\System.Private.CoreLib\src\Internal\Runtime\InteropServices\ComponentActivator.cs (2)

24private static readonly Dictionary<string, IsolatedComponentLoadContext> s_assemblyLoadContexts = new Dictionary<string, IsolatedComponentLoadContext>(StringComparer.InvariantCulture); 26private static readonly HashSet<string> s_loadedInDefaultContext = new HashSet<string>(StringComparer.InvariantCulture);

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\NonRandomizedStringEqualityComparer.cs (4)

24private static readonly NonRandomizedStringEqualityComparer WrappedAroundStringComparerOrdinal = new OrdinalComparer(StringComparer.Ordinal); 25private static readonly NonRandomizedStringEqualityComparer WrappedAroundStringComparerOrdinalIgnoreCase = new OrdinalIgnoreCaseComparer(StringComparer.OrdinalIgnoreCase); 157if (ReferenceEquals(comparer, StringComparer.Ordinal)) 162if (ReferenceEquals(comparer, StringComparer.OrdinalIgnoreCase))

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventSource.cs (1)

5808Array.Sort(sortedStrings, StringComparer.Ordinal);

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\TraceLogging\NameInfo.cs (1)

65int result = StringComparer.Ordinal.Compare(this.name, otherName);

src\libraries\System.Private.CoreLib\src\System\Globalization\CultureData.cs (1)

152new Dictionary<string, string>(255, StringComparer.OrdinalIgnoreCase)

src\libraries\System.Private.CoreLib\src\System\Globalization\GlobalizationExtensions.cs (3)

8public static StringComparer GetStringComparer(this CompareInfo compareInfo, CompareOptions options) 14return StringComparer.Ordinal; 19return StringComparer.OrdinalIgnoreCase;

src\libraries\System.Private.CoreLib\src\System\Resources\ResourceSet.cs (1)

217caseTable = new Dictionary<string, object?>(copyOfTable.Count, StringComparer.OrdinalIgnoreCase);

src\libraries\System.Private.CoreLib\src\System\Resources\RuntimeResourceSet.cs (1)

317caseInsensitiveTable = new Dictionary<string, ResourceLocator>(StringComparer.OrdinalIgnoreCase);

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\OSPlatform.cs (1)

52return Name == null ? 0 : StringComparer.OrdinalIgnoreCase.GetHashCode(Name);

src\libraries\System.Private.CoreLib\src\System\Runtime\Loader\AssemblyDependencyResolver.cs (1)

96_assemblyPaths = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\Helpers\AhoCorasickBuilder.cs (1)

95unreachableValues ??= new HashSet<string>(StringComparer.Ordinal);

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\StringSearchValues.cs (4)

44var uniqueValues = new HashSet<string>(values.Length, ignoreCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal); 403uniqueValues ??= new HashSet<string>(1, ignoreCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal) { value };

src\libraries\System.Private.CoreLib\src\System\String.Comparison.cs (1)

763public int GetHashCode(StringComparison comparisonType) => StringComparer.FromComparison(comparisonType).GetHashCode(this);

src\libraries\System.Private.CoreLib\src\System\StringComparer.cs (12)

src\libraries\System.Private.CoreLib\src\System\Text\EncodingTable.cs (1)

18private static readonly Hashtable s_nameToCodePage = Hashtable.Synchronized(new Hashtable(StringComparer.OrdinalIgnoreCase));

src\libraries\System.Private.CoreLib\src\System\TimeZoneInfo.cs (3)

876public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(_id); 2041cachedData._timeZonesUsingAlternativeIds ??= new Dictionary<string, TimeZoneInfo>(StringComparer.OrdinalIgnoreCase); 2131cachedData._systemTimeZones ??= new Dictionary<string, TimeZoneInfo>(StringComparer.OrdinalIgnoreCase)

src\libraries\System.Private.CoreLib\src\System\TimeZoneInfo.Unix.cs (1)

291cachedData._systemTimeZones ??= new Dictionary<string, TimeZoneInfo>(StringComparer.OrdinalIgnoreCase)

System.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 (1)

artifacts\obj\System.Runtime\Debug\net10.0\System.Runtime.Forwards.cs (1)

774[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.StringComparer))]

System.Runtime.Caching (1)

System\Runtime\Caching\FileChangeNotificationSystem.cs (1)

92_dirMonitors = Hashtable.Synchronized(new Hashtable(StringComparer.OrdinalIgnoreCase));

System.Runtime.Extensions (1)

System.Runtime.Extensions.cs (1)

28[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.StringComparer))]

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.Federation (3)

System\IdentityModel\Tokens\Saml2AssertionKeyIdentifierClause.cs (2)

32if (keyIdentifierClause is Saml2AssertionKeyIdentifierClause saml2Clause && StringComparer.Ordinal.Equals(assertionId, saml2Clause.Id)) 44if (keyIdentifierClause is SamlAssertionKeyIdentifierClause samlClause && StringComparer.Ordinal.Equals(assertionId, samlClause.Id))

System\IdentityModel\Tokens\SamlAssertionKeyIdentifierClause.cs (1)

33if (keyIdentifierClause is SamlAssertionKeyIdentifierClause samlClause && StringComparer.Ordinal.Equals(assertionId, samlClause.Id))

System.ServiceModel.Syndication (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 (13)

System\Text\Json\Document\JsonElement.cs (1)

1367Dictionary<string, ValueQueue<JsonElement>> properties2 = new(capacity: remainingProps, StringComparer.Ordinal);

System\Text\Json\Nodes\JsonObject.IDictionary.cs (3)

280StringComparer comparer = options?.PropertyNameCaseInsensitive ?? false 281? StringComparer.OrdinalIgnoreCase 282: StringComparer.Ordinal;

System\Text\Json\Serialization\Converters\Value\EnumConverter.cs (3)

63_enumFieldInfoIndex = new(StringComparer.OrdinalIgnoreCase); 66_nameCacheForReading = new(StringComparer.Ordinal); 530(enumMemberAttributes ??= new(StringComparer.Ordinal)).Add(field.Name, attribute.Name);

System\Text\Json\Serialization\Metadata\JsonTypeInfo.cs (6)

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 (2)

JsonSourceGenerator.Parser.cs (2)

1035public Dictionary<string, (PropertyGenerationSpec, ISymbol, int index)> AddedProperties = new(options?.PropertyNameCaseInsensitive == true ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal);

System.Text.RegularExpressions.Generator (2)

RegexGenerator.cs (1)

266foreach (KeyValuePair<string, string[]> helper in requiredHelpers.OrderBy(h => h.Key, StringComparer.Ordinal))

RegexGenerator.Emitter.cs (1)

162AppendHashtableContents(writer, rm.Tree.CaptureNameToNumberMapping.Cast<DictionaryEntry>().OrderBy(de => de.Key as string, StringComparer.Ordinal));

System.Web.HttpUtility (1)

System\Web\HttpUtility.cs (1)

46: base(StringComparer.OrdinalIgnoreCase)

System.Windows.Forms (2)

System\Resources\AssemblyNamesTypeResolutionService.cs (1)

80_cachedTypes ??= new(StringComparer.Ordinal);

System\Windows\Forms\Controls\PropertyGrid\PropertyGridInternal\GridEntryComparer.cs (1)

11=> StringComparer.CurrentCulture.Compare(x?.ToString(), y?.ToString());

System.Windows.Forms.Design (10)

System\ComponentModel\Design\MenuCommandService.cs (1)

259Dictionary<string, int> buildVerbs = new(verbCount, StringComparer.OrdinalIgnoreCase);

System\ComponentModel\Design\Serialization\CodeDomDesignerLoader.cs (3)

419? StringComparer.InvariantCultureIgnoreCase 420: StringComparer.InvariantCulture); 1035HashSet<string> memberHash = new(StringComparer.CurrentCultureIgnoreCase);

System\ComponentModel\Design\Serialization\DesignerSerializationManager.cs (2)

781_instancesByName ??= new(StringComparer.CurrentCulture); 925_instancesByName = new(StringComparer.CurrentCulture);

System\Resources\Tools\StronglyTypedResourceBuilder.cs (4)

165Dictionary<string, ResourceData> resourceTypes = new(StringComparer.InvariantCultureIgnoreCase); 271Dictionary<string, ResourceData> resourceList = new(StringComparer.InvariantCultureIgnoreCase); 865reverseFixupTable = new(0, StringComparer.InvariantCultureIgnoreCase); 866SortedList<string, ResourceData> cleanedResourceList = new(resourceList.Count, StringComparer.InvariantCultureIgnoreCase);

System.Windows.Forms.Design.Tests (2)

System\Windows\Forms\Design\EmbeddedResourceTests.cs (2)

136Array.Sort(actual, StringComparer.Ordinal); 139Array.Sort(expected, StringComparer.Ordinal);

System.Windows.Forms.Primitives (1)

Windows\Win32\System\Ole\ClassPropertyDispatchAdapter.cs (1)

25private readonly Dictionary<string, int> _reverseLookup = new(StringComparer.OrdinalIgnoreCase);

System.Windows.Forms.Tests (4)

System\Windows\Forms\EmbeddedResourceTests.cs (2)

254Array.Sort(actual, StringComparer.Ordinal); 258Array.Sort(expected, StringComparer.Ordinal);

System\Windows\Forms\TreeViewTests.cs (2)

4709yield return new object[] { StringComparer.CurrentCulture }; 4732TreeViewNodeSorter = StringComparer.CurrentCulture

System.Xaml (6)

System\Xaml\Context\NameFixupGraph.cs (1)

43_dependenciesByName = new Dictionary<string, FrugalObjectList<NameFixupToken>>(StringComparer.Ordinal);

System\Xaml\MS\Impl\XmlNsInfo.cs (4)

145else if (StringComparer.Ordinal.Compare(prefix1, prefix2) < 0) 304Dictionary<string, string> result = new Dictionary<string, string>(StringComparer.Ordinal); 357Dictionary<string, string> result = new Dictionary<string, string>(StringComparer.Ordinal); 568return StringComparer.Ordinal.Compare(ns1, ns2);

System\Xaml\XamlSchemaContext.cs (1)

589Dictionary<string, SpecialBracketCharacters> map = new Dictionary<string, SpecialBracketCharacters>(StringComparer.OrdinalIgnoreCase);

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);

Templates.Blazor.Tests (1)

src\ProjectTemplates\Shared\Project.cs (1)

331Assert.Equal(expectedProfileName, actualProfile.Name, StringComparer.Ordinal);

Templates.Blazor.WebAssembly.Auth.Tests (1)

src\ProjectTemplates\Shared\Project.cs (1)

331Assert.Equal(expectedProfileName, actualProfile.Name, StringComparer.Ordinal);

Templates.Blazor.WebAssembly.Tests (1)

src\ProjectTemplates\Shared\Project.cs (1)

331Assert.Equal(expectedProfileName, actualProfile.Name, StringComparer.Ordinal);

Templates.Mvc.Tests (1)

src\ProjectTemplates\Shared\Project.cs (1)

331Assert.Equal(expectedProfileName, actualProfile.Name, StringComparer.Ordinal);

Templates.Tests (1)

src\ProjectTemplates\Shared\Project.cs (1)

331Assert.Equal(expectedProfileName, actualProfile.Name, StringComparer.Ordinal);

Test.Utilities (29)

src\Compilers\Core\Portable\FileSystem\PathUtilities.cs (3)

520var comparer = ignoreCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;

src\Compilers\Core\Portable\InternalUtilities\Hash.cs (2)

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (1)

359ImmutableHashSet.Create(StringComparer.Ordinal, "Add", "AddOrUpdate", "GetOrAdd", "TryAdd", "TryUpdate");

src\RoslynAnalyzers\Utilities\Compiler\RulesetToEditorconfigConverter.cs (1)

67var ruleIdToComments = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

src\RoslynAnalyzers\Utilities\Compiler\SymbolByDisplayStringComparer.cs (1)

55return StringComparer.Ordinal.Compare(

src\RoslynAnalyzers\Utilities\Compiler\WellKnownTypeProvider.cs (2)

32_fullNameToTypeMap = new ConcurrentDictionary<string, INamedTypeSymbol?>(StringComparer.Ordinal); 82new(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 (3)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\EditorConfig\EditorConfigNamingStyleParser.cs (2)

59.ThenBy(item => item.title, StringComparer.OrdinalIgnoreCase) 60.ThenBy(item => item.title, StringComparer.Ordinal);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\ObjectPools\SharedPools.cs (3)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\EditorConfigValueSerializer.cs (2)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\ISyntaxFacts.cs (1)

88StringComparer StringComparer { get; }

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyComparer.cs (3)

34var comparer = _options.IgnoreCase 35? StringComparer.OrdinalIgnoreCase 36: StringComparer.Ordinal;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (3)

593var comparer = caseSensitive ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase;

Text.Analyzers (34)

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 (3)

520var comparer = ignoreCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;

src\Compilers\Core\Portable\InternalUtilities\Hash.cs (2)

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (1)

359ImmutableHashSet.Create(StringComparer.Ordinal, "Add", "AddOrUpdate", "GetOrAdd", "TryAdd", "TryUpdate");

src\RoslynAnalyzers\Utilities\Compiler\RulesetToEditorconfigConverter.cs (1)

67var ruleIdToComments = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

src\RoslynAnalyzers\Utilities\Compiler\SymbolByDisplayStringComparer.cs (1)

55return StringComparer.Ordinal.Compare(

src\RoslynAnalyzers\Utilities\Compiler\WellKnownTypeProvider.cs (2)

32_fullNameToTypeMap = new ConcurrentDictionary<string, INamedTypeSymbol?>(StringComparer.Ordinal); 82new(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 (3)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\EditorConfig\EditorConfigNamingStyleParser.cs (2)

59.ThenBy(item => item.title, StringComparer.OrdinalIgnoreCase) 60.ThenBy(item => item.title, StringComparer.Ordinal);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\ObjectPools\SharedPools.cs (3)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\EditorConfigValueSerializer.cs (2)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SyntaxFacts\ISyntaxFacts.cs (1)

88StringComparer StringComparer { get; }

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyComparer.cs (3)

34var comparer = _options.IgnoreCase 35? StringComparer.OrdinalIgnoreCase 36: StringComparer.Ordinal;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (3)

593var comparer = caseSensitive ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IMethodSymbolExtensions.cs (2)

33syntaxFacts.IsCaseSensitive ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Utilities\NameGenerator.cs (1)

137public static string GenerateUniqueName(string baseName, ISet<string> names, StringComparer comparer)

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) &&

WindowsBase.Tests (22)

System\ComponentModel\GroupDescriptionTests.cs (22)

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)

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);