OrdinalIgnoreCase

Acquisition\InstallationDiscovery.cs (2)

144_environment.IsWindows() ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal); 467var comparer = _environment.IsWindows() ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;

Agents\AspireSkills\AspireSkillsBundleProvider.cs (3)

174var skillNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 209if (installExcludedRelativePaths.Contains(AspireSkillsBundleLayout.SkillFileName, StringComparer.OrdinalIgnoreCase)) 220var filePaths = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

Agents\Copilot\CopilotAppInstallationDetector.cs (1)

60.Distinct(StringComparer.OrdinalIgnoreCase)

Agents\Hooks\AgentTelemetryCatalog.cs (3)

39var skills = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 40var references = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 89return new(skills, new HashSet<string>(tools, StringComparer.OrdinalIgnoreCase), references);

Agents\Playwright\PlaywrightCliInstaller.cs (2)

93.. AgentClient.All.Select(static client => client.ProjectSkillsDirectory).Distinct(StringComparer.OrdinalIgnoreCase), 333var existing = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

Backchannel\AppHostAuxiliaryBackchannel.cs (2)

412return snapshots.OrderBy(s => s.Name, StringComparer.OrdinalIgnoreCase).ToList(); 434return snapshots.OrderBy(s => s.Name, StringComparer.OrdinalIgnoreCase).ToList();

Backchannel\AppHostPathComparer.cs (1)

129? StringComparer.OrdinalIgnoreCase

Backchannel\ResourceSnapshotWatcher.cs (2)

269.OrderBy(update => update.Snapshot.Name, StringComparer.OrdinalIgnoreCase) 365.OrderBy(snapshot => snapshot.Name, StringComparer.OrdinalIgnoreCase)

Commands\AddCommand.cs (1)

233.ThenBy(p => p.FriendlyName, StringComparer.OrdinalIgnoreCase)

Commands\AgentInitCommand.cs (5)

Commands\DescribeCommand.cs (1)

450.ThenBy(e => e.Name, StringComparer.OrdinalIgnoreCase);

Commands\GroupedHelpWriter.cs (1)

132foreach (var cmd in ungroupedCommands.OrderBy(c => c.Name, StringComparer.OrdinalIgnoreCase))

Commands\IntegrationSearchCommand.cs (3)

103.ThenBy(p => p.FriendlyName, StringComparer.OrdinalIgnoreCase) 162.ThenBy(p => p.FriendlyName, StringComparer.OrdinalIgnoreCase) 163.ThenBy(p => p.Package.Id, StringComparer.OrdinalIgnoreCase)

Commands\NewCommand.cs (1)

169.Distinct(StringComparer.OrdinalIgnoreCase)

Commands\ParseResultHelper.cs (1)

346var knownOptions = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

Commands\PsCommand.cs (1)

349? StringComparer.OrdinalIgnoreCase

Commands\ResourceCommand.cs (1)

811var names = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

Commands\Sdk\SdkDumpCommand.cs (2)

140.GroupBy(integration => integration.Name, StringComparer.OrdinalIgnoreCase) 213? integrations.Select(i => i.Name).Distinct(StringComparer.OrdinalIgnoreCase).ToArray()

Commands\SecretListCommand.cs (5)

83foreach (var (key, value) in secrets.OrderBy(s => s.Key, StringComparer.OrdinalIgnoreCase)) 103foreach (var (key, value) in secrets.OrderBy(s => s.Key, StringComparer.OrdinalIgnoreCase)) 126.OrderBy(result => result.EnvironmentName, StringComparer.OrdinalIgnoreCase) 135foreach (var (key, value) in environment.Secrets.OrderBy(s => s.Key, StringComparer.OrdinalIgnoreCase)) 161foreach (var (key, value) in environment.Secrets.OrderBy(s => s.Key, StringComparer.OrdinalIgnoreCase))

Commands\StopCommand.cs (1)

680? StringComparer.OrdinalIgnoreCase

Documentation\ApiDocs\ApiDocsCache.cs (1)

165=> _contentCache.SetAsync(_memberIndexContainerIdsCacheKey, string.Join('\n', containerIds.OrderBy(static id => id, StringComparer.OrdinalIgnoreCase)), cancellationToken);

Documentation\ApiDocs\ApiDocsIndexService.cs (18)

Documentation\ApiDocs\ApiMemberMarkdownParser.cs (1)

66var slugCounts = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);

DotNet\ProcessExecutionFactory.cs (1)

39StringComparer.OrdinalIgnoreCase);

Git\GitRepository.cs (1)

96? StringComparer.OrdinalIgnoreCase

Mcp\Tools\ListIntegrationsTool.cs (1)

113.ThenBy(p => p.FriendlyName, StringComparer.OrdinalIgnoreCase)

Mcp\Tools\ListResourcesTool.cs (1)

457var seenRelationships = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

Mcp\Tools\McpToolHelpers.cs (1)

22private static readonly HashSet<string> s_sensitiveQueryKeys = new(StringComparer.OrdinalIgnoreCase)

NuGet\BundleNuGetService.cs (1)

580foreach (var source in sources.OrderBy(static source => source, StringComparer.OrdinalIgnoreCase))

NuGet\NuGetClient.cs (14)

NuGet\NuGetConfiguration.cs (4)

67var disabledKeys = overlay.DisabledPackageSourceKeys.ToHashSet(StringComparer.OrdinalIgnoreCase); 81static mapping => mapping.SourceKey, StringComparer.OrdinalIgnoreCase); 83static mapping => mapping.SourceKey, StringComparer.OrdinalIgnoreCase); 86.ToHashSet(StringComparer.OrdinalIgnoreCase)

NuGet\NuGetConfigurationBuilder.cs (14)

NuGet\NuGetPackageAssetResolver.cs (3)

83StringComparer.OrdinalIgnoreCase); 228return new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 231var overrides = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

NuGet\NuGetPackageCache.cs (1)

54}.ToFrozenSet(StringComparer.OrdinalIgnoreCase);

Packaging\IntegrationPackageSearchService.cs (1)

246.ThenBy(p => p.FriendlyName, StringComparer.OrdinalIgnoreCase);

Packaging\PackagingService.cs (3)

700var versionsById = new Dictionary<string, SortedSet<string>>(StringComparer.OrdinalIgnoreCase); 713versions = new SortedSet<string>(StringComparer.OrdinalIgnoreCase); 722.OrderBy(static kvp => kvp.Key, StringComparer.OrdinalIgnoreCase)

Processes\ProcessEnvironment.cs (1)

12public static StringComparer Comparer => StringComparer.OrdinalIgnoreCase;

Projects\AppHostCandidateFinder.cs (1)

498? StringComparer.OrdinalIgnoreCase

Projects\AppHostConfigurationProjector.cs (1)

29if (environmentVariables.Keys.Contains(projection.EnvironmentVariableName, StringComparer.OrdinalIgnoreCase)

Projects\CSharpProjectFile.cs (1)

70var addedIntegrations = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

Projects\DefaultLanguageDiscovery.cs (1)

75private static readonly Dictionary<string, string> s_experimentalFeatureFlags = new(StringComparer.OrdinalIgnoreCase)

Projects\DotNetBasedAppHostServerProject.cs (3)

254if (!atsAssemblies.Contains(integration.Name, StringComparer.OrdinalIgnoreCase)) 289if (!channelSources.Contains(mapping.Source, StringComparer.OrdinalIgnoreCase)) 306!channelSources.Contains(packageSourceOverride, StringComparer.OrdinalIgnoreCase))

Projects\FallbackProjectParser.cs (1)

100if (ProjectFileExtensions.Supported.Contains(projectFile.Extension, StringComparer.OrdinalIgnoreCase))

Projects\IntegrationClosureBuilder.cs (1)

348var fingerprints = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

Projects\IntegrationRestorePlan.cs (1)

301.OrderBy(static mapping => mapping.PackageFilter, StringComparer.OrdinalIgnoreCase)

Projects\JavaAppHostToolchainResolver.cs (1)

272OperatingSystem.IsLinux() ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase;

Projects\PrebuiltAppHostServer.cs (2)

986if (!atsAssemblies.Contains(pkg.Name, StringComparer.OrdinalIgnoreCase)) 994if (!atsAssemblies.Contains(name, StringComparer.OrdinalIgnoreCase))

Projects\ProjectFileExtensions.cs (1)

8public static readonly HashSet<string> Supported = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { ".csproj", ".fsproj", ".vbproj" };

Projects\ProjectUpdater.cs (2)

801var candidates = new HashSet<string>(OperatingSystem.IsWindows() ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal); 1975.Select(static feed => feed.Key).ToHashSet(StringComparer.OrdinalIgnoreCase);

Projects\SolutionLocator.cs (1)

88.ThenBy(f => f.Name, StringComparer.OrdinalIgnoreCase)

Secrets\AspireSecretsStoreResolver.cs (1)

144foreach (var file in Directory.EnumerateFiles(secretsDirectory, "*.json", SearchOption.TopDirectoryOnly).Order(StringComparer.OrdinalIgnoreCase))

src\Shared\ColorGenerator.cs (2)

65_colorIndexByKey = new ConcurrentDictionary<string, Lazy<int>>(StringComparer.OrdinalIgnoreCase); 101foreach (var key in keys.OrderBy(k => k, StringComparer.OrdinalIgnoreCase))

src\Shared\CommandPathResolver.cs (1)

11private static readonly Dictionary<string, CommandMetadata> s_commandMetadata = new(StringComparer.OrdinalIgnoreCase)

src\Shared\IntegrationPackageProbeManifest.cs (12)

src\Shared\StringComparers.cs (25)

src\Shared\Telemetry\InternalMicrosoftDetector.cs (2)

1247var values = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 1497var exactNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase)

src\Shared\UserSecrets\SecretsStore.cs (4)

198return new Dictionary<string, JsonNode?>(StringComparer.OrdinalIgnoreCase); 204return new Dictionary<string, JsonNode?>(StringComparer.OrdinalIgnoreCase); 214return new Dictionary<string, JsonNode?>(StringComparer.OrdinalIgnoreCase); 222var result = new Dictionary<string, JsonNode?>(StringComparer.OrdinalIgnoreCase);

Utils\DotNetToolDetection.cs (1)

273return s_toolPackageRuntimeIdentifiers.Contains(runtimeIdentifier, StringComparer.OrdinalIgnoreCase) ||

Utils\EnvironmentChecker\DevCertsCheck.cs (1)

264.ThenBy(c => c.Thumbprint, StringComparer.OrdinalIgnoreCase);

Utils\FileSystemHelper.cs (2)

147? StringComparer.OrdinalIgnoreCase 174var isProjectFile = DotNetAppHostProject.ProjectExtensions.Contains(extension, StringComparer.OrdinalIgnoreCase);

src\Aspire.Tray\Common\TrayPanel.cs (2)

865var duplicateNames = running.GroupBy(host => host.DisplayName, StringComparer.OrdinalIgnoreCase) 866.Where(group => group.Count() > 1).Select(group => group.Key).ToHashSet(StringComparer.OrdinalIgnoreCase);

src\Aspire.Tray\Common\TraySavedState.cs (1)

104? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;

Scripts\Common\RealGitHubPRFixture.cs (1)

125var artifactNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

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

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

MockTransport.cs (2)

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

TerminalCommandTests.cs (1)

100var availableIds = string.Join(", ", instanceIds.Order(StringComparer.OrdinalIgnoreCase));

tests\Shared\CliPackageDiscovery.cs (2)

44.OrderBy(package => Path.GetFileName(package.PackagePath), StringComparer.OrdinalIgnoreCase) 103.OrderBy(name => name, StringComparer.OrdinalIgnoreCase));

Acquisition\InstallationDiscoveryDiscoverAllTests.cs (1)

734Assert.Equal(canonicalSelf, results[0].CanonicalPath, StringComparer.OrdinalIgnoreCase);

Agents\PlaywrightCliInstallerTests.cs (4)

878var selectedDirs = new HashSet<string>(StringComparer.OrdinalIgnoreCase) 975var selectedDirs = new HashSet<string>(StringComparer.OrdinalIgnoreCase) 1026var selectedDirs = new HashSet<string>(StringComparer.OrdinalIgnoreCase) 1075var selectedDirs = new HashSet<string>(StringComparer.OrdinalIgnoreCase)

Backchannel\AuxiliaryBackchannelMonitorTests.cs (1)

160StringComparer.OrdinalIgnoreCase));

Commands\AgentInitCommandTests.cs (1)

365var sorted = promptedSkillNames.OrderBy(static name => name, StringComparer.OrdinalIgnoreCase).ToList();

Commands\NewCommandTemplateConfigPersistenceTests.cs (2)

224.OrderBy(static key => key, StringComparer.OrdinalIgnoreCase) 229.OrderBy(static key => key, StringComparer.OrdinalIgnoreCase)

Commands\NewCommandTests.cs (2)

83Assert.DoesNotContain(command.Options, option => option.Aliases.Contains("--language", StringComparer.OrdinalIgnoreCase)); 1200StringComparer.OrdinalIgnoreCase);

Commands\TypeScriptAppHostToolingCheckTests.cs (1)

40commandResolver: command => requiredCommands.Contains(command, StringComparer.OrdinalIgnoreCase) ? $"/usr/bin/{command}" : null);

Mcp\ApiDocs\ApiDocsFetcherTests.cs (2)

104private readonly Dictionary<string, string> _content = new(StringComparer.OrdinalIgnoreCase); 105private readonly Dictionary<string, string?> _etags = new(StringComparer.OrdinalIgnoreCase);

Mcp\ApiDocs\ApiDocsIndexServiceTests.cs (9)

Mcp\ApiDocs\ApiMemberMarkdownParserTests.cs (2)

44new Dictionary<string, ApiReferenceItem>(StringComparer.OrdinalIgnoreCase) 92new Dictionary<string, ApiReferenceItem>(StringComparer.OrdinalIgnoreCase)

NuGet\NuGetClientTests.cs (1)

1325restoredPackages.OrderBy(package => package.Id, StringComparer.OrdinalIgnoreCase),

Projects\ExtensionGuestLauncherTests.cs (1)

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

Projects\GuestRuntimeTests.cs (3)

618OperatingSystem.IsWindows() ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal), 622OperatingSystem.IsWindows() ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal)); 1001OperatingSystem.IsWindows() ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal);

Projects\PrebuiltAppHostServerTests.cs (3)

5310var credentialSourceKeySet = credentialSourceKeys?.ToHashSet(StringComparer.OrdinalIgnoreCase) ?? []; 5311var clientCertificateSourceKeySet = clientCertificateSourceKeys?.ToHashSet(StringComparer.OrdinalIgnoreCase) ?? []; 5317.Distinct(StringComparer.OrdinalIgnoreCase)

Telemetry\AspireCliTelemetryTests.cs (1)

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

TestServices\FakeNuGetClient.cs (1)

76.Distinct(StringComparer.OrdinalIgnoreCase)

TestServices\FakePeerInstallProbe.cs (1)

23_pathComparer = OperatingSystem.IsWindows() ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;

TestServices\NuGetTestHelper.cs (1)

79.Where(source => source.IsEnabled && (!mapping.IsEnabled || keys.Contains(source.Name, StringComparer.OrdinalIgnoreCase)))

TestServices\TestAppHostProjectFactory.cs (1)

14private static readonly HashSet<string> s_projectExtensions = new(StringComparer.OrdinalIgnoreCase) { ".csproj", ".fsproj", ".vbproj" };

Components\Controls\Chart\ChartFilterTags.razor.cs (1)

89return values.OrderBy(v => v.Text, StringComparer.OrdinalIgnoreCase);

Components\Controls\ResourceDetails.razor.cs (2)

98.OrderBy(vm => vm.Source, StringComparer.OrdinalIgnoreCase); 103.OrderBy(vm => vm.Name, StringComparer.OrdinalIgnoreCase);

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

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

Model\ConnectionStringParser.cs (3)

17private static readonly Dictionary<string, int> s_schemeDefaultPorts = new(StringComparer.OrdinalIgnoreCase) 194!s_databaseUriSchemes.Contains(uri.Scheme, StringComparer.OrdinalIgnoreCase)) 511var result = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

Model\ConsoleLogsFetcher.cs (1)

70var result = new Dictionary<string, List<LogEntry>>(StringComparer.OrdinalIgnoreCase);

Model\EnvHelpers.cs (1)

22foreach (var envVar in environmentVariables.OrderBy(e => e.Key, StringComparer.OrdinalIgnoreCase))

Model\TextVisualizerFormatHelpers.cs (1)

35private static readonly Dictionary<string, (string Format, bool RequiresSqlDatabase)> s_queryFields = new(StringComparer.OrdinalIgnoreCase)

ServiceClient\DashboardDataSourcePool.cs (1)

14? StringComparer.OrdinalIgnoreCase

src\Shared\ColorGenerator.cs (2)

65_colorIndexByKey = new ConcurrentDictionary<string, Lazy<int>>(StringComparer.OrdinalIgnoreCase); 101foreach (var key in keys.OrderBy(k => k, StringComparer.OrdinalIgnoreCase))

src\Shared\StringComparers.cs (25)

src\Shared\Telemetry\InternalMicrosoftDetector.cs (2)

1247var values = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 1497var exactNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase)

Utils\MimeTypeHelpers.cs (4)

11public static readonly HashSet<string> SupportedImageTypes = new HashSet<string>(StringComparer.OrdinalIgnoreCase) 25public static readonly HashSet<string> SupportedAudioTypes = new HashSet<string>(StringComparer.OrdinalIgnoreCase) 37public static readonly HashSet<string> SupportedVideoTypes = new HashSet<string>(StringComparer.OrdinalIgnoreCase) 47public static readonly Dictionary<string, string> MimeToExtension = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)

Controls\AspireFluentDataGridTests.cs (1)

24.ThenAscending(item => item.Name, StringComparer.OrdinalIgnoreCase);

Integration\Playwright\AccessibilityTests.cs (2)

41private static readonly HashSet<string> s_failingImpacts = new(StringComparer.OrdinalIgnoreCase) { "serious", "critical" }; 46private static readonly HashSet<string> s_allowedRuleIds = new(StringComparer.OrdinalIgnoreCase);

Model\ExportHelpersTests.cs (2)

25var resourceByName = new Dictionary<string, ResourceViewModel>(StringComparer.OrdinalIgnoreCase) { [resource.Name] = resource }; 49var resourceByName = new Dictionary<string, ResourceViewModel>(StringComparer.OrdinalIgnoreCase) { [resource.Name] = resource };

Model\ResourceMenuBuilderTests.cs (9)

tests\Shared\CliPackageDiscovery.cs (2)

44.OrderBy(package => Path.GetFileName(package.PackagePath), StringComparer.OrdinalIgnoreCase) 103.OrderBy(name => name, StringComparer.OrdinalIgnoreCase));

ConnectionPropertiesExtensions.cs (1)

25var dict = new Dictionary<string, ReferenceExpression>(StringComparer.OrdinalIgnoreCase);

Dashboard\DashboardEventHandlers.cs (1)

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

Lifecycle\DotnetBuildCommandEventingSubscriber.cs (1)

72? StringComparer.OrdinalIgnoreCase

Orchestrator\ApplicationOrchestrator.cs (1)

87var connectionProperties = new Dictionary<string, string?>(StringComparer.OrdinalIgnoreCase);

Pipelines\DistributedApplicationPipeline.cs (1)

377var consumedBuildOnlyContainerNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

Publishing\PodmanContainerRuntime.cs (1)

110var grouped = new Dictionary<string, List<ComposeServicePort>>(StringComparer.OrdinalIgnoreCase);

Publishing\ResourceContainerImageManager.cs (2)

236private static readonly HashSet<string> s_containerArtifactProperties = new(StringComparer.OrdinalIgnoreCase) 719var comparer = OperatingSystem.IsWindows() ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;

ResourceBuilderExtensions.cs (2)

1066var schemeIndexTracker = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase); 1440.Intersect(candidateNames.GetPhysicalNames(), StringComparer.OrdinalIgnoreCase)

src\Shared\StringComparers.cs (25)

src\Shared\UserSecrets\SecretsStore.cs (4)

198return new Dictionary<string, JsonNode?>(StringComparer.OrdinalIgnoreCase); 204return new Dictionary<string, JsonNode?>(StringComparer.OrdinalIgnoreCase); 214return new Dictionary<string, JsonNode?>(StringComparer.OrdinalIgnoreCase); 222var result = new Dictionary<string, JsonNode?>(StringComparer.OrdinalIgnoreCase);

Utils\DotnetSdkVersionProvider.cs (3)

55new(OperatingSystem.IsWindows() ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal); 204? StringComparer.OrdinalIgnoreCase 227? StringComparer.OrdinalIgnoreCase

src\Shared\StringComparers.cs (25)

AzureBicepResource.cs (2)

120public Dictionary<string, object?> Outputs { get; } = new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase); 125public Dictionary<string, string?> SecretOutputs { get; } = new Dictionary<string, string?>(StringComparer.OrdinalIgnoreCase);

src\Shared\StringComparers.cs (25)

AzureAppServiceEnvironmentResource.cs (2)

327.Distinct(StringComparer.OrdinalIgnoreCase) 328.OrderBy(static k => k, StringComparer.OrdinalIgnoreCase)

AzureConnectorNamespaceExtensions.cs (1)

614var operationNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

EntraIdApplicationResource.cs (1)

378StringComparer.OrdinalIgnoreCase);

AzureKubernetesEnvironmentExtensions.cs (1)

126if (context.Model.Resources.Any(existing => StringComparer.OrdinalIgnoreCase.Equals(existing.Name, identity.Name)))

src\Shared\StringComparers.cs (25)

src\Shared\StringComparers.cs (25)

AzureSandboxContainerDeployment.cs (17)

AzureSandboxesExtensions.cs (1)

387var names = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

src\Shared\StringComparers.cs (25)

AzureStorageExtensions.cs (1)

105var usedIdentifiers = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { storageAccount.BicepIdentifier };

src\Shared\StringComparers.cs (25)

AzureBicepProvisionerTests.cs (4)

598new Dictionary<string, IEnumerable<string>>(StringComparer.OrdinalIgnoreCase) 670new Dictionary<string, IEnumerable<string>>(StringComparer.OrdinalIgnoreCase) 1267new Dictionary<string, IEnumerable<string>>(StringComparer.OrdinalIgnoreCase) 1383new Dictionary<string, IEnumerable<string>>(StringComparer.OrdinalIgnoreCase)

AzureConnectorNamespaceTests.cs (1)

841Assert.Equal(identifiers.Length, identifiers.Distinct(StringComparer.OrdinalIgnoreCase).Count());

AzureEnvironmentResourceExtensionsTests.cs (2)

5553private readonly Dictionary<string, IReadOnlyList<ContextSubscriptionResource>> _subscriptionsByTenant = new(StringComparer.OrdinalIgnoreCase) 5558private readonly Dictionary<string, IReadOnlyList<(string Name, string Location)>> _resourceGroupsBySubscription = new(StringComparer.OrdinalIgnoreCase)

DefaultArmClientProviderTests.cs (1)

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

ProvisioningTestHelpers.cs (1)

266_existingResourceIds = new HashSet<string>(existingResourceIds, StringComparer.OrdinalIgnoreCase);

src\Shared\StringComparers.cs (25)

AzureWebPubSubResource.cs (1)

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

BrowserLogsConfigurationManager.cs (1)

207var options = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)

ChromiumBrowserResolver.cs (2)

165var profiles = new Dictionary<string, ChromiumBrowserProfile>(StringComparer.OrdinalIgnoreCase); 205.ThenBy(static profile => profile.DirectoryName, StringComparer.OrdinalIgnoreCase)];

IBrowserHost.cs (1)

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

src\Shared\StringComparers.cs (25)

BrowserLogsBuilderExtensionsTests.cs (1)

130var knownBrowserOptionKeys = new HashSet<string>(["msedge", "chrome", "chromium"], StringComparer.OrdinalIgnoreCase);

src\Aspire.Hosting.Browsers\BrowserLogsConfigurationManager.cs (1)

207var options = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)

src\Aspire.Hosting.Browsers\ChromiumBrowserResolver.cs (2)

165var profiles = new Dictionary<string, ChromiumBrowserProfile>(StringComparer.OrdinalIgnoreCase); 205.ThenBy(static profile => profile.DirectoryName, StringComparer.OrdinalIgnoreCase)];

src\Aspire.Hosting.Browsers\IBrowserHost.cs (1)

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

src\Shared\StringComparers.cs (25)

TypeScriptApiProjector.cs (1)

456var owned = new HashSet<string>(ownedAssemblyNames, StringComparer.OrdinalIgnoreCase);

DevTunnelResourceBuilderExtensions.cs (1)

520var schemeIndexTracker = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);

src\Shared\StringComparers.cs (25)

DockerComposeServiceResource.cs (3)

61private static readonly HashSet<string> s_shellExecutables = new(StringComparer.OrdinalIgnoreCase) 278var ports = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 279var expose = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

src\Shared\StringComparers.cs (25)

DotnetProjectBuildCoordinator.cs (1)

1177var comparer = OperatingSystem.IsWindows() ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;

DotnetProjectHostingExtensions.cs (1)

209var includedEndpointNames = endpointNames.ToHashSet(StringComparer.OrdinalIgnoreCase);

DotnetProjectMetadata.cs (1)

50var comparer = OperatingSystem.IsWindows() ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;

EFCoreOperationExecutor.cs (1)

413var comparer = OperatingSystem.IsWindows() ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;

FoundryLocalService.cs (1)

145modelIds.Contains(modelId, StringComparer.OrdinalIgnoreCase);

JavaHostingExtensions.cs (1)

2171var attributes = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

src\Shared\StringComparers.cs (25)

Extensions\ResourceExtensions.cs (2)

79var processedKeys = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 113var processedKeys = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

KubernetesEnvironmentExtensions.cs (3)

142StringComparer.OrdinalIgnoreCase)) 164StringComparer.OrdinalIgnoreCase)) 168StringComparer.OrdinalIgnoreCase))

KubernetesEnvironmentResource.cs (1)

869StringComparer.OrdinalIgnoreCase);

src\Shared\StringComparers.cs (25)

Utilities\MauiEnvironmentHelper.cs (2)

37var environmentVariables = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 87foreach (var (key, value) in environmentVariables.OrderBy(kvp => kvp.Key, StringComparer.OrdinalIgnoreCase))

Utilities\ProjectFileReader.cs (2)

16private static readonly ConcurrentDictionary<string, Dictionary<string, string?>> s_projectCache = new(StringComparer.OrdinalIgnoreCase); 32var platformCache = s_projectCache.GetOrAdd(projectPath, _ => new Dictionary<string, string?>(StringComparer.OrdinalIgnoreCase));

src\Shared\StringComparers.cs (25)

ReplicaSet\MongoDBReplicaSetBuilderExtensions.cs (2)

235.Except(memberHosts.Select(m => m.Internal), StringComparer.OrdinalIgnoreCase) 614var idsByHost = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);

src\Shared\StringComparers.cs (25)

ReplicaSet\MongoDbReplicaSetFunctionalTests.cs (1)

468.ToDictionary(m => m["host"].AsString, m => m["_id"].AsInt32, StringComparer.OrdinalIgnoreCase);

src\Shared\StringComparers.cs (25)

Authoring\NativeApplication.cs (1)

47var applicationArguments = new Dictionary<string, string?>(StringComparer.OrdinalIgnoreCase);

Model\ApplicationModel.cs (1)

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

Runtime\RuntimeGeneration.cs (1)

98var previous = _resources.Values.ToDictionary(resource => resource.Declaration.Name, StringComparer.OrdinalIgnoreCase);

Runtime\WorkloadDefinition.cs (1)

60var names = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

Auxiliary\NativeAuxiliaryBackchannel.cs (2)

255var previousSnapshots = new Dictionary<string, NativeAuxiliaryResourceSnapshot>(StringComparer.OrdinalIgnoreCase); 276var current = snapshots.ToDictionary(snapshot => snapshot.Name, StringComparer.OrdinalIgnoreCase);

Rpc\NativeLanguageCatalog.cs (1)

23var ids = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

src\Shared\StringComparers.cs (25)

src\Shared\StringComparers.cs (25)

src\Shared\StringComparers.cs (25)

src\Shared\StringComparers.cs (25)

Secrets\RadiusSecretStoreNaming.cs (1)

38private static readonly HashSet<string> s_reservedDeviceNames = new(StringComparer.OrdinalIgnoreCase)

Deployment\RadCliDetectionTests.cs (1)

82Assert.DoesNotContain("push", pipelineStep.DependsOnSteps, StringComparer.OrdinalIgnoreCase);

src\Shared\StringComparers.cs (25)

AssemblyLoader.cs (3)

82var names = new SortedSet<string>(StringComparer.OrdinalIgnoreCase); 186var seen = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 248var assemblyNames = new SortedSet<string>(StringComparer.OrdinalIgnoreCase);

AtsContextFilter.cs (4)

49new HashSet<string>(StringComparer.OrdinalIgnoreCase)); 101StringComparer.OrdinalIgnoreCase); 191var normalizedAssemblyNames = new HashSet<string>(assemblyNames.Where(static name => !string.IsNullOrWhiteSpace(name)), StringComparer.OrdinalIgnoreCase); 544var knownAssemblyNames = new HashSet<string>(assemblyNames, StringComparer.OrdinalIgnoreCase);

CodeGeneration\CodeGenerationService.cs (2)

454.OrderBy(language => language, StringComparer.OrdinalIgnoreCase) 463.OrderBy(s => s, StringComparer.OrdinalIgnoreCase)

CodeGeneration\CodeGeneratorResolver.cs (2)

105var generators = new Dictionary<string, ICodeGenerator>(StringComparer.OrdinalIgnoreCase); 155var exporters = new Dictionary<string, IApiReferenceExporter>(StringComparer.OrdinalIgnoreCase);

Diagnostics\RemoteHostProfilingTelemetry.cs (2)

525.Distinct(StringComparer.OrdinalIgnoreCase) 526.Order(StringComparer.OrdinalIgnoreCase)];

Language\LanguageService.cs (1)

193.OrderBy(s => s, StringComparer.OrdinalIgnoreCase)

Language\LanguageSupportResolver.cs (1)

63var languages = new Dictionary<string, ILanguageSupport>(StringComparer.OrdinalIgnoreCase);

src\Shared\CommandPathResolver.cs (1)

11private static readonly Dictionary<string, CommandMetadata> s_commandMetadata = new(StringComparer.OrdinalIgnoreCase)

src\Shared\IntegrationPackageProbeManifest.cs (12)

src\Shared\StringComparers.cs (25)

CommandPathResolver.cs (1)

22var seenPaths = new HashSet<string>(IsWindows() ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal);

ResolveAspireCliBundle.cs (2)

382.ThenByDescending(Path.GetFileName, StringComparer.OrdinalIgnoreCase)) 505return IsWindows() ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;

ConnectionPropertiesExtensionsTests.cs (1)

26var dict = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

Utils\StringComparersTests.cs (2)

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

Utils\MockUserSecretsManager.cs (1)

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

ConfigurationBuilder\YarpCluster.cs (1)

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

ConfigurationBuilder\YarpRoute.cs (2)

204var transform = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 224var copiedTransform = new Dictionary<string, string>(transform, StringComparer.OrdinalIgnoreCase);

YarpConfigGeneratorTests.cs (2)

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

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

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

Infrastructure\DistributedApplicationExtensions.cs (1)

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

src\Vendoring\OpenTelemetry.Instrumentation.StackExchangeRedis\Shared\DatabaseSemanticConventionHelper.cs (1)

176values = new HashSet<string>(stringValues, StringComparer.OrdinalIgnoreCase);

TrxReader.cs (1)

61.ToDictionary(static testDefinition => testDefinition.Id!, StringComparer.OrdinalIgnoreCase);

src\Aspire.Tray\Common\TrayPanel.cs (2)

865var duplicateNames = running.GroupBy(host => host.DisplayName, StringComparer.OrdinalIgnoreCase) 866.Where(group => group.Count() > 1).Select(group => group.Key).ToHashSet(StringComparer.OrdinalIgnoreCase);

src\Aspire.Tray\Common\TraySavedState.cs (1)

104? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;

ApiReferenceExportOptions.cs (1)

19/// assembly simple names using <see cref="StringComparer.OrdinalIgnoreCase"/>.

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

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

Crossgen2RootCommand.cs (1)

351foreach (var instructionSet in Internal.JitInterface.InstructionSetFlags.ArchitectureToValidInstructionSets(targetArch).DistinctBy((instructionSet) => instructionSet.Name, StringComparer.OrdinalIgnoreCase))

parent\parent\Common\CommandLineHelpers.cs (2)

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

Program.cs (1)

305var singleCompilationInputFilePaths = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

PrepareForReadyToRunCompilation.cs (3)

145var exclusionSet = ExcludeList == null || Crossgen2Composite ? null : new HashSet<string>(ExcludeList, StringComparer.OrdinalIgnoreCase); 146var compositeExclusionSet = PublishReadyToRunCompositeExclusions == null || !Crossgen2Composite ? null : new HashSet<string>(PublishReadyToRunCompositeExclusions, StringComparer.OrdinalIgnoreCase); 147var compositeRootSet = PublishReadyToRunCompositeRoots == null || !Crossgen2Composite ? null : new HashSet<string>(PublishReadyToRunCompositeRoots, StringComparer.OrdinalIgnoreCase);

src\roslyn\src\Compilers\Shared\BuildServerConnection.cs (1)

491foreach (var kvp in environmentVariables.OrderBy(kvp => kvp.Key, StringComparer.OrdinalIgnoreCase))

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

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

Grammar\GrammarGenerator.cs (1)

383public int CompareTo(Production other) => StringComparer.OrdinalIgnoreCase.Compare(this.Text, other.Text);

parent\dotnet\CliSchema.cs (2)

145foreach (var option in options.OrderBy(o => o.Name, StringComparer.OrdinalIgnoreCase)) 159foreach (var subcommand in subcommands.OrderBy(c => c.Name, StringComparer.OrdinalIgnoreCase))

parent\dotnet\CommandFactory\CommandFactoryUsingResolver.cs (1)

85if (_knownCommandsAvailableAsDotNetTool.Contains(commandName, StringComparer.OrdinalIgnoreCase))

parent\dotnet\CommandFactory\CommandResolution\DotnetToolsCommandResolver.cs (1)

12private static readonly IReadOnlyDictionary<string, string> AggregateToolPackages = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)

parent\dotnet\Commands\Run\AotRunCommand.cs (1)

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

parent\dotnet\Commands\Run\CommonRunHelpers.cs (2)

45=> new(VirtualProjectBuilder.GetGlobalBuildProperties(), StringComparer.OrdinalIgnoreCase) 109var globalProperties = msbuildArgs.GlobalProperties?.ToDictionary() ?? new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

parent\dotnet\Commands\Run\RunFileBuildCacheEntry.cs (1)

17private static StringComparer GlobalPropertiesComparer => StringComparer.OrdinalIgnoreCase;

parent\dotnet\Commands\Test\MTP\MicrosoftTestingPlatformTestCommand.cs (1)

1031var propertyNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

parent\dotnet\Commands\Test\MTP\MicrosoftTestingPlatformTestCommand.Help.cs (1)

134var commandOptionNames = commandOptions.Select(o => o.Name.TrimStart('-')).ToHashSet(StringComparer.OrdinalIgnoreCase);

parent\dotnet\Commands\Test\MTP\Terminal\FileUtilities.cs (1)

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

parent\dotnet\Commands\Test\MTP\TestResultsDirectoryResolver.cs (2)

70Dictionary<string, HashSet<string>> identitiesByProjectName = new(StringComparer.OrdinalIgnoreCase); 83HashSet<string> ambiguousProjectNames = new(StringComparer.OrdinalIgnoreCase);

parent\dotnet\Commands\Workload\WorkloadInfoHelper.cs (1)

203var manifestInfoDict = WorkloadResolver.GetInstalledManifests().ToDictionary(info => info.Id, StringComparer.OrdinalIgnoreCase);

parent\dotnet\NugetPackageDownloader\FirstPartyNuGetPackageSigningVerifier.cs (2)

40new(StringComparer.OrdinalIgnoreCase) 54new(StringComparer.OrdinalIgnoreCase)

parent\dotnet\NugetPackageDownloader\NuGetPackageDownloader.cs (1)

445allowListNuspec.Contains(Path.GetFileName(f), comparer: StringComparer.OrdinalIgnoreCase)))

parent\dotnet\Telemetry\TelemetryCommonProperties.cs (1)

81}.ToFrozenDictionary(StringComparer.OrdinalIgnoreCase);

parent\dotnet\ToolPackage\RestoredCommandIdentifier.cs (1)

50StringComparer.OrdinalIgnoreCase.GetHashCode(RuntimeIdentifier));

Analyzers\AnalyzerOptionExtensions.cs (1)

172var comparer = StringComparer.OrdinalIgnoreCase;

Analyzers\AnalyzerReferenceInformationProvider.cs (2)

14private static readonly Dictionary<string, Assembly> s_pathsToAssemblies = new(StringComparer.OrdinalIgnoreCase); 15private static readonly Dictionary<string, Assembly> s_namesToAssemblies = new(StringComparer.OrdinalIgnoreCase);

Utilities\EditorConfigFinder.cs (1)

13var visitedDirectories = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

Sgen.cs (1)

27private static readonly Dictionary<string, string> s_referencedic = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

Commands\BaseCommand.cs (1)

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

Bootstrapper\SvcutilBootstrapper.cs (1)

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

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

58_files = new Hashtable(StringComparer.OrdinalIgnoreCase);

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

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

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

2744importList = new SortedList(StringComparer.OrdinalIgnoreCase);

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

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

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

487: base(StringComparer.OrdinalIgnoreCase)

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

73s_dnsComparer = new ClaimComparer(StringComparer.OrdinalIgnoreCase);

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

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

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

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

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

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

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

418return StringComparer.OrdinalIgnoreCase.GetHashCode(uriString);

Metadata\MetadataFileNameManager.cs (3)

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

Shared\MSBuildProj.cs (1)

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

Shared\Options\OptionBase.cs (2)

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

Shared\Options\OptionValueParser.cs (1)

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

Shared\ProjectPropertyResolver.cs (2)

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

Shared\Utilities\RuntimeEnvironmentHelper.cs (1)

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

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\BindingExtensions.g.cs (1)

44private readonly static Lazy<global::System.Collections.Generic.HashSet<string>> s_configKeys_Microsoft__AspNetCore__Authentication__JwtBearer__Tools__SigningKey = new(() => new global::System.Collections.Generic.HashSet<string>(StringComparer.OrdinalIgnoreCase) { "Id", "Issuer", "Value", "Length" });

Internal\SecretsStore.cs (1)

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

Program.cs (1)

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

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

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

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

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

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

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

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

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

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

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

src\roslyn\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\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyComparer.cs (1)

35? StringComparer.OrdinalIgnoreCase

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

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

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

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

ComponentManifest.cs (1)

108var packages = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

Program.cs (3)

132var builtIds = builtPackages.Select(package => package[..package.LastIndexOf('/')]).ToHashSet(StringComparer.OrdinalIgnoreCase); 161.Distinct(StringComparer.OrdinalIgnoreCase); 173builtIds.Order(StringComparer.OrdinalIgnoreCase).Select(id => new XElement("package", new XAttribute("pattern", id)))));

TemplateRestorePlan.cs (3)

135var documents = new Dictionary<string, XElement>(StringComparer.OrdinalIgnoreCase); 178var resolved = new Dictionary<string, RestoreProject>(StringComparer.OrdinalIgnoreCase); 179var visiting = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

NativeCommandLine.cs (1)

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

EntityRegistry.cs (1)

20private readonly Dictionary<string, AssemblyReferenceEntity> _seenAssemblyRefs = new(StringComparer.OrdinalIgnoreCase);

ConfigurablePInvokePolicy.cs (1)

22_directPInvokes = new Dictionary<string, HashSet<string>>(target.IsWindows ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal);

ILCompilerRootCommand.cs (1)

367foreach (var instructionSet in Internal.JitInterface.InstructionSetFlags.ArchitectureToValidInstructionSets(targetArch).DistinctBy((instructionSet) => instructionSet.Name, StringComparer.OrdinalIgnoreCase))

parent\parent\Common\CommandLineHelpers.cs (2)

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

Program.cs (1)

149if (StringComparer.OrdinalIgnoreCase.Equals(guard, "cf"))

Compiler\Logger.cs (4)

34private readonly HashSet<string> _trimWarnedAssemblies = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 35private readonly HashSet<string> _aotWarnedAssemblies = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 63_singleWarnEnabledAssemblies = new HashSet<string>(singleWarnEnabledModules, StringComparer.OrdinalIgnoreCase); 64_singleWarnDisabledAssemblies = new HashSet<string>(singleWarnDisabledModules, StringComparer.OrdinalIgnoreCase);

Compiler\SourceLinkWriter.cs (1)

28_generatedSourceMappings = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

parent\parent\Common\Compiler\CompilerTypeSystemContext.cs (1)

62private StringComparer _comparer = StringComparer.OrdinalIgnoreCase;

parent\parent\Common\Compiler\NativeAotNameMangler.cs (2)

132private Dictionary<string, Utf8String> _mangledAssemblyNames = new Dictionary<string, Utf8String>(StringComparer.OrdinalIgnoreCase); 218var assemblySet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

PerfMapWriter.cs (1)

77IEnumerable<AssemblyInfo> orderedInputs = inputAssemblies.OrderBy(asm => asm.Name, StringComparer.OrdinalIgnoreCase);

parent\parent\Common\Compiler\CompilerTypeSystemContext.cs (1)

62private StringComparer _comparer = StringComparer.OrdinalIgnoreCase;

parent\parent\Common\Compiler\NativeAotNameMangler.cs (2)

132private Dictionary<string, Utf8String> _mangledAssemblyNames = new Dictionary<string, Utf8String>(StringComparer.OrdinalIgnoreCase); 218var assemblySet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

parent\parent\Common\JitInterface\JitConfigProvider.cs (1)

45private Dictionary<string, string> _config = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

parent\parent\Common\JitInterface\JitConfigProvider.cs (1)

45private Dictionary<string, string> _config = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

Linker\AssemblyResolver.cs (1)

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

ILLinkCache.cs (1)

299var paths = new HashSet<string>(RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal);

LinkTask.cs (1)

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

ConditionalWcfTest.cs (1)

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

JsonSerializer.cs (1)

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

TestProperties.cs (1)

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

TemplateManifest\ComponentManifestTests.cs (2)

15var manifest = new ComponentManifest(new HashSet<string>(StringComparer.OrdinalIgnoreCase) 32var manifest = new ComponentManifest(new HashSet<string>(StringComparer.OrdinalIgnoreCase)

TestTriggerMap\GraphAffectedProjectsTests.cs (1)

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

TestTriggerMap\TestTriggerMapTests.cs (1)

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

FileUtilities.cs (1)

16StringComparer.OrdinalIgnoreCase);

GenerateFileVersionProps.cs (1)

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

GenerateTestSharedFrameworkDepsFile.cs (1)

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

Internal\DefaultAntiforgeryTokenGenerator.cs (1)

162var comparer = StringComparer.OrdinalIgnoreCase;

Http\HeaderDictionaryIndexerAnalyzer.cs (1)

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

Mvc\DetectAmbiguousActionRoutes.cs (1)

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

RouteEmbeddedLanguage\FrameworkParametersCompletionProvider.cs (1)

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

RouteEmbeddedLanguage\Infrastructure\EmbeddedLanguageCommentOptions.cs (1)

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

RouteEmbeddedLanguage\RoutePatternAnalyzer.cs (1)

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

AuthorizationOptions.cs (1)

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

PersistentState\PersistentServicesRegistry.cs (1)

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

Reflection\ComponentProperties.cs (3)

133unmatched ??= new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase); 154unmatched ??= new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase); 294_underlyingWriters = new Dictionary<string, PropertySetter>(StringComparer.OrdinalIgnoreCase);

RenderTree\Renderer.cs (1)

46private 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\aspnetcore\src\Http\Routing\src\Patterns\RoutePatternFactory.cs (3)

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

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

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

src\aspnetcore\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\aspnetcore\src\Http\Routing\src\RouteOptions.cs (1)

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

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

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

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

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

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

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

VirtualizeSpacerElementAnalyzer.cs (2)

27new Dictionary<string, ImmutableArray<string>>(StringComparer.OrdinalIgnoreCase) 34}.ToImmutableDictionary(StringComparer.OrdinalIgnoreCase);

Discovery\PageComponentBuilder.cs (1)

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

SessionCascadingValueSupplier.cs (1)

20private readonly Dictionary<string, Func<object?>> _valueCallbacks = new(StringComparer.OrdinalIgnoreCase);

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

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

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

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

TempData\TempData.cs (2)

12private readonly Dictionary<string, object?> _data = new(StringComparer.OrdinalIgnoreCase); 13private readonly HashSet<string> _retainedKeys = new(StringComparer.OrdinalIgnoreCase);

TempData\TempDataCascadingValueSupplier.cs (1)

18private readonly Dictionary<string, Func<object?>> _valueCallbacks = new(StringComparer.OrdinalIgnoreCase);

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

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

Infrastructure\ServerInstance.cs (1)

217var environment = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)

HtmlRendering\StaticHtmlRenderer.HtmlWriting.cs (1)

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

JSComponents\JSComponentInterop.cs (1)

219ParameterInfoByName = new(StringComparer.OrdinalIgnoreCase);

Hosting\WebAssemblyHostConfiguration.cs (1)

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

Prerendering\WebAssemblyComponentParameterDeserializer.cs (1)

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

FileExtensionContentTypeProvider.cs (1)

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

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

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

Logging\LoggingRedactionOptions.cs (4)

58public IDictionary<string, DataClassification> RouteParameterDataClasses { get; set; } = new Dictionary<string, DataClassification>(StringComparer.OrdinalIgnoreCase); 67public IDictionary<string, DataClassification> RequestHeadersDataClasses { get; set; } = new Dictionary<string, DataClassification>(StringComparer.OrdinalIgnoreCase); 76public IDictionary<string, DataClassification> ResponseHeadersDataClasses { get; set; } = new Dictionary<string, DataClassification>(StringComparer.OrdinalIgnoreCase); 94public ISet<string> ExcludePathStartsWith { get; set; } = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

Logging\RequestHeadersLogEnricherOptions.cs (1)

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

Internal\GrpcProtocolConstants.cs (1)

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

HeaderParsingOptions.cs (2)

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

HeaderPropagationMiddleware.cs (1)

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

Internal\HostingTelemetryHelpers.cs (1)

163], StringComparer.OrdinalIgnoreCase);

Internal\WebHostOptions.cs (1)

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

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

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

WebHostBuilder.cs (1)

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

Features\QueryFeature.cs (3)

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

HeaderDictionary.cs (1)

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

Internal\RequestCookieCollection.cs (2)

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

QueryCollection.cs (1)

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

Timeouts\RequestTimeoutOptions.cs (1)

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

HostString.cs (1)

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

HttpMethods.cs (1)

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

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

Routing\RouteValueDictionary.cs (3)

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

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

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

Internal\HttpConnectionDispatcher.cs (1)

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

RequestDelegateFactory.cs (2)

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

src\aspnetcore\src\Shared\ParameterBindingMethodCache.cs (1)

709return StringComparer.OrdinalIgnoreCase.GetHashCode(Name);

StaticRouteHandlerModel\Model\ParameterLookupKey.cs (1)

23return StringComparer.OrdinalIgnoreCase.GetHashCode(Name);

HttpLoggingOptions.cs (2)

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

W3CLoggerOptions.cs (1)

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

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\GeneratedRouteBuilderExtensions.g.cs (1)

2379return routeParameterNames?.Contains(parameterName, StringComparer.OrdinalIgnoreCase) == true

Tracing\CollectingEventListener.cs (1)

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

Abstractions\ActionDescriptor.cs (1)

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

src\aspnetcore\src\Shared\ParameterBindingMethodCache.cs (1)

709return StringComparer.OrdinalIgnoreCase.GetHashCode(Name);

DefaultApiDescriptionProvider.cs (1)

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

ApplicationModels\ActionModel.cs (2)

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

ApplicationModels\ApplicationModelFactory.cs (3)

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

ApplicationModels\AttributeRouteModel.cs (1)

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

ApplicationModels\ControllerActionDescriptorProvider.cs (1)

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

ApplicationModels\ControllerModel.cs (2)

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

ApplicationModels\DefaultApplicationModelProvider.cs (1)

668.Distinct(StringComparer.OrdinalIgnoreCase)

Formatters\FormatterMappings.cs (1)

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

Infrastructure\ActionSelectionTable.cs (1)

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

Infrastructure\ControllerActionInvoker.cs (1)

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

Infrastructure\StringArrayComparer.cs (1)

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

ModelBinding\CompositeValueProvider.cs (1)

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

ModelBinding\FormValueProvider.cs (1)

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

ModelBinding\JQueryFormValueProvider.cs (1)

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

ModelBinding\JQueryKeyValuePairNormalizer.cs (1)

22StringComparer.OrdinalIgnoreCase);

ModelBinding\PrefixContainer.cs (2)

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

MvcOptions.cs (1)

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

Routing\AttributeRoute.cs (2)

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

Routing\ControllerActionEndpointDataSource.cs (2)

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

Routing\KnownRouteValueConstraint.cs (1)

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

SerializableError.cs (1)

20: base(StringComparer.OrdinalIgnoreCase)

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

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

BsonTempDataSerializer.cs (2)

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

ApplicationParts\RazorCompiledItemFeatureProvider.cs (1)

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

Compilation\DefaultViewCompiler.cs (1)

54StringComparer.OrdinalIgnoreCase);

RazorPage.cs (4)

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

RazorPageBase.cs (1)

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

TagHelpers\UrlResolutionTagHelper.cs (1)

58new(StringComparer.OrdinalIgnoreCase)

RuntimeViewCompiler.cs (1)

65StringComparer.OrdinalIgnoreCase);

ApplicationModels\CompiledPageRouteModelProvider.cs (1)

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

ApplicationModels\PageRouteModel.cs (2)

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

Infrastructure\DefaultPageLoader.cs (1)

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

Infrastructure\PageActionEndpointDataSource.cs (1)

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

Infrastructure\PageActionInvoker.cs (1)

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

AnchorTagHelper.cs (1)

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

ComponentTagHelper.cs (1)

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

FormActionTagHelper.cs (1)

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

FormTagHelper.cs (1)

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

InputTagHelper.cs (4)

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

OptionTagHelper.cs (1)

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

SelectTagHelper.cs (1)

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

TextAreaTagHelper.cs (1)

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

ValidationMessageTagHelper.cs (1)

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

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)

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

DefaultHtmlGenerator.cs (1)

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

HtmlHelper.cs (2)

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

Rendering\MultiSelectList.cs (1)

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

SessionStateTempDataProvider.cs (1)

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

TempDataDictionary.cs (4)

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

TemplateRenderer.cs (2)

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

ViewComponents\DefaultViewComponentHelper.cs (1)

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

ViewDataDictionary.cs (2)

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

Extensions\OpenApiEndpointRouteBuilderExtensions.cs (1)

39if (documentNames is null || !documentNames.Contains(documentName, StringComparer.OrdinalIgnoreCase))

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\GeneratedRouteBuilderExtensions.g.cs (1)

236return routeParameterNames?.Contains(parameterName, StringComparer.OrdinalIgnoreCase) == true

Services\OpenApiDocumentService.cs (1)

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

src\aspnetcore\src\Shared\ParameterBindingMethodCache.cs (1)

709return StringComparer.OrdinalIgnoreCase.GetHashCode(Name);

OutputCacheEntryFormatter.cs (2)

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

OutputCacheKeyProvider.cs (2)

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

OutputCacheOptions.cs (2)

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

src\roslyn\src\Razor\src\Shared\Microsoft.AspNetCore.Razor.SharedUtilities\PathUtilities.cs (1)

19? StringComparer.OrdinalIgnoreCase

src\roslyn\src\Razor\src\Shared\Microsoft.AspNetCore.Razor.SharedUtilities\PooledObjects\PooledHashSet`1.cs (2)

73!ReferenceEquals(comparer, StringComparer.OrdinalIgnoreCase)) 272if (ReferenceEquals(comparer, StringComparer.OrdinalIgnoreCase))

src\roslyn\src\Razor\src\Shared\Microsoft.AspNetCore.Razor.SharedUtilities\PooledObjects\SpecializedPools.StringDictionary`1.cs (1)

22public static readonly DictionaryPool<string, TValue> OrdinalIgnoreCase = DictionaryPool<string, TValue>.Create(StringComparer.OrdinalIgnoreCase);

src\roslyn\src\Razor\src\Shared\Microsoft.AspNetCore.Razor.SharedUtilities\PooledObjects\SpecializedPools.StringHashSet.cs (1)

22public static readonly HashSetPool<string> OrdinalIgnoreCase = HashSetPool<string>.Create(StringComparer.OrdinalIgnoreCase);

RequestDecompressionOptions.cs (1)

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

ResponseCachingKeyProvider.cs (1)

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

ResponseCompressionProvider.cs (3)

63_mimeTypes = new HashSet<string>(mimeTypes, StringComparer.OrdinalIgnoreCase); 67StringComparer.OrdinalIgnoreCase 291return StringComparer.OrdinalIgnoreCase.GetHashCode(EncodingName);

ApacheModRewrite\FlagParser.cs (1)

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

Constraints\HttpMethodRouteConstraint.cs (2)

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

DecisionTree\DecisionTreeBuilder.cs (3)

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

DefaultLinkParser.cs (1)

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

Matching\AcceptsMatcherPolicy.cs (1)

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

Matching\ContentEncodingNegotiationMatcherPolicy.cs (1)

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

Matching\DfaMatcherBuilder.cs (1)

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

Matching\DfaNode.cs (1)

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

Matching\DictionaryJumpTable.cs (1)

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

Matching\HostMatcherPolicy.cs (1)

483hash.Add(Host, StringComparer.OrdinalIgnoreCase);

Matching\HttpMethodDestinationsLookup.cs (1)

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

Matching\HttpMethodMatcherPolicy.cs (3)

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

Matching\NegotiationMatcherPolicy.cs (1)

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

Patterns\RoutePatternFactory.cs (6)

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

Patterns\RoutePatternParser.cs (1)

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

RouteCollection.cs (1)

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

RouteConstraintBuilder.cs (3)

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

RouteOptions.cs (1)

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

RouteValueEqualityComparer.cs (2)

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

RouteValuesAddressScheme.cs (2)

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

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

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

Tree\LinkGenerationDecisionTree.cs (1)

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

Tree\TreeRouter.cs (1)

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

Tree\UrlMatchingNode.cs (1)

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

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

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

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

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

src\aspnetcore\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\aspnetcore\src\Shared\HttpSys\RequestProcessing\RequestHeaders.cs (1)

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

UrlPrefix.cs (1)

200return StringComparer.OrdinalIgnoreCase.GetHashCode(FullPrefix);

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

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

src\aspnetcore\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\aspnetcore\src\Shared\HttpSys\RequestProcessing\RequestHeaders.cs (1)

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

Internal\ConfigurationReader.cs (2)

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

Internal\Http\HttpHeaders.cs (2)

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

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

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

Internal\SniOptionsSelector.cs (1)

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

KestrelConfigurationLoader.cs (1)

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

Internal\DefaultHubDispatcher.cs (1)

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

Internal\DefaultHubProtocolResolver.cs (2)

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

RedisHubLifetimeManager.cs (1)

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

Proxying\SpaProxy.cs (3)

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

FileExtensionContentTypeProvider.cs (1)

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

src\sdk\src\Dotnet.Watch\Web.Middleware\BrowserToolsForwarder.cs (1)

24private static readonly HashSet<string> s_hopByHopHeaders = new(StringComparer.OrdinalIgnoreCase)

KeyValueAccumulator.cs (3)

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

QueryHelpers.cs (2)

122/// case-insensitive (<see cref="StringComparer.OrdinalIgnoreCase"/>) key comparer so keys can be accessed 131return new Dictionary<string, StringValues>(0, StringComparer.OrdinalIgnoreCase);

BackEnd\BuildManager\BuildParameters.cs (5)

300_propertiesFromCommandLine = other._propertiesFromCommandLine != null ? new HashSet<string>(other._propertiesFromCommandLine, StringComparer.OrdinalIgnoreCase) : null; 324WarningsAsErrors = other.WarningsAsErrors == null ? null : new HashSet<string>(other.WarningsAsErrors, StringComparer.OrdinalIgnoreCase); 325WarningsNotAsErrors = other.WarningsNotAsErrors == null ? null : new HashSet<string>(other.WarningsNotAsErrors, StringComparer.OrdinalIgnoreCase); 326WarningsAsMessages = other.WarningsAsMessages == null ? null : new HashSet<string>(other.WarningsAsMessages, StringComparer.OrdinalIgnoreCase); 989translator.TranslateDictionary(ref _buildProcessEnvironment, StringComparer.OrdinalIgnoreCase);

BackEnd\BuildManager\RequestedProjectState.cs (1)

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

BackEnd\Components\Communications\NodeProviderOutOfProcBase.cs (1)

1356: new Dictionary<string, string>(globalParameters, StringComparer.OrdinalIgnoreCase);

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

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

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

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

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

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

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

39private static readonly HashSet<string> s_projectSpecificPropertyNames = new(StringComparer.OrdinalIgnoreCase) { "TargetFramework", "Configuration", "Platform", "TargetPlatform", "OutputType" }; 189var pluginSettings = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 396Dictionary<string, string> globalProperties = new(configuration.GlobalProperties.Count, StringComparer.OrdinalIgnoreCase); 728var globalProperties = new Dictionary<string, string>(configuration.GlobalProperties.Count, StringComparer.OrdinalIgnoreCase); 795var globalProperties = new Dictionary<string, string>(templateGlobalProperties, StringComparer.OrdinalIgnoreCase)

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

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

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

561HashSet<string> excludesUnescapedForComparison = new HashSet<string>(excludes.Count, StringComparer.OrdinalIgnoreCase); 600HashSet<string> specificationsToFind = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

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

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

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

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

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

1473args.WarningsAsErrors = loggingService.GetWarningsAsErrors(projectBuildEventContext).ToHashSet(StringComparer.OrdinalIgnoreCase); 1474args.WarningsAsMessages = loggingService.GetWarningsAsMessages(projectBuildEventContext).ToHashSet(StringComparer.OrdinalIgnoreCase); 1475args.WarningsNotAsErrors = loggingService.GetWarningsNotAsErrors(projectBuildEventContext).ToHashSet(StringComparer.OrdinalIgnoreCase); 1601.Select(w => w.Trim()), StringComparer.OrdinalIgnoreCase);

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

562(_legacyCallTargetFailuresToIgnore ??= new HashSet<string>(StringComparer.OrdinalIgnoreCase))

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

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

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

1029targetOutputsPerProject.Add(new Dictionary<string, ITaskItem[]>(StringComparer.OrdinalIgnoreCase)); 1207new Dictionary<string, ITaskItem[]>(StringComparer.OrdinalIgnoreCase) 1269targetOutputsPerProject?.Add(new Dictionary<string, ITaskItem[]>(StringComparer.OrdinalIgnoreCase));

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

2367HashSet<string> requestTargetsSet = new(request.Targets, StringComparer.OrdinalIgnoreCase);

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

90translator.TranslateDictionary(ref _propertiesToAdd, count => new Dictionary<string, string>(count, StringComparer.OrdinalIgnoreCase)); 94dictionaryCreator: count => new Dictionary<string, SdkResultItem>(count, StringComparer.OrdinalIgnoreCase)); 95translator.TranslateDictionary(ref _environmentVariablesToAdd, count => new Dictionary<string, string>(count, StringComparer.OrdinalIgnoreCase)); 111StringComparer.OrdinalIgnoreCase.Equals(_path, result._path) && 112StringComparer.OrdinalIgnoreCase.Equals(_version, result._version) && 175hashCode = (hashCode * -1521134295) + StringComparer.OrdinalIgnoreCase.GetHashCode(_path); 176hashCode = (hashCode * -1521134295) + StringComparer.OrdinalIgnoreCase.GetHashCode(_version); 183hashCode = (hashCode * -1521134295) + StringComparer.OrdinalIgnoreCase.GetHashCode(additionalPath);

BackEnd\Node\ServerNodeBuildCommand.cs (1)

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

BackEnd\Shared\BuildRequestConfiguration.cs (3)

699new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase)); 993return StringComparer.OrdinalIgnoreCase.GetHashCode(_projectFullPath) ^ StringComparer.OrdinalIgnoreCase.GetHashCode(_toolsVersion);

BackEnd\Shared\BuildResult.cs (2)

813_resultsByTarget = new ConcurrentDictionary<string, TargetResult>(_resultsByTarget, StringComparer.OrdinalIgnoreCase), 835return new ConcurrentDictionary<string, TargetResult>(1, capacity, StringComparer.OrdinalIgnoreCase);

BackEnd\Shared\ConfigurationMetadata.cs (2)

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

BackEnd\TaskExecutionHost\TaskExecutionHost.cs (2)

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

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

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

Construction\ProjectTaskElement.cs (2)

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

Construction\Solution\ProjectInSolution.cs (2)

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

Construction\Solution\SolutionFile.cs (8)

132: StringComparer.OrdinalIgnoreCase; 353_projectsByGuid = new Dictionary<string, ProjectInSolution>(StringComparer.OrdinalIgnoreCase); 354_solutionFoldersByGuid = new Dictionary<string, ProjectInSolution>(StringComparer.OrdinalIgnoreCase); 765_projectsByGuid = new Dictionary<string, ProjectInSolution>(StringComparer.OrdinalIgnoreCase); 766_solutionFoldersByGuid = new Dictionary<string, ProjectInSolution>(StringComparer.OrdinalIgnoreCase); 826var projectsByUniqueName = new Dictionary<string, ProjectInSolution>(StringComparer.OrdinalIgnoreCase); 827var projectsByOriginalName = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 1749var rawProjectConfigurationsEntries = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

Construction\Solution\SolutionProjectGenerator.cs (3)

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

Definition\Project.cs (2)

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

Definition\ProjectCollection.cs (4)

129private readonly ConcurrentDictionary<string, LockType> _loadProjectLocks = new(StringComparer.OrdinalIgnoreCase); 1955_toolsets = new Dictionary<string, Toolset>(StringComparer.OrdinalIgnoreCase); 2006private Dictionary<string, List<Project>> _loadedProjects = new Dictionary<string, List<Project>>(StringComparer.OrdinalIgnoreCase); 2166_loadedProjects = new Dictionary<string, List<Project>>(StringComparer.OrdinalIgnoreCase);

Definition\Toolset.cs (3)

507translator.TranslateDictionary(ref _subToolsets, StringComparer.OrdinalIgnoreCase, SubToolset.FactoryForDeserialization); 510translator.TranslateDictionary(ref _propertySearchPathsTable, StringComparer.OrdinalIgnoreCase, ProjectImportPathMatch.FactoryForDeserialization); 620Array.Sort<string>(defaultTasksFiles, StringComparer.OrdinalIgnoreCase);

Definition\ToolsetConfigurationReader.cs (1)

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

Definition\ToolsetReader.cs (1)

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

ElementLocation\ElementLocation.cs (5)

112&& StringComparer.OrdinalIgnoreCase.Equals(File, other.File); 314FileOnly other => StringComparer.OrdinalIgnoreCase.Equals(File, other.File), 319ElementLocation { Line: 0, Column: 0 } other => StringComparer.OrdinalIgnoreCase.Equals(File, other.File), 363&& StringComparer.OrdinalIgnoreCase.Equals(_file, other._file), 413&& StringComparer.OrdinalIgnoreCase.Equals(_file, other._file),

Evaluation\Evaluator.cs (6)

281_importsSeen = new Dictionary<string, ProjectImportElement>(StringComparer.OrdinalIgnoreCase); 904Dictionary<string, List<TargetSpecification>> targetsWhichRunBeforeByTarget = new Dictionary<string, List<TargetSpecification>>(StringComparer.OrdinalIgnoreCase); 905Dictionary<string, List<TargetSpecification>> targetsWhichRunAfterByTarget = new Dictionary<string, List<TargetSpecification>>(StringComparer.OrdinalIgnoreCase); 907Dictionary<string, LinkedListNode<ProjectTargetElement>> activeTargets = new Dictionary<string, LinkedListNode<ProjectTargetElement>>(StringComparer.OrdinalIgnoreCase); 2141escapedMetadata = new Dictionary<string, string>(item.Value.Metadata.Count, StringComparer.OrdinalIgnoreCase); 2847StringComparer.OrdinalIgnoreCase);

Evaluation\Expander.ItemExpander.cs (2)

67private static readonly FrozenDictionary<string, TransformKind> s_intrinsicTransforms = new Dictionary<string, TransformKind>(StringComparer.OrdinalIgnoreCase) 85}.ToFrozenDictionary(StringComparer.OrdinalIgnoreCase);

Evaluation\Expander.ItemExpander.Transforms.cs (4)

69}.ToFrozenDictionary(StringComparer.OrdinalIgnoreCase); 246SortedSet<string> directories = new SortedSet<string>(StringComparer.OrdinalIgnoreCase); 328Dictionary<string, string> directoryNameTable = new Dictionary<string, string>(input.Count, StringComparer.OrdinalIgnoreCase); 471=> DistinctWithComparer(input, output, arguments, StringComparer.OrdinalIgnoreCase, functionName, elementLocation);

Evaluation\ItemSpec.cs (1)

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

Evaluation\LazyItemEvaluator.cs (3)

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

Evaluation\LazyItemEvaluator.LazyItemOperation.cs (1)

126Assumed.Equal(capturedItems.Comparer, StringComparer.OrdinalIgnoreCase, "MSBuild assumes case insensitive item name comparison");

Evaluation\LazyItemEvaluator.OrderedItemDataCollection.cs (1)

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

Evaluation\LazyItemEvaluator.UpdateOperation.cs (1)

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

Evaluation\ParserIgnoreConfiguration.cs (9)

Evaluation\ProjectParser.cs (1)

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

Evaluation\ProjectRootElementCache.cs (4)

154_weakCache = new WeakValueDictionary<string, ProjectRootElement>(StringComparer.OrdinalIgnoreCase); 156_fileLoadLocks = new ConcurrentDictionary<string, object>(StringComparer.OrdinalIgnoreCase); 446_weakCache = new WeakValueDictionary<string, ProjectRootElement>(StringComparer.OrdinalIgnoreCase); 485_weakCache = new WeakValueDictionary<string, ProjectRootElement>(StringComparer.OrdinalIgnoreCase);

Evaluation\PropertiesUseTracker.cs (1)

93_properties = new(StringComparer.OrdinalIgnoreCase);

Evaluation\PropertyFunctionReceiver.cs (1)

68}.ToFrozenSet(StringComparer.OrdinalIgnoreCase);

Evaluation\PropertyTrackingEvaluatorDataWrapper.cs (1)

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

Evaluation\SimpleProjectRootElementCache.cs (1)

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

Evaluation\ToolsetElement.cs (2)

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

Evaluation\ToolsetProvider.cs (3)

38_toolsets = new Dictionary<string, Toolset>(StringComparer.OrdinalIgnoreCase); 83translator.TranslateDictionary(ref _toolsets, StringComparer.OrdinalIgnoreCase, Toolset.FactoryForDeserialization); 103_toolsets = new Dictionary<string, Toolset>(StringComparer.OrdinalIgnoreCase);

Graph\GraphBuilder.cs (2)

286keyComparer: StringComparer.OrdinalIgnoreCase, 328Dictionary<string, ImmutableDictionary<string, string>> globalPropertiesForProjectConfiguration = new(StringComparer.OrdinalIgnoreCase);

Graph\ProjectGraph.cs (3)

787var seenTargets = new SortedSet<string>(StringComparer.OrdinalIgnoreCase); 896var seen = new HashSet<string>(count, StringComparer.OrdinalIgnoreCase); 1044hashCode ^= StringComparer.OrdinalIgnoreCase.GetHashCode(RequestedTargets[i]);

Instance\HostServices.cs (3)

142_hostObjectMap ??= new Dictionary<string, HostObjects>(StringComparer.OrdinalIgnoreCase); 171_hostObjectMap ??= new Dictionary<string, HostObjects>(StringComparer.OrdinalIgnoreCase); 221_projectAffinities = new Dictionary<string, NodeAffinity>(StringComparer.OrdinalIgnoreCase);

Instance\ProjectInstance.cs (9)

Instance\ProjectItemInstance.cs (1)

1716return StringComparer.OrdinalIgnoreCase.GetHashCode(_includeEscaped);

Instance\ProjectTaskInstance.cs (2)

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

Instance\TaskFactoryWrapper.cs (4)

277propertyInfoCache = new Dictionary<string, TaskPropertyInfo>(StringComparer.OrdinalIgnoreCase); 291namesOfPropertiesWithAmbiguousMatches = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 301namesOfPropertiesWithRequiredAttribute = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 312namesOfPropertiesWithOutputAttribute = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

Instance\TaskRegistry.cs (6)

80private readonly ConcurrentDictionary<string, ConcurrentDictionary<RegisteredTaskIdentity, RegisteredTaskRecord>> _cachedTaskRecordsWithFuzzyMatch = new(StringComparer.OrdinalIgnoreCase); 695int nameHash = String.IsNullOrEmpty(obj.Name) ? 0 : StringComparer.OrdinalIgnoreCase.GetHashCode(obj.Name); 703int runtimeHash = obj.TaskIdentityParameters.Runtime == null ? 0 : StringComparer.OrdinalIgnoreCase.GetHashCode(obj.TaskIdentityParameters.Runtime); 704int architectureHash = obj.TaskIdentityParameters.Architecture == null ? 0 : StringComparer.OrdinalIgnoreCase.GetHashCode(obj.TaskIdentityParameters.Architecture); 1574_usingTaskParameters ??= new Dictionary<string, TaskPropertyInfo>(StringComparer.OrdinalIgnoreCase); 1666translator.TranslateDictionary(ref _usingTaskParameters, TranslatorForTaskParametersKey, TranslatorForTaskParameterValue, count => new Dictionary<string, TaskPropertyInfo>(StringComparer.OrdinalIgnoreCase));

Logging\BaseConsoleLogger.cs (1)

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

Logging\BinaryLogger\BinaryLogger.cs (2)

983nonPathParams.Sort(StringComparer.OrdinalIgnoreCase); 1059var distinctFilePaths = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

Logging\BinaryLogger\ProjectImportsCollector.cs (1)

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

Logging\ParallelLogger\ParallelConsoleLogger.cs (1)

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

Logging\ParallelLogger\ParallelLoggerHelpers.cs (2)

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

parent\Shared\PlatformNegotiation.cs (2)

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

parent\Shared\PropertyParser.cs (2)

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

parent\Shared\TaskHostBuildRequest.cs (2)

87result[i] = new Dictionary<string, string>(globalProperties[i].Count, StringComparer.OrdinalIgnoreCase); 176translator.TranslateDictionary(ref dict, StringComparer.OrdinalIgnoreCase);

parent\Shared\TaskHostBuildResponse.cs (4)

64var dict = new Dictionary<string, ITaskItem[]>(projectOutputs.Count, StringComparer.OrdinalIgnoreCase); 95var dict = new Dictionary<string, TaskParameter>(projectOutputs?.Count ?? 0, StringComparer.OrdinalIgnoreCase); 139translator.TranslateDictionary(ref dict, StringComparer.OrdinalIgnoreCase, TaskParameter.FactoryForDeserialization); 148translator.TranslateDictionary(ref dict, StringComparer.OrdinalIgnoreCase, TaskParameter.FactoryForDeserialization);

parent\Shared\TaskHostConfiguration.cs (9)

parent\Shared\TaskHostTaskComplete.cs (5)

126_taskOutputParameters = new Dictionary<string, TaskParameter>(StringComparer.OrdinalIgnoreCase); 204_taskOutputParameters = new Dictionary<string, TaskParameter>(StringComparer.OrdinalIgnoreCase); 263translator.TranslateDictionary(ref _taskOutputParameters, StringComparer.OrdinalIgnoreCase, TaskParameter.FactoryForDeserialization); 282translator.TranslateDictionary(ref _buildProcessEnvironment, StringComparer.OrdinalIgnoreCase); 287translator.TranslateDictionary(ref _buildProcessEnvironment, StringComparer.OrdinalIgnoreCase);

parent\Shared\TypeLoader.cs (3)

695_typeNameToType = new(StringComparer.OrdinalIgnoreCase); 696_publicTypeNameToType = new Dictionary<string, Type>(StringComparer.OrdinalIgnoreCase); 697_publicTypeNameToLoadedType = new(StringComparer.OrdinalIgnoreCase);

Resources\Constants.cs (1)

219var availableStaticMethods = new ConcurrentDictionary<string, Tuple<string, Type>>(StringComparer.OrdinalIgnoreCase);

Utilities\EngineFileUtilities.cs (2)

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

BackEnd\CommunicationsUtilities.cs (1)

72internal static StringComparer EnvironmentVariableComparer => StringComparer.OrdinalIgnoreCase;

Collections\CopyOnWriteDictionary.cs (3)

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

FileUtilities.cs (2)

72public static readonly StringComparer PathComparer = IsFileSystemCaseSensitive ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase; 141private static readonly ConcurrentDictionary<string, bool> FileExistenceCache = new ConcurrentDictionary<string, bool>(StringComparer.OrdinalIgnoreCase);

ImmutableFilesTimestampCache.cs (1)

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

ItemSpecModifiers.cs (1)

98new(StringComparer.OrdinalIgnoreCase);

Loader\CoreCLRAssemblyLoader.cs (2)

26private readonly Dictionary<string, Assembly> _pathsToAssemblies = new Dictionary<string, Assembly>(StringComparer.OrdinalIgnoreCase); 28private readonly HashSet<string> _dependencyPaths = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

MSBuildNameIgnoreCaseComparer.cs (1)

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

MutableTaskItem.cs (1)

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

PathHelpers\AbsolutePath.cs (1)

29private static readonly StringComparer s_pathComparer = NativeMethods.IsFileSystemCaseSensitive ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase;

ProjectStartedEventArgs.cs (1)

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

Sdk\SdkReference.cs (1)

134var comparer = 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);

SolutionConfiguration.cs (5)

52_cachedProjectElements = new Dictionary<string, XmlElement>(projectConfigurationCount, StringComparer.OrdinalIgnoreCase); 53_cachedProjectElementsByAbsolutePath = new Dictionary<string, XmlElement>(projectConfigurationCount, StringComparer.OrdinalIgnoreCase); 54_cachedProjectAbsolutePathsByGuid = new Dictionary<string, string>(projectConfigurationCount, StringComparer.OrdinalIgnoreCase); 55_cachedProjectGuidsByAbsolutePath = new Dictionary<string, string>(projectConfigurationCount, StringComparer.OrdinalIgnoreCase); 56_cachedDependencyProjectGuidsByDependingProjectGuid = new Dictionary<string, List<string>>(projectConfigurationCount, StringComparer.OrdinalIgnoreCase);

TaskClassRegistry.cs (1)

45private static readonly ConcurrentDictionary<string, TaskClassRegistration> s_tasksByName = new(StringComparer.OrdinalIgnoreCase);

TaskHostParameters.cs (4)

79StringComparer.OrdinalIgnoreCase.Equals(Runtime ?? string.Empty, other.Runtime ?? string.Empty) 80&& StringComparer.OrdinalIgnoreCase.Equals(Architecture ?? string.Empty, other.Architecture ?? string.Empty) 86var comparer = StringComparer.OrdinalIgnoreCase; 161internal Dictionary<string, string> ToDictionary() => new(3, StringComparer.OrdinalIgnoreCase)

TaskParameterTypeRegistry.cs (1)

49private static readonly ConcurrentDictionary<string, Type> s_typesByName = new(StringComparer.OrdinalIgnoreCase);

Telemetry\BuildTelemetry.cs (1)

107private static readonly HashSet<string> KnownTargetNames = new(StringComparer.OrdinalIgnoreCase)

Telemetry\TelemetryDataUtils.cs (1)

20private static readonly HashSet<string> KnownTaskFactoryNames = new(StringComparer.OrdinalIgnoreCase)

Utilities\AssemblyNameExtension.cs (1)

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

Utilities\FileMatcher.cs (1)

3872searchesToExcludeInSubdirs = new Dictionary<string, List<RecursionState>>(StringComparer.OrdinalIgnoreCase);

Utilities\TargetPlatformSDK.cs (3)

49ExtensionSDKs = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 50Platforms = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 147=> StringComparer.OrdinalIgnoreCase.GetHashCode(TargetPlatformIdentifier) ^ TargetPlatformVersion.GetHashCode();

Utilities\ToolLocationHelper_ExtensionSDKs.cs (3)

55var extensionSDKs = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 102var extensionSDKsAndVersions = new Dictionary<string, Tuple<string, string>>(StringComparer.OrdinalIgnoreCase); 331s_cachedExtensionSdkReferences ??= new Dictionary<string, string[]>(StringComparer.OrdinalIgnoreCase);

Utilities\ToolLocationHelper_InstalledFrameworks.cs (1)

78s_cachedHighestFrameworkNameForTargetFrameworkIdentifier = new Dictionary<string, FrameworkNameVersioning>(StringComparer.OrdinalIgnoreCase);

Utilities\ToolLocationHelper_PlatformSDKs.cs (1)

150s_cachedTargetPlatformReferences ??= new Dictionary<string, string[]>(StringComparer.OrdinalIgnoreCase);

Utilities\ToolLocationHelper_ReferenceAssemblies.cs (3)

308s_cachedReferenceAssemblyPaths ??= new Dictionary<string, IList<string>>(StringComparer.OrdinalIgnoreCase); 592s_chainedReferenceAssemblyPath ??= new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 593s_cachedTargetFrameworkDisplayNames ??= new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

Utilities\ToolLocationHelper_SDKDiscovery.cs (2)

72s_cachedTargetPlatforms ??= new Dictionary<string, IEnumerable<TargetPlatformSDK>>(StringComparer.OrdinalIgnoreCase); 74s_cachedExtensionSdks ??= new Dictionary<string, TargetPlatformSDK>(StringComparer.OrdinalIgnoreCase);

Utilities\VersionUtilities.cs (1)

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

XMakeAttributes.cs (3)

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

GlobalJsonReader.cs (1)

219versionsByName ??= new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\EnvironmentExtensions.cs (1)

16StringComparer.OrdinalIgnoreCase :

src\roslyn\src\Compilers\Shared\BuildServerConnection.cs (1)

491foreach (var kvp in environmentVariables.OrderBy(kvp => kvp.Key, StringComparer.OrdinalIgnoreCase))

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

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

AssemblyDependency\AssemblyFoldersFromConfig\AssemblyFoldersFromConfigCache.cs (1)

57StringComparer.OrdinalIgnoreCase);

AssemblyDependency\Reference.cs (3)

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

AssemblyDependency\ReferenceTable.cs (9)

37private static readonly Dictionary<string, Tuple<RedistList, string>> s_monikerToHighestRedistList = new Dictionary<string, Tuple<RedistList, string>>(StringComparer.OrdinalIgnoreCase); 42private readonly HashSet<string> _externallyResolvedPrimaryReferences = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 47private readonly Dictionary<string, AssemblyNameExtension> _externallyResolvedImmutableFiles = new Dictionary<string, AssemblyNameExtension>(StringComparer.OrdinalIgnoreCase); 362_resolvedSDKReferences = new Dictionary<string, ITaskItem>(StringComparer.OrdinalIgnoreCase); 1291var parentReferencesAdded = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 1950var conflictingFullNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 1951var fullNameToReference = new Dictionary<string, AssemblyNameReference>(References.Count, StringComparer.OrdinalIgnoreCase); 2133var seenFrameworkDirectories = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 2270var baseNameToReferences = new Dictionary<string, List<AssemblyNameReference>>(References.Count, StringComparer.OrdinalIgnoreCase);

AssemblyDependency\ResolveAssemblyReference.cs (2)

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

AssignProjectConfiguration.cs (2)

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

BootstrapperUtil\BootstrapperBuilder.cs (3)

43private readonly Dictionary<string, XmlNode> _cultures = new Dictionary<string, XmlNode>(StringComparer.OrdinalIgnoreCase); 429var folders = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 2217var includedProducts = new Dictionary<string, Product>(StringComparer.OrdinalIgnoreCase)

BootstrapperUtil\PackageCollection.cs (1)

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

BootstrapperUtil\Product.cs (1)

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

BootstrapperUtil\ProductCollection.cs (1)

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

CreateItem.cs (1)

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

CreateManifestResourceName.cs (1)

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

CultureInfoCache.cs (1)

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

FileIO\GetFileHash.cs (1)

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

GenerateResource.cs (2)

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

GetSDKReferenceFiles.cs (7)

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

ListOperators\RemoveDuplicates.cs (1)

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

MakeDir.cs (1)

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

ManifestUtil\ApplicationManifest.cs (1)

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

MSBuild.cs (1)

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

parent\Shared\PlatformNegotiation.cs (2)

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

parent\Shared\PropertyParser.cs (2)

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

RedistList.cs (12)

ResolveManifestFiles.cs (2)

189_runtimePackAssets = RuntimePackAssets.ToDictionary(p => p.ItemSpec, StringComparer.OrdinalIgnoreCase); 526var outputAssembliesMap = outputAssemblies.ToDictionary(p => (string)TaskEnvironment.GetAbsolutePath(p.ItemSpec).GetCanonicalForm(), StringComparer.OrdinalIgnoreCase);

ResolveProjectBase.cs (1)

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

ResolveSDKReference.cs (7)

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

RoslynCodeTaskFactory\RoslynCodeTaskFactory.cs (6)

48internal static readonly IDictionary<string, IEnumerable<string>> DefaultReferences = new Dictionary<string, IEnumerable<string>>(StringComparer.OrdinalIgnoreCase) 73internal static readonly IDictionary<string, ISet<string>> ValidCodeLanguages = new Dictionary<string, ISet<string>>(StringComparer.OrdinalIgnoreCase) 76{ "CS", new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "CSharp", "C#" } }, 77{ "VB", new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "VisualBasic", "Visual Basic" } }, 328codeNamespace.Imports.AddRange(DefaultNamespaces.Union(taskInfo.Namespaces, StringComparer.OrdinalIgnoreCase).Select(i => new CodeNamespaceImport(i)).ToArray()); 622ISet<string> resolvedAssemblyReferences = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

RoslynCodeTaskFactory\RoslynCodeTaskFactoryTaskInfo.cs (4)

36public ISet<string> Namespaces { get; } = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 41public ISet<string> References { get; } = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 81Name is null ? 0 : StringComparer.OrdinalIgnoreCase.GetHashCode(Name), 82SourceCode is null ? 0 : StringComparer.OrdinalIgnoreCase.GetHashCode(SourceCode),

SystemState.cs (8)

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

Telemetry.cs (1)

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

Touch.cs (1)

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

ZipDirectory.cs (4)

153if (StringComparer.OrdinalIgnoreCase.Equals(levelString, CompressionLevelOptimal)) 157else if (StringComparer.OrdinalIgnoreCase.Equals(levelString, CompressionLevelFastest)) 161else if (StringComparer.OrdinalIgnoreCase.Equals(levelString, CompressionLevelNoCompression)) 166else if (StringComparer.OrdinalIgnoreCase.Equals(levelString, CompressionLevelSmallestSize))

GitDataReader\GitConfig.cs (2)

93!s_knownExtensions.Contains(variable.Key.VariableName, StringComparer.OrdinalIgnoreCase)) 134var comparer = StringComparer.OrdinalIgnoreCase;

GitDataReader\GitIgnore.cs (1)

94=> IgnoreCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;

GitDataReader\GitVariableName.cs (2)

11public static readonly StringComparer SectionNameComparer = StringComparer.OrdinalIgnoreCase; 13public static readonly StringComparer VariableNameComparer = StringComparer.OrdinalIgnoreCase;

Collections\IdentifierCollection.cs (1)

28StringComparer.OrdinalIgnoreCase);

CommandLine\AnalyzerConfigSet.cs (1)

333var comparer = StringComparer.OrdinalIgnoreCase;

CommandLine\ReportAnalyzerUtil.cs (2)

135.OrderBy(g => g.Key.FullName, StringComparer.OrdinalIgnoreCase); 140foreach (var analyzer in group.OrderBy(a => a.GetType().FullName, StringComparer.OrdinalIgnoreCase))

Compilation\Compilation.cs (1)

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

DiagnosticAnalyzer\AnalyzerAssemblyLoader.cs (1)

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

DiagnosticAnalyzer\AnalyzerExecutor.cs (1)

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

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

Emit\AnonymousTypeKey.cs (2)

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

Emit\DebugDocumentsBuilder.cs (1)

31StringComparer.OrdinalIgnoreCase);

FileKey.cs (1)

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

FileSystem\PathUtilities.cs (1)

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

InternalUtilities\EnvironmentExtensions.cs (1)

16StringComparer.OrdinalIgnoreCase :

MetadataReader\PEAssembly.cs (1)

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

MetadataReader\PEModule.cs (1)

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

MetadataReference\AssemblyIdentityComparer.cs (2)

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

RuleSet\RuleSet.cs (1)

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

SourceGeneration\AdditionalSourcesCollection.cs (1)

24private static readonly StringComparer s_hintNameComparer = StringComparer.OrdinalIgnoreCase;

SourceGeneration\CompilationCache.cs (1)

209StringComparer.OrdinalIgnoreCase.GetHashCode(HintName),

SourceGeneration\GeneratorDriver.cs (1)

469var builder = ImmutableHashSet.CreateBuilder<string>(StringComparer.OrdinalIgnoreCase);

MetaAnalyzers\DiagnosticDescriptorCreationAnalyzer_ReleaseTracking.cs (1)

252StringComparer comparer = StringComparer.OrdinalIgnoreCase;

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

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

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

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

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

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

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

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

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

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

src\roslyn\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\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyComparer.cs (1)

35? StringComparer.OrdinalIgnoreCase

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

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

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

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

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

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

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

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

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

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

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

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

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

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

src\roslyn\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\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyComparer.cs (1)

35? StringComparer.OrdinalIgnoreCase

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

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

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\EnvironmentExtensions.cs (1)

16StringComparer.OrdinalIgnoreCase :

src\roslyn\src\Compilers\Shared\BuildServerConnection.cs (1)

491foreach (var kvp in environmentVariables.OrderBy(kvp => kvp.Key, StringComparer.OrdinalIgnoreCase))

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

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

src\roslyn\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\roslyn\src\Analyzers\Core\Analyzers\RemoveUnnecessarySuppressions\SuppressMessageAttributeState.cs (1)

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

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

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

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

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

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

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

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

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

src\roslyn\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\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyComparer.cs (1)

35? StringComparer.OrdinalIgnoreCase

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

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

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

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

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

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

CommandLine\CSharpCompiler.cs (1)

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

CSharpParseOptions.cs (2)

170if (features is not ImmutableDictionary<string, string> dictionary || dictionary.KeyComparer != StringComparer.OrdinalIgnoreCase) 172dictionary = (features ?? []).ToImmutableDictionary(StringComparer.OrdinalIgnoreCase);

Symbols\MissingModuleSymbol.cs (1)

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

Symbols\Source\SourceAssemblySymbol.cs (2)

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

EmbeddedLanguages\CSharpTestEmbeddedLanguageClassifier.cs (1)

52var (virtualCharsWithoutMarkup, markdownSpans) = StringComparer.OrdinalIgnoreCase.Equals(context.LanguageIdentifier, PredefinedEmbeddedLanguageNames.CSharpTest)

FileBasedPrograms\FileBasedProgramService.cs (1)

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

SyncedSource\FileBasedPrograms\FileLevelDirectiveHelpers.cs (3)

325internal static readonly StringComparer MetadataNameComparer = StringComparer.OrdinalIgnoreCase; 1518StringComparer.OrdinalIgnoreCase.Equals(x.Name, y.Name); 1525StringComparer.OrdinalIgnoreCase.GetHashCode(obj.Name));

SyncedSource\FileBasedPrograms\VirtualProjectBuilder.cs (2)

547processedFiles ??= new HashSet<string>(StringComparer.OrdinalIgnoreCase); 744.ToHashSet(StringComparer.OrdinalIgnoreCase);

Symbols\INamedTypeSymbolExtensions.cs (1)

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

AddImport\AbstractAddImportFeatureService.cs (2)

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

AddImport\References\MetadataSymbolReference.cs (2)

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

AddImport\References\Reference.cs (1)

43diff = StringComparer.OrdinalIgnoreCase.Compare(

AddImport\SymbolResult.cs (1)

44return StringComparer.OrdinalIgnoreCase.Equals(

CodeLens\LocationComparer.cs (1)

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

CodeRefactorings\CodeRefactoringService.cs (2)

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

Completion\CompletionItem.cs (2)

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

Completion\FileSystemCompletionHelper.cs (1)

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

Completion\Providers\AbstractInternalsVisibleToCompletionProvider.cs (1)

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

EmbeddedLanguages\AbstractEmbeddedLanguageFeatureService.cs (4)

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

EmbeddedLanguages\EmbeddedLanguageCommentOptions.cs (1)

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

EmbeddedLanguages\EmbeddedLanguageDetector.cs (1)

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

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

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

InheritanceMargin\AbstractInheritanceMarginService_Helpers.cs (1)

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

MetadataAsSource\DecompilationMetadataAsSourceFileProvider.cs (3)

49private readonly ConcurrentDictionary<string, (MetadataAsSourceGeneratedFileInfo Metadata, DocumentId DocumentId)> _generatedFilenameToInformation = new(StringComparer.OrdinalIgnoreCase); 458return StringComparer.OrdinalIgnoreCase.Equals(_filePath, other._filePath) && 472Hash.Combine(StringComparer.OrdinalIgnoreCase.GetHashCode(_filePath ?? string.Empty),

PdbSourceDocument\ImplementationAssemblyLookupService.cs (1)

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

PdbSourceDocument\PdbSourceDocumentMetadataAsSourceFileProvider.cs (1)

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

src\roslyn\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\roslyn\src\Analyzers\Core\Analyzers\RemoveUnnecessarySuppressions\SuppressMessageAttributeState.cs (1)

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

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

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

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\DefineAccessorsForAttributeArguments.cs (2)

109var uniqueParamNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 125var propertiesMap = new Dictionary<string, IPropertySymbol>(StringComparer.OrdinalIgnoreCase);

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\IdentifiersShouldDifferByMoreThanCase.cs (4)

143using var membersByName = PooledDictionary<string, PooledHashSet<ISymbol>>.GetInstance(StringComparer.OrdinalIgnoreCase); 223using var uniqueNames = PooledHashSet<string>.GetInstance(StringComparer.OrdinalIgnoreCase); 243using var typesByName = PooledDictionary<string, PooledHashSet<ISymbol>>.GetInstance(StringComparer.OrdinalIgnoreCase); 275using var namespacesByName = PooledDictionary<string, PooledHashSet<ISymbol>>.GetInstance(StringComparer.OrdinalIgnoreCase);

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\IdentifiersShouldNotContainTypeNames.cs (1)

31ImmutableHashSet.CreateRange(StringComparer.OrdinalIgnoreCase, new[]

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\IdentifiersShouldNotMatchKeywords.cs (1)

713}.ToImmutableDictionary(key => key, StringComparer.OrdinalIgnoreCase);

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\TypeNamesShouldNotMatchNamespaces.cs (2)

104var namespaceComponentToNamespaceNameDictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 286var wellKnownSystemNamespaceTable = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

Microsoft.CodeQuality.Analyzers\Maintainability\CodeMetricsAnalyzer.cs (1)

330var builder = ImmutableDictionary.CreateBuilder<string, IReadOnlyList<(SymbolKind?, uint)>>(StringComparer.OrdinalIgnoreCase);

Microsoft.NetCore.Analyzers\InteropServices\PlatformCompatibilityAnalyzer.cs (19)

Microsoft.NetCore.Analyzers\InteropServices\PlatformCompatibilityAnalyzer.OperationVisitor.cs (2)

95mappedAttributes ??= new(StringComparer.OrdinalIgnoreCase); 237mappedAttributes ??= new(StringComparer.OrdinalIgnoreCase);

Microsoft.NetCore.Analyzers\InteropServices\UseValidPlatformString.cs (1)

79var knownPlatforms = PooledDictionary<string, int>.GetInstance(StringComparer.OrdinalIgnoreCase);

Microsoft.NetCore.Analyzers\Performance\AvoidPotentiallyExpensiveCallWhenLogging.cs (1)

42private static readonly Dictionary<string, int> s_logLevelsByName = new(StringComparer.OrdinalIgnoreCase)

Microsoft.NetCore.Analyzers\Performance\PreferDictionaryTryMethodsOverContainsKeyGuardFixer.cs (1)

89var reserved = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

Microsoft.NetCore.Analyzers\Runtime\AttributeStringLiteralsShouldParseCorrectly.cs (1)

258=> _ignoredNames.Contains(name, StringComparer.OrdinalIgnoreCase);

Microsoft.NetCore.Analyzers\Security\DoNotUseDSA.cs (1)

37StringComparer.OrdinalIgnoreCase,

Microsoft.NetCore.Analyzers\Security\UseRSAWithSufficientKeySize.cs (1)

38StringComparer.OrdinalIgnoreCase,

src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\Compiler\Extensions\CompilationExtensions.cs (2)

39return guids.Contains(WebAppProjectGuidString, StringComparer.OrdinalIgnoreCase) || 40guids.Contains(WebSiteProjectGuidString, StringComparer.OrdinalIgnoreCase);

src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\Compiler\Extensions\UriExtensions.cs (1)

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

src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\Compiler\RulesetToEditorconfigConverter.cs (1)

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

CSharp\AssemblyIdentityEqualityComparer.cs (1)

46hash.Add(obj.Name, StringComparer.OrdinalIgnoreCase);

CSharp\Utf8SupportMap.cs (2)

68var fileToType = ImmutableSortedDictionary.CreateBuilder<string, string>(StringComparer.OrdinalIgnoreCase); 269hash.Add(kvp.Key, StringComparer.OrdinalIgnoreCase);

Language\CodeGeneration\TagHelperRenderingContext.cs (1)

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

Language\Components\ComponentLoweringPass.cs (3)

295using var markupAttributeNames = new PooledHashSet<string>(StringComparer.OrdinalIgnoreCase); 315using var genericParamNames = new PooledHashSet<string>(StringComparer.OrdinalIgnoreCase); 324using var nonGenericParamNames = new PooledHashSet<string>(StringComparer.OrdinalIgnoreCase);

Language\Components\ComponentMarkupDiagnosticPass.cs (1)

28private readonly Dictionary<string, (string name, IntermediateNode node)> _attributes = new(StringComparer.OrdinalIgnoreCase);

Language\Components\ComponentTildePathPass.cs (2)

65var result = new Dictionary<string, HashSet<string>>(StringComparer.OrdinalIgnoreCase); 76attributes = new(StringComparer.OrdinalIgnoreCase);

Language\DefaultTagHelperResolutionPhase.ComponentTagHelperResolver.cs (1)

102var renderedBoundAttributeNames = new PooledHashSet<string>(StringComparer.OrdinalIgnoreCase);

Language\DefaultTagHelperResolutionPhase.LegacyTagHelperResolver.cs (1)

43var renderedBoundAttributeNames = new PooledHashSet<string>(StringComparer.OrdinalIgnoreCase);

Language\Legacy\ParserHelpers.cs (1)

41public static readonly FrozenSet<string> VoidElements = FrozenSet.Create(StringComparer.OrdinalIgnoreCase,

Language\Legacy\TagHelperBlockRewriter.cs (1)

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

Language\Legacy\TagHelperParseTreeRewriter.cs (2)

770var distinctSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 797var distinctSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

Language\RazorLanguageVersion.cs (2)

48var map = new Dictionary<string, RazorLanguageVersion>(StringComparer.OrdinalIgnoreCase) 68return map.ToFrozenDictionary(StringComparer.OrdinalIgnoreCase);

Language\TagHelperBinder.cs (1)

102var map = new Dictionary<string, TagHelperSet>(capacity: tagNameToBuilderIndexMap.Count, StringComparer.OrdinalIgnoreCase);

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

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

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

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

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

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

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

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

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

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

src\roslyn\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\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyComparer.cs (1)

35? StringComparer.OrdinalIgnoreCase

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

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

Hosting\AssemblyLoader\MetadataShadowCopyProvider.cs (1)

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

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

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

Hosting\ObjectFormatter\ObjectFormatterHelpers.cs (1)

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

Hosting\Resolvers\RuntimeMetadataReferenceResolver.cs (1)

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

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

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

Symbols\MissingModuleSymbol.vb (1)

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

Symbols\Source\SourceAssemblySymbol.vb (2)

979New ConcurrentDictionary(Of String, ConcurrentDictionary(Of ImmutableArray(Of Byte), Tuple(Of Location, String)))(StringComparer.OrdinalIgnoreCase), Nothing) 1364Dim knownModuleNames As New HashSet(Of String)(StringComparer.OrdinalIgnoreCase)

VisualBasicParseOptions.vb (1)

235Return New VisualBasicParseOptions(Me) With {._features = features.ToImmutableDictionary(StringComparer.OrdinalIgnoreCase)}

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Services\SemanticFacts\VisualBasicSemanticFacts.vb (1)

158Dim builder = ImmutableHashSet.CreateBuilder(Of String)(StringComparer.OrdinalIgnoreCase)

EncapsulateField\VisualBasicEncapsulateFieldService.vb (4)

101Return NameGenerator.GenerateUniqueName(baseName, containingType.MemberNames.Where(Function(x) x <> originalFieldName).ToSet(), StringComparer.OrdinalIgnoreCase) 103Return NameGenerator.GenerateUniqueName(baseName, containingType.MemberNames.ToSet(), StringComparer.OrdinalIgnoreCase) 116propertyName = NameGenerator.GenerateUniqueName(propertyName, containingTypeMemberNames.Where(Function(m) m <> field.Name).ToSet(), StringComparer.OrdinalIgnoreCase) 129Return NameGenerator.GenerateUniqueName(propertyName, containingTypeMemberNames.ToSet(), StringComparer.OrdinalIgnoreCase)

CaseCorrection\VisualBasicCaseCorrectionService.Rewriter.vb (1)

28Dim [set] = ImmutableHashSet.CreateBuilder(Of String)(StringComparer.OrdinalIgnoreCase)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Services\SemanticFacts\VisualBasicSemanticFacts.vb (1)

158Dim builder = ImmutableHashSet.CreateBuilder(Of String)(StringComparer.OrdinalIgnoreCase)

FindSymbols\FindReferences\DependentProjectsFinder.cs (1)

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

FindSymbols\FindReferences\FindReferenceCache.cs (1)

87LanguageNames.VisualBasic => StringComparer.OrdinalIgnoreCase,

FindSymbols\ReferenceLocation.cs (1)

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

FindSymbols\SyntaxTree\SyntaxTreeIndex_Create.cs (4)

370Debug.Assert(identifiers.Comparer == StringComparer.OrdinalIgnoreCase); 371Debug.Assert(escapedIdentifiers.Comparer == StringComparer.OrdinalIgnoreCase); 386Debug.Assert(identifiers.Comparer == StringComparer.OrdinalIgnoreCase); 387Debug.Assert(escapedIdentifiers.Comparer == StringComparer.OrdinalIgnoreCase);

Shared\Extensions\IFindReferencesResultExtensions.cs (1)

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

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

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

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

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

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

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

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

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

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

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

src\roslyn\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\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyComparer.cs (1)

35? StringComparer.OrdinalIgnoreCase

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

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

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

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

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

39private readonly Dictionary<string, DocumentEntry> _documentPathsToDocuments = new(StringComparer.OrdinalIgnoreCase);

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

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

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

32private static readonly StringComparer s_comparer = StringComparer.OrdinalIgnoreCase;

MSBuild\MSBuildProjectLoader.cs (1)

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

MSBuild\ProjectFileExtensionRegistry.cs (1)

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

MSBuild\SolutionFileReader.SolutionFilterReader.cs (1)

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

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\EnvironmentExtensions.cs (1)

16StringComparer.OrdinalIgnoreCase :

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

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

Build\ProjectBuildManager.cs (1)

216var mergedGlobalProperties = new Dictionary<string, string>(_projectCollection.GlobalProperties, StringComparer.OrdinalIgnoreCase);

MSBuild\ProjectFile\CommandLineArgumentReader.cs (1)

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

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

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

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

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

parent\parent\Microsoft.DotNet.ApiSymbolExtensions\Logging\MSBuildLog.cs (1)

14private readonly HashSet<string> _noWarn = string.IsNullOrEmpty(noWarn) ? [] : new(noWarn!.Split(';'), StringComparer.OrdinalIgnoreCase);

Logging\SuppressionEngine.cs (1)

21private readonly HashSet<string> _noWarn = string.IsNullOrEmpty(noWarn) ? [] : new(noWarn!.Split(';'), StringComparer.OrdinalIgnoreCase);

AssemblySymbolLoader.cs (2)

38private readonly Dictionary<string, string> _referencePathFiles = new(StringComparer.OrdinalIgnoreCase); 39private readonly HashSet<string> _referencePathDirectories = new(StringComparer.OrdinalIgnoreCase);

Logging\ConsoleLog.cs (1)

11private readonly HashSet<string> _noWarn = string.IsNullOrEmpty(noWarn) ? [] : new(noWarn!.Split(';'), StringComparer.OrdinalIgnoreCase);

src\InstallDotNetCore.cs (1)

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

ArtifactSet.cs (4)

27.OrderBy(p => p.Id, StringComparer.OrdinalIgnoreCase) 28.ThenBy(p => p.Version, StringComparer.OrdinalIgnoreCase) 31.OrderBy(b => b.Id, StringComparer.OrdinalIgnoreCase) 34.OrderBy(b => b.Id, StringComparer.OrdinalIgnoreCase)

MSBuildListSplitter.cs (2)

15return new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 23var values = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

XElementParsingExtensions.cs (1)

36.ThenBy(pair => pair.Key, StringComparer.OrdinalIgnoreCase)

src\CreateWixBuildWixpack.cs (3)

202_defineVariablesDictionary = new Dictionary<string, string>(System.StringComparer.OrdinalIgnoreCase); 476var dict = new Dictionary<string, string>(System.StringComparer.OrdinalIgnoreCase); 507var dict = new Dictionary<string, string>(System.StringComparer.OrdinalIgnoreCase);

GenerateNuSpec.cs (1)

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

HarvestPackage.cs (4)

274var livePackageFiles = new Dictionary<string, PackageItem>(StringComparer.OrdinalIgnoreCase); 510_pathsToExclude = new HashSet<string>(PathsToExclude.NullAsEmpty().Select(NormalizePath), StringComparer.OrdinalIgnoreCase); 522_pathsToInclude = PathsToInclude.NullAsEmpty().ToDictionary(i => NormalizePath(i.ItemSpec), i=> i, StringComparer.OrdinalIgnoreCase); 605return extension != null && extension.Length > 0 && s_includedExtensions.Contains(extension, StringComparer.OrdinalIgnoreCase);

PackageIndex.cs (1)

33public HashSet<string> IndexSources { get; set; } = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

UpdatePackageIndex.cs (1)

97_packageIdsToInclude = new HashSet<string>(PackageIds.Select(i => i.ItemSpec), StringComparer.OrdinalIgnoreCase);

MSBuildListSplitter.cs (1)

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

OptProf\IbcEntry.cs (2)

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

Common\CommonOptions.cs (3)

55var dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 138return allValues.Distinct(StringComparer.OrdinalIgnoreCase).ToArray(); 311RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal);

Help\HelpBuilder.Default.cs (2)

228.OrderBy(r => r.Prefix, StringComparer.OrdinalIgnoreCase) 229.ThenBy(r => r.Alias, StringComparer.OrdinalIgnoreCase)

Providers\CopilotCliDetectionProvider.cs (1)

32.OrderBy(variable => variable.Name, StringComparer.OrdinalIgnoreCase))

Providers\WorkplaceJoinDetectionProvider.cs (1)

110new(StringComparer.OrdinalIgnoreCase);

FrameworkDependencyFile.cs (2)

88.Distinct(comparer: StringComparer.OrdinalIgnoreCase) 89.ToDictionary(x => x, StringComparer.OrdinalIgnoreCase);

MSBuildArgs.cs (4)

244var newRestoreProperties = new Dictionary<string, string>(RestoreGlobalProperties, StringComparer.OrdinalIgnoreCase); 294var newProperties = new Dictionary<string, string>(GlobalProperties, StringComparer.OrdinalIgnoreCase); 377var newdict = new Dictionary<string, string>(GlobalProperties, StringComparer.OrdinalIgnoreCase); 391_ => [.. RequestedTargets.Union(GetTargetResult, StringComparer.OrdinalIgnoreCase)]

ToolCommandName.cs (1)

39return StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

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

Build\BuildUtilities.cs (1)

24var properties = ImmutableDictionary.CreateBuilder<string, string>(StringComparer.OrdinalIgnoreCase);

src\sdk\src\Dotnet.Watch\HotReloadClient\Web\BrowserRefreshServer.cs (1)

64!webSocketConfig.GetAllowedOriginDomains().Contains(originUri.Host, StringComparer.OrdinalIgnoreCase)))

src\sdk\src\Dotnet.Watch\HotReloadClient\WebSocketClientTransport.cs (1)

127!webSocketConfig.GetAllowedOriginDomains().Contains(originUri.Host, StringComparer.OrdinalIgnoreCase))

UI\BuildParametersSelectionPrompt.cs (2)

20var orderedTargetFrameworks = targetFrameworks.Order(StringComparer.OrdinalIgnoreCase).ToArray(); 22if (PreviousFrameworkSelection != null && PreviousTargetFrameworks?.SequenceEqual(orderedTargetFrameworks, StringComparer.OrdinalIgnoreCase) == true)

Utilities\PathUtilities.cs (1)

8public static readonly IEqualityComparer<string?> OSSpecificPathComparer = Path.DirectorySeparatorChar == '\\' ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;

src\sdk\src\Dotnet.Watch\HotReloadAgent\MetadataUpdateHandlerInvoker.cs (1)

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

src\UpdatePackageVersionTask.cs (2)

50else if (StringComparer.OrdinalIgnoreCase.Equals(VersionKind, "release")) 54else if (StringComparer.OrdinalIgnoreCase.Equals(VersionKind, "prerelease"))

VerifyClosure.cs (3)

46private HashSet<string> otherFiles = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 47private Dictionary<string, Version> ignoredReferences = new Dictionary<string, Version>(StringComparer.OrdinalIgnoreCase); 356var nodeIds = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

BuildService.cs (2)

78private readonly ConcurrentDictionary<string, Microsoft.Build.Construction.ProjectRootElement> _projectRootElements = new(StringComparer.OrdinalIgnoreCase); 95var mergedGlobalProperties = new Dictionary<string, string>(projectCollection.Inner.GlobalProperties, StringComparer.OrdinalIgnoreCase);

src\sdk\src\Cli\Microsoft.DotNet.FileBasedPrograms\FileLevelDirectiveHelpers.cs (3)

325internal static readonly StringComparer MetadataNameComparer = StringComparer.OrdinalIgnoreCase; 1518StringComparer.OrdinalIgnoreCase.Equals(x.Name, y.Name); 1525StringComparer.OrdinalIgnoreCase.GetHashCode(obj.Name));

src\sdk\src\Cli\Microsoft.DotNet.FileBasedPrograms\VirtualProjectBuilder.cs (2)

547processedFiles ??= new HashSet<string>(StringComparer.OrdinalIgnoreCase); 744.ToHashSet(StringComparer.OrdinalIgnoreCase);

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

46private HashSet<string> otherFiles = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 47private Dictionary<string, Version> ignoredReferences = new Dictionary<string, Version>(StringComparer.OrdinalIgnoreCase); 356var nodeIds = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

src\CreateFrameworkListFile.cs (1)

77StringComparer.OrdinalIgnoreCase);

src\FileUtilities.cs (1)

18StringComparer.OrdinalIgnoreCase);

src\ValidateFileVersions.cs (1)

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

src\UsageReport\WritePackageUsageData.cs (1)

204StringComparer.OrdinalIgnoreCase);

src\UsageReport\WriteUsageReports.cs (2)

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

parent\Resolvers\Microsoft.NET.Sdk.WorkloadManifestReader\SdkDirectoryWorkloadManifestProvider.cs (4)

22private static HashSet<string> _outdatedManifestIds = new(StringComparer.OrdinalIgnoreCase) { "microsoft.net.workload.android", "microsoft.net.workload.blazorwebassembly", "microsoft.net.workload.ios", 340var manifestIdsToManifests = new Dictionary<string, ReadableWorkloadManifest>(StringComparer.OrdinalIgnoreCase); 384Dictionary<string, string> directoriesWithManifests = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 469.ThenBy(kvp => kvp.Key, StringComparer.OrdinalIgnoreCase)

parent\Resolvers\Microsoft.NET.Sdk.WorkloadManifestReader\WorkloadId.cs (1)

28public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(_id);

parent\Resolvers\Microsoft.NET.Sdk.WorkloadManifestReader\WorkloadManifestReader.cs (1)

220var dependsOn = new Dictionary<string, FXVersion>(StringComparer.OrdinalIgnoreCase);

parent\Resolvers\Microsoft.NET.Sdk.WorkloadManifestReader\WorkloadPackId.cs (1)

34public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(_id);

parent\Resolvers\Microsoft.NET.Sdk.WorkloadManifestReader\WorkloadResolver.cs (1)

17private readonly Dictionary<string, (WorkloadManifest manifest, WorkloadManifestInfo info)> _manifests = new(StringComparer.OrdinalIgnoreCase);

parent\Resolvers\Microsoft.NET.Sdk.WorkloadManifestReader\WorkloadSet.cs (1)

112var dictionary = ManifestVersions.ToDictionary(kvp => kvp.Key.ToString(), kvp => kvp.Value.Version + "/" + kvp.Value.FeatureBand, StringComparer.OrdinalIgnoreCase);

Tasks\GatherXlf.cs (1)

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

ChatCompletion\ImageGeneratingChatClient.cs (1)

148private readonly Dictionary<string, AIContent> _imageContentById = new(StringComparer.OrdinalIgnoreCase);

src\LegacySupport\MediaTypeMap\MediaTypeMap.cs (2)

20private static readonly Dictionary<string, string> s_extensionToMediaType = new(StringComparer.OrdinalIgnoreCase) 428private static readonly Dictionary<string, string> s_mediaTypeToExtension = new(StringComparer.OrdinalIgnoreCase)

AdditionalPropertiesDictionary{TValue}.cs (3)

30_dictionary = new(StringComparer.OrdinalIgnoreCase); 36_dictionary = new(dictionary, StringComparer.OrdinalIgnoreCase); 43_dictionary = new(collection, StringComparer.OrdinalIgnoreCase);

ChatCompletion\ChatFinishReason.cs (2)

34public bool Equals(ChatFinishReason other) => StringComparer.OrdinalIgnoreCase.Equals(Value, other.Value); 37public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

ChatCompletion\ChatRole.cs (1)

85=> StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

Realtime\RealtimeServerMessageType.cs (1)

146=> Value is null ? 0 : StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

Realtime\RealtimeSessionKind.cs (1)

83=> Value is null ? 0 : StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

SpeechToText\SpeechToTextResponseUpdateKind.cs (1)

88=> StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

src\LegacySupport\MediaTypeMap\MediaTypeMap.cs (2)

20private static readonly Dictionary<string, string> s_extensionToMediaType = new(StringComparer.OrdinalIgnoreCase) 428private static readonly Dictionary<string, string> s_mediaTypeToExtension = new(StringComparer.OrdinalIgnoreCase)

TextToSpeech\TextToSpeechResponseUpdateKind.cs (1)

88=> Value is null ? 0 : StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

Tools\HostedMcpServerTool.cs (1)

145/// As HTTP header names are case-insensitive, callers should use <see cref="StringComparer.OrdinalIgnoreCase"/> comparison when constructing the dictionary.

Functions\AIFunctionArgumentsTests.cs (6)

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

OpenAIRealtimeClientSession.cs (1)

560var sdkHeaders = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

src\LegacySupport\MediaTypeMap\MediaTypeMap.cs (2)

20private static readonly Dictionary<string, string> s_extensionToMediaType = new(StringComparer.OrdinalIgnoreCase) 428private static readonly Dictionary<string, string> s_mediaTypeToExtension = new(StringComparer.OrdinalIgnoreCase)

Functions\AIFunctionFactoryTest.cs (2)

1748AIFunctionArguments caseInsensitive = new(StringComparer.OrdinalIgnoreCase) 1756AIFunctionArguments withExtra = new(StringComparer.OrdinalIgnoreCase)

ConfigurationProvider.cs (1)

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

InternalConfigurationRootExtensions.cs (1)

29.Distinct(StringComparer.OrdinalIgnoreCase)

ConfigurationBinder.cs (2)

227StringComparer.OrdinalIgnoreCase); 627HashSet<string> propertyNames = new(StringComparer.OrdinalIgnoreCase);

ConfigurationBindingGenerator.Parser.cs (2)

744(reportedUnsupportedProperties ??= new(StringComparer.OrdinalIgnoreCase)).Add(propertyName)) 774(properties ??= new(StringComparer.OrdinalIgnoreCase))[propertyName] = spec;

CommandLineConfigurationProvider.cs (2)

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

EnvironmentVariablesConfigurationProvider.cs (1)

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

FileConfigurationProvider.cs (1)

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

IniStreamConfigurationProvider.cs (1)

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

JsonConfigurationFileParser.cs (1)

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

KeyPerFileConfigurationProvider.cs (1)

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

XmlStreamConfigurationProvider.cs (2)

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

src\LegacySupport\MediaTypeMap\MediaTypeMap.cs (2)

20private static readonly Dictionary<string, string> s_extensionToMediaType = new(StringComparer.OrdinalIgnoreCase) 428private static readonly Dictionary<string, string> s_mediaTypeToExtension = new(StringComparer.OrdinalIgnoreCase)

CollectionExtensions.netcoreapp.cs (1)

15return collection.ToDictionary(l => l.Name, StringComparer.OrdinalIgnoreCase);

DependencyContext.cs (2)

86return StringComparer.OrdinalIgnoreCase.Equals(x?.Name, y?.Name); 91return StringComparer.OrdinalIgnoreCase.GetHashCode(obj.Name);

Tracing\DefaultActivitySourceFactory.cs (2)

354seen ??= new HashSet<string>(StringComparer.OrdinalIgnoreCase); 363divergent ??= new HashSet<string>(StringComparer.OrdinalIgnoreCase);

DefaultHealthCheckService.cs (2)

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

HealthCheckRegistration.cs (2)

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

Linux\Resources\HardcodedValueFileSystem.cs (1)

27_fileContent = fileContent.ToDictionary(static x => x.Key.FullName, static y => y.Value, StringComparer.OrdinalIgnoreCase);

Linux\Resources\TestResources.cs (1)

15private static readonly Dictionary<string, string> _files = new(StringComparer.OrdinalIgnoreCase)

src\sdk\src\Dotnet.Watch\HotReloadAgent\MetadataUpdateHandlerInvoker.cs (1)

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

PhysicalFilesWatcher.cs (2)

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

FilePatternMatch.cs (1)

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

Util\StringComparisonHelper.cs (1)

15StringComparison.OrdinalIgnoreCase => StringComparer.OrdinalIgnoreCase,

DependencyInjection\HttpClientBuilderExtensions.cs (1)

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

Logging\Internal\HttpHeadersReader.cs (2)

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

Logging\Internal\HttpRequestBodyReader.cs (1)

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

Logging\Internal\HttpResponseBodyReader.cs (1)

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

Logging\MediaTypeCollectionExtensionsTest.cs (4)

27var collection = new HashSet<string>(_readableContentTypes, StringComparer.OrdinalIgnoreCase).ToFrozenSet(StringComparer.OrdinalIgnoreCase); 44var collection = new HashSet<string>(_readableContentTypes, StringComparer.OrdinalIgnoreCase).ToFrozenSet(StringComparer.OrdinalIgnoreCase);

Helpers\ConfigurationStubFactory.cs (1)

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

Routing\RoutingStrategyTest.cs (1)

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

ConsoleLoggerProvider.cs (1)

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

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\BindingExtensions.g.cs (6)

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\BindingExtensions.g.cs (1)

54private readonly static Lazy<global::System.Collections.Generic.HashSet<string>> s_configKeys_Microsoft__Extensions__Logging__EventLog__EventLogSettings = new(() => new global::System.Collections.Generic.HashSet<string>(StringComparer.OrdinalIgnoreCase) { "LogName", "SourceName", "MachineName", "EventLog" });

LoggerMessageGenerator.Parser.cs (1)

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

TraceSourceLoggerProvider.cs (1)

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

StringSegmentComparer.cs (1)

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

Http\ResolvingHttpDelegatingHandler.cs (1)

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

Program.cs (1)

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

ServiceDiscoveryDestinationResolver.cs (1)

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

Parsing\Parser.cs (3)

173bool parameterInTemplate = lm.Templates.Contains(lp.TagName, StringComparer.OrdinalIgnoreCase) || 174lm.Templates.Contains(lp.ParameterNameWithAtIfNeeded, StringComparer.OrdinalIgnoreCase) || 175lm.Templates.Contains($"@{lp.ParameterName}", StringComparer.OrdinalIgnoreCase);

Handlers\HybridWebView\FileExtensionContentTypeProvider.cs (1)

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

Visuals\VisualTypeConverter.cs (1)

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

ColorDesignTypeConverter.cs (1)

170 knowValuesSet = new HashSet<string>(knownValues, StringComparer.OrdinalIgnoreCase);

VisibilityDesignTypeConverter.cs (1)

10 private static readonly HashSet<string> supportedValues = new HashSet<string>(validValues, StringComparer.OrdinalIgnoreCase);

Text\TextColors.cs (1)

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

ColorTable.cs (1)

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

MLImage.cs (1)

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

Model\TiktokenTokenizer.cs (2)

1073new Dictionary<string, ModelEncoding>(StringComparer.OrdinalIgnoreCase) 1293private 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);

AddFacadesToReferences.cs (1)

23Dictionary<string, ITaskItem> facadeDict = new(StringComparer.OrdinalIgnoreCase);

parent\Common\ConflictResolution\PackageOverride.cs (1)

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

parent\Common\ConflictResolution\PackageOverrideResolver.cs (1)

38result = new Dictionary<string, PackageOverride>(_packageOverrideItems.Length, StringComparer.OrdinalIgnoreCase);

parent\Common\ConflictResolution\PackageRank.cs (1)

15packageRanks = new Dictionary<string, int>(numPackages, StringComparer.OrdinalIgnoreCase);

parent\Common\ConflictResolution\ResolvePackageFileConflicts.cs (1)

188StringComparer.OrdinalIgnoreCase);

parent\Common\FileUtilities.cs (2)

13= new(StringComparer.OrdinalIgnoreCase); 43static readonly HashSet<string?> s_assemblyExtensions = new(new[] { ".dll", ".exe", ".winmd" }, StringComparer.OrdinalIgnoreCase);

parent\Common\FileUtilities.MetadataReader.cs (1)

23private static readonly ConcurrentDictionary<string, (DateTime LastKnownWriteTimeUtc, Version? Version)> s_versionCache = new(StringComparer.OrdinalIgnoreCase /* Not strictly correct on *nix. Fix? */);

AllowEmptyTelemetry.cs (1)

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

CheckForDuplicateFrameworkReferences.cs (1)

33var duplicateItems = FrameworkReferences.GroupBy(i => i.ItemSpec, StringComparer.OrdinalIgnoreCase).Where(g => g.Count() > 1);

CheckForDuplicateItems.cs (1)

41var itemGroups = Items.GroupBy(i => i.ItemSpec, StringComparer.OrdinalIgnoreCase);

CheckForImplicitPackageReferenceOverrides.cs (1)

27var duplicateItems = PackageReferenceItems.GroupBy(i => i.ItemSpec, StringComparer.OrdinalIgnoreCase).Where(g => g.Count() > 1);

CollectSDKReferencesDesignTime.cs (1)

47var implicitPackageReferences = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

DependencyContextBuilder.cs (8)

FrameworkPackages\FrameworkPackages.cs (1)

59public Dictionary<string, NuGetVersion> Packages { get; } = new Dictionary<string, NuGetVersion>(StringComparer.OrdinalIgnoreCase);

GenerateDepsFile.cs (1)

166var userRuntimeAssemblySet = new HashSet<string>(UserRuntimeAssemblies is not null ? UserRuntimeAssemblies.Select(i => i.ItemSpec) : Enumerable.Empty<string>(), StringComparer.OrdinalIgnoreCase);

GenerateRuntimeConfigurationFiles.cs (2)

106if (!RollForwardValues.Contains(RollForward, StringComparer.OrdinalIgnoreCase)) 225HashSet<string> usedFrameworkNames = new(StringComparer.OrdinalIgnoreCase);

JoinItems.cs (1)

132StringComparer.OrdinalIgnoreCase).ToArray();

LockFileExtensions.cs (2)

139var set = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 168var exclusionList = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

LockFileLookup.cs (2)

20_projects = new Dictionary<string, LockFileLibrary>(StringComparer.OrdinalIgnoreCase); 99hashCode ^= StringComparer.OrdinalIgnoreCase.GetHashCode(obj.Key);

parent\Common\ConflictResolution\PackageOverride.cs (1)

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

parent\Common\ConflictResolution\PackageOverrideResolver.cs (1)

38result = new Dictionary<string, PackageOverride>(_packageOverrideItems.Length, StringComparer.OrdinalIgnoreCase);

parent\Common\ConflictResolution\PackageRank.cs (1)

15packageRanks = new Dictionary<string, int>(numPackages, StringComparer.OrdinalIgnoreCase);

parent\Common\ConflictResolution\ResolvePackageFileConflicts.cs (1)

188StringComparer.OrdinalIgnoreCase);

parent\Common\FileUtilities.cs (2)

13= new(StringComparer.OrdinalIgnoreCase); 43static readonly HashSet<string?> s_assemblyExtensions = new(new[] { ".dll", ".exe", ".winmd" }, StringComparer.OrdinalIgnoreCase);

parent\Common\FileUtilities.MetadataReader.cs (1)

23private static readonly ConcurrentDictionary<string, (DateTime LastKnownWriteTimeUtc, Version? Version)> s_versionCache = new(StringComparer.OrdinalIgnoreCase /* Not strictly correct on *nix. Fix? */);

parent\parent\Resolvers\Microsoft.NET.Sdk.WorkloadManifestReader\SdkDirectoryWorkloadManifestProvider.cs (4)

22private static HashSet<string> _outdatedManifestIds = new(StringComparer.OrdinalIgnoreCase) { "microsoft.net.workload.android", "microsoft.net.workload.blazorwebassembly", "microsoft.net.workload.ios", 340var manifestIdsToManifests = new Dictionary<string, ReadableWorkloadManifest>(StringComparer.OrdinalIgnoreCase); 384Dictionary<string, string> directoriesWithManifests = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 469.ThenBy(kvp => kvp.Key, StringComparer.OrdinalIgnoreCase)

parent\parent\Resolvers\Microsoft.NET.Sdk.WorkloadManifestReader\WorkloadId.cs (1)

28public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(_id);

parent\parent\Resolvers\Microsoft.NET.Sdk.WorkloadManifestReader\WorkloadManifestReader.cs (1)

220var dependsOn = new Dictionary<string, FXVersion>(StringComparer.OrdinalIgnoreCase);

parent\parent\Resolvers\Microsoft.NET.Sdk.WorkloadManifestReader\WorkloadPackId.cs (1)

34public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(_id);

parent\parent\Resolvers\Microsoft.NET.Sdk.WorkloadManifestReader\WorkloadResolver.cs (1)

17private readonly Dictionary<string, (WorkloadManifest manifest, WorkloadManifestInfo info)> _manifests = new(StringComparer.OrdinalIgnoreCase);

parent\parent\Resolvers\Microsoft.NET.Sdk.WorkloadManifestReader\WorkloadSet.cs (1)

112var dictionary = ManifestVersions.ToDictionary(kvp => kvp.Key.ToString(), kvp => kvp.Value.Version + "/" + kvp.Value.FeatureBand, StringComparer.OrdinalIgnoreCase);

PrepareForReadyToRunCompilation.cs (4)

147var exclusionSet = ExcludeList == null ? null : new HashSet<string>(ExcludeList, StringComparer.OrdinalIgnoreCase); 148var compositeExclusionSet = PublishReadyToRunCompositeExclusions == null || !Crossgen2Composite ? null : new HashSet<string>(PublishReadyToRunCompositeExclusions, StringComparer.OrdinalIgnoreCase); 149var compositeRootSet = PublishReadyToRunCompositeRoots == null || !Crossgen2Composite ? null : new HashSet<string>(PublishReadyToRunCompositeRoots, StringComparer.OrdinalIgnoreCase); 150var partialSet = PublishReadyToRunPartialAssemblies == null ? null : new HashSet<string>(PublishReadyToRunPartialAssemblies, StringComparer.OrdinalIgnoreCase);

ProcessFrameworkReferences.cs (4)

224var frameworkReferenceMap = FrameworkReferences.ToDictionary(fr => fr.ItemSpec, StringComparer.OrdinalIgnoreCase); 228HashSet<string> unrecognizedRuntimeIdentifiers = new(StringComparer.OrdinalIgnoreCase); 615HashSet<string> knownRuntimeIdentifierPlatforms = new(StringComparer.OrdinalIgnoreCase); 672requiredRuntimePackLabels = new HashSet<string>(requiredLabelsMetadata.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries), StringComparer.OrdinalIgnoreCase);

ProduceContentAssets.cs (2)

122var preprocessorValues = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 128var duplicatedPreprocessorKeys = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

ProjectContext.cs (10)

ResolveFrameworkReferences.cs (2)

30var resolvedTargetingPacks = ResolvedTargetingPacks.ToDictionary(tp => tp.ItemSpec, StringComparer.OrdinalIgnoreCase); 31var resolvedRuntimePacks = ResolvedRuntimePacks.ToDictionary(rp => rp.GetMetadata(MetadataKeys.FrameworkName), StringComparer.OrdinalIgnoreCase);

ResolvePackageAssets.cs (13)

ResolvePackageDependencies.cs (3)

24private readonly Dictionary<string, string> _fileTypes = new(StringComparer.OrdinalIgnoreCase); 300.ToDictionary(pkg => pkg.Name, pkg => pkg.Version.ToNormalizedString(), StringComparer.OrdinalIgnoreCase); 308StringComparer.OrdinalIgnoreCase);

ResolveRuntimePackAssets.cs (3)

48HashSet<string> frameworkReferenceNames = new(FrameworkReferences.Select(item => item.ItemSpec), StringComparer.OrdinalIgnoreCase); 61HashSet<string> processedRuntimePackRoots = new(StringComparer.OrdinalIgnoreCase); 172var assetSubPaths = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

ResolveTargetingPackAssets.cs (4)

146StringComparer.OrdinalIgnoreCase); 262HashSet<string> frameworkReferenceNames = new(frameworkReferences.Select(fr => fr.Name), StringComparer.OrdinalIgnoreCase); 286HashSet<string> seenItemSpecs = new(StringComparer.OrdinalIgnoreCase); 389if (!assemblyProfiles.Contains(profile, StringComparer.OrdinalIgnoreCase))

ShowMissingWorkloads.cs (2)

20private static readonly HashSet<string> MauiWorkloadIds = new(StringComparer.OrdinalIgnoreCase) 23private static readonly HashSet<string> WasmWorkloadIds = new(StringComparer.OrdinalIgnoreCase)

SingleProjectInfo.cs (1)

76Dictionary<string, SingleProjectInfo> projectReferences = new(StringComparer.OrdinalIgnoreCase);

ValidateExecutableReferences.cs (1)

46Dictionary<string, string> projectAdditionalProperties = new(StringComparer.OrdinalIgnoreCase);

CacheFileReader.cs (3)

883 analyzerPaths.Sort(StringComparer.OrdinalIgnoreCase); 1175 HashSet<string> explicitBasenames = new(StringComparer.OrdinalIgnoreCase); 1199 HashSet<string> set = new(StringComparer.OrdinalIgnoreCase);

CachePathResolver.cs (1)

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

Donor\ProjectDataDonorIndex.cs (1)

23 RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase;

Model\ProjectDataSnapshotFactory.cs (3)

153 ImmutableDictionary.CreateBuilder<string, ImmutableArray<ProjectDataItem>>(StringComparer.OrdinalIgnoreCase); 209 .Distinct(StringComparer.OrdinalIgnoreCase) 210 .OrderBy(static c => c, StringComparer.OrdinalIgnoreCase)

StringComparers.cs (6)

DataModelSchemaGenerator.cs (3)

152 HashSet<string> propertyNames = new(StringComparer.OrdinalIgnoreCase); 201 HashSet<string> generatedNames = new(StringComparer.OrdinalIgnoreCase); 232 HashSet<string> metadataNames = new(StringComparer.OrdinalIgnoreCase);

AnalyzerConfigFileFilter.cs (1)

39 .OrderBy(static item => item, StringComparer.OrdinalIgnoreCase)

ForwardCompat.cs (6)

54 map[entry.Key] = new HashSet<string>(entry.Value, StringComparer.OrdinalIgnoreCase); 65 internal static readonly HashSet<string> KnownPropertyKeys = new HashSet<string>(ProjectProperties.All, StringComparer.OrdinalIgnoreCase); 526 block.AddRange(unknown.OrderBy(PropertyKey, StringComparer.OrdinalIgnoreCase)); 542 var present = new HashSet<string>(candidateProps.Lines.Select(PropertyKey), StringComparer.OrdinalIgnoreCase); 615 StringComparer.OrdinalIgnoreCase); 713 : string.Join("\n", sliceDimensionLines.OrderBy(l => l, StringComparer.OrdinalIgnoreCase));

ProjectDataBuildCompletionLogger.cs (1)

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

ProjectDataMerger.cs (6)

128 : new HashSet<string>(orderedTargetFrameworks, StringComparer.OrdinalIgnoreCase); 132 .GroupBy(candidate => GetSliceIdentity(candidate.Slice) ?? candidate.Path, StringComparer.OrdinalIgnoreCase) 135 .ThenBy(static candidate => GetSliceIdentity(candidate.Slice) ?? string.Empty, StringComparer.OrdinalIgnoreCase) 206 StringComparer.OrdinalIgnoreCase); 240 files.Sort(StringComparer.OrdinalIgnoreCase); 596 : string.Join("\n", slice.SliceDimensions.OrderBy(static line => line, StringComparer.OrdinalIgnoreCase));

ProjectDataWriter.cs (12)

src\roslyn\src\ProjectData\Microsoft.NET.ProjectData\Donor\ProjectDataDonorIndex.cs (1)

23 RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase;

StringComparers.cs (1)

12 RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase;

ValidateProjectDataPackagesTask.cs (16)

GenerateBlazorWebAssemblyBootJson50.cs (1)

110resourceData.satelliteResources ??= new Dictionary<string, ResourceHashesByNameDictionary>(StringComparer.OrdinalIgnoreCase);

parent\parent\StaticWebAssetsSdk\Tasks\Data\StaticWebAsset.cs (1)

1975_additionalCustomMetadata ??= new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

parent\parent\StaticWebAssetsSdk\Tasks\Utils\OSPath.cs (1)

9? StringComparer.OrdinalIgnoreCase :

MsDeploy\CommonUtility.cs (5)

274s_wellKnownNamesDict = new Dictionary<string, string?>(wellKnownNames.GetLength(0), StringComparer.OrdinalIgnoreCase); 299s_wellKnownNamesMsdeployDict = new Dictionary<string, string?>(wellKnownNames.GetLength(0), StringComparer.OrdinalIgnoreCase); 1126Dictionary<string, string> nameValueDictionary = new(parameters.Count, StringComparer.OrdinalIgnoreCase); 1177Dictionary<string, string> nameValueDictionary = new(parameters.Count, StringComparer.OrdinalIgnoreCase); 1420Dictionary<string, bool> FoundDictionary = new(optimizedValueList.Count, StringComparer.OrdinalIgnoreCase);

MsDeploy\VsMSDeployObject.cs (1)

344private Dictionary<string, string?> m_NameValueDictionary = new(10, StringComparer.OrdinalIgnoreCase);

Tasks\MsDeploy\CreateParameterFile.cs (1)

106= new(parameters.GetLength(0), StringComparer.OrdinalIgnoreCase);

Tasks\MsDeploy\MSDeploy.cs (1)

755Dictionary<string, string> nameValueDictionary = new(items.Count, StringComparer.OrdinalIgnoreCase);

Tasks\MsDeploy\VsMsdeploy.cs (1)

519ExtendedMetadata = new Dictionary<string, string?>(StringComparer.OrdinalIgnoreCase)

Data\StaticWebAsset.cs (1)

1975_additionalCustomMetadata ??= new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

Data\StaticWebAssetEndpoint.cs (1)

520_additionalCustomMetadata ??= new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

DefineStaticWebAssets.cs (1)

88_overrides = new HashSet<string>(PropertyOverrides ?? [], StringComparer.OrdinalIgnoreCase);

GeneratePackageAssetsManifestFile.cs (4)

115.OrderBy(i => parsedAssets[i].BasePath, StringComparer.OrdinalIgnoreCase) 116.ThenBy(i => parsedAssets[i].RelativePath, StringComparer.OrdinalIgnoreCase); 168foreach (var endpoint in endpoints.OrderBy(e => e.Route, StringComparer.OrdinalIgnoreCase) 169.ThenBy(e => e.AssetFile, StringComparer.OrdinalIgnoreCase))

GenerateStaticWebAssetEndpointsManifest.cs (1)

200Array.Sort(parsed, StringComparer.OrdinalIgnoreCase);

GenerateStaticWebAssetEndpointsPropsFile.cs (2)

48var orderedAssets = endpoints.OrderBy(e => e.Route, StringComparer.OrdinalIgnoreCase) 49.ThenBy(e => e.AssetFile, StringComparer.OrdinalIgnoreCase);

GenerateStaticWebAssetsManifest.cs (1)

166var result = new Dictionary<string, (StaticWebAsset First, StaticWebAsset Second, List<StaticWebAsset> Other)>(StringComparer.OrdinalIgnoreCase);

GenerateStaticWebAssetsPropsFile.cs (2)

84var orderedAssets = StaticWebAssets.OrderBy(e => e.GetMetadata(BasePath), StringComparer.OrdinalIgnoreCase) 85.ThenBy(e => e.GetMetadata(RelativePath), StringComparer.OrdinalIgnoreCase);

Legacy\GenerateStaticWebAssetsPropsFile50.cs (2)

57var orderedAssets = StaticWebAssets.OrderBy(e => e.GetMetadata(BasePath), StringComparer.OrdinalIgnoreCase) 58.ThenBy(e => e.GetMetadata(RelativePath), StringComparer.OrdinalIgnoreCase);

Legacy\ValidateStaticWebAssetsUniquePaths.cs (1)

24var assetsByWebRootPaths = new Dictionary<string, ITaskItem>(StringComparer.OrdinalIgnoreCase);

MergeStaticWebAssets.cs (1)

34.GroupBy(a => a.ComputeTargetPath("", '/'), StringComparer.OrdinalIgnoreCase)

OverrideHtmlAssetPlaceholders.cs (1)

265var mappings = new Dictionary<string, ResourceAsset>(StringComparer.OrdinalIgnoreCase);

ScopedCss\ConcatenateCssFiles.cs (1)

19Comparer<ITaskItem>.Create((x, y) => StringComparer.OrdinalIgnoreCase.Compare(x.GetMetadata("FullPath"), y.GetMetadata("FullPath")));

ScopedCss\ConcatenateCssFiles50.cs (1)

18Comparer<ITaskItem>.Create((x, y) => StringComparer.OrdinalIgnoreCase.Compare(x.GetMetadata("FullPath"), y.GetMetadata("FullPath")));

Utils\Globbing\StaticWebAssetGlobMatcherBuilder.cs (2)

105current.LiteralsDictionary ??= new(StringComparer.OrdinalIgnoreCase); 182current.ExtensionsDictionary ??= new(StringComparer.OrdinalIgnoreCase);

Utils\OSPath.cs (1)

9? StringComparer.OrdinalIgnoreCase :

SdkDirectoryWorkloadManifestProvider.cs (4)

22private static HashSet<string> _outdatedManifestIds = new(StringComparer.OrdinalIgnoreCase) { "microsoft.net.workload.android", "microsoft.net.workload.blazorwebassembly", "microsoft.net.workload.ios", 340var manifestIdsToManifests = new Dictionary<string, ReadableWorkloadManifest>(StringComparer.OrdinalIgnoreCase); 384Dictionary<string, string> directoriesWithManifests = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 469.ThenBy(kvp => kvp.Key, StringComparer.OrdinalIgnoreCase)

WorkloadId.cs (1)

28public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(_id);

WorkloadManifestReader.cs (1)

220var dependsOn = new Dictionary<string, FXVersion>(StringComparer.OrdinalIgnoreCase);

WorkloadPackId.cs (1)

34public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(_id);

WorkloadResolver.cs (1)

17private readonly Dictionary<string, (WorkloadManifest manifest, WorkloadManifestInfo info)> _manifests = new(StringComparer.OrdinalIgnoreCase);

WorkloadSet.cs (1)

112var dictionary = ManifestVersions.ToDictionary(kvp => kvp.Key.ToString(), kvp => kvp.Value.Version + "/" + kvp.Value.FeatureBand, StringComparer.OrdinalIgnoreCase);

CachingWorkloadResolver.cs (1)

45CachedResults = ImmutableDictionary.Create<string, ResolutionResult>(StringComparer.OrdinalIgnoreCase);

src\sourcelink\src\Common\AzureDevOps\AzureDevOpsUrlParser.cs (3)

42if (StringComparer.OrdinalIgnoreCase.Equals(parts[index], "DefaultCollection")) 50if (StringComparer.OrdinalIgnoreCase.Equals(parts[0], "e")) 95if (!parts.Take(virtualDirectoryParts.Length).SequenceEqual(virtualDirectoryParts, StringComparer.OrdinalIgnoreCase))

src\sourcelink\src\Common\AzureDevOps\AzureDevOpsUrlParser.cs (3)

42if (StringComparer.OrdinalIgnoreCase.Equals(parts[index], "DefaultCollection")) 50if (StringComparer.OrdinalIgnoreCase.Equals(parts[0], "e")) 95if (!parts.Take(virtualDirectoryParts.Length).SequenceEqual(virtualDirectoryParts, StringComparer.OrdinalIgnoreCase))

Alias\AliasModel.cs (1)

17CommandAliases = new Dictionary<string, IReadOnlyList<string>>(commandAliases.ToDictionary(x => x.Key, x => x.Value), StringComparer.OrdinalIgnoreCase);

Alias\AliasRegistry.cs (2)

29return new Dictionary<string, IReadOnlyList<string>>(_aliases!.CommandAliases, StringComparer.OrdinalIgnoreCase); 140IReadOnlyDictionary<string, IReadOnlyList<string>> commandAliases = ToStringListDictionary(parsed, StringComparer.OrdinalIgnoreCase, "CommandAliases");

ChoiceTemplateParameter.cs (3)

19private Dictionary<string, ParameterChoice> _choices = new(StringComparer.OrdinalIgnoreCase); 31_choices = parameter.Choices.ToDictionary(kvp => kvp.Key, kvp => kvp.Value, StringComparer.OrdinalIgnoreCase); 37_choices = choiceTemplateParameter.Choices.ToDictionary(kvp => kvp.Key, kvp => kvp.Value, StringComparer.OrdinalIgnoreCase);

CliEnvironment.cs (1)

15Dictionary<string, string> variables = new(StringComparer.OrdinalIgnoreCase)

Commands\create\CombinedChoiceTemplateParameter.cs (1)

15private Dictionary<string, ParameterChoice> _combinedParameters = new(StringComparer.OrdinalIgnoreCase);

Commands\create\InstantiateCommand.Help.cs (3)

124if (languages.Contains(defaultLanguage, StringComparer.OrdinalIgnoreCase)) 225supportedLanguages.Sort(StringComparer.OrdinalIgnoreCase); 261supportedTypes.Sort(StringComparer.OrdinalIgnoreCase);

Commands\create\InstantiateCommand.NoMatchHandling.cs (1)

208string allowedValues = string.Join(", ", option.AllowedValues.Select(l => $"'{l}'").OrderBy(l => l, StringComparer.OrdinalIgnoreCase));

Commands\create\InstantiateCommand.TabCompletion.cs (3)

25.OrderBy(c => c.Label, StringComparer.OrdinalIgnoreCase) 35.OrderBy(c => c.Label, StringComparer.OrdinalIgnoreCase) 97return distinctCompletions.OrderBy(c => c.Label, StringComparer.OrdinalIgnoreCase);

Commands\Extensions.cs (1)

71var invalidArguments = optionResult.Tokens.Where(token => !allowedValues.Append(allowedHiddenValue).Contains(token.Value, StringComparer.OrdinalIgnoreCase)).ToList();

TabularOutput\TemplateGroupDisplay.cs (10)

TemplateGroup.cs (7)

41.Distinct(StringComparer.OrdinalIgnoreCase) 64HashSet<string> shortNames = new(StringComparer.OrdinalIgnoreCase); 80HashSet<string?> language = new(StringComparer.OrdinalIgnoreCase); 96HashSet<string?> type = new(StringComparer.OrdinalIgnoreCase); 112HashSet<string> baselines = new(StringComparer.OrdinalIgnoreCase); 158HashSet<string> authors = new(StringComparer.OrdinalIgnoreCase); 188.GroupBy(x => x.GroupIdentity, x => !string.IsNullOrEmpty(x.GroupIdentity), StringComparer.OrdinalIgnoreCase)

TemplateListCoordinator.cs (1)

254return templates.Where(t => curatedGroupIdentityList.Contains(t.GroupIdentity, StringComparer.OrdinalIgnoreCase));

TemplatePackageCoordinator.cs (3)

733var templateGroupsCount = templates.GroupBy(x => x.GroupIdentity, x => !string.IsNullOrEmpty(x.GroupIdentity), StringComparer.OrdinalIgnoreCase).Count(); 793return template.ShortNameList.Contains(sourceIdentifier, StringComparer.OrdinalIgnoreCase); 815return template.ShortNameList.Contains(sourceIdentifier, StringComparer.OrdinalIgnoreCase);

TemplateResolution\CliFilters.cs (2)

111if (templateLanguages.Contains(language, StringComparer.OrdinalIgnoreCase)) 123if (templateLanguages.Contains(defaultLanguage, StringComparer.OrdinalIgnoreCase))

TemplateResolution\TemplateResolutionResult.cs (1)

343IEnumerable<string?> templateLanguages = highestPrecedenceTemplates.Select(t => t.GetLanguage()).Distinct(StringComparer.OrdinalIgnoreCase);

TemplateSearch\CliHostSearchCacheData.cs (1)

28var keys = new HashSet<string>(cacheObject.Select(p => p.Key), StringComparer.OrdinalIgnoreCase);

Constraints\HostConstraint.cs (1)

48foreach (HostInformation hostInfo in supportedHosts.Where(h => EnvironmentSettings.Host.FallbackHostTemplateConfigNames.Contains(h.HostName, StringComparer.OrdinalIgnoreCase)))

Constraints\OSConstraint.cs (1)

12private static readonly Dictionary<string, OSPlatform> PlatformMap = new Dictionary<string, OSPlatform>(StringComparer.OrdinalIgnoreCase)

DefaultEnvironment.cs (1)

56Dictionary<string, string> variables = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

ReflectionLoadProbingPath.cs (1)

15private static readonly ConcurrentDictionary<string, Assembly?> LoadedAssemblies = new ConcurrentDictionary<string, Assembly?>(StringComparer.OrdinalIgnoreCase);

Settings\LocalizationCacheKeyComparer.cs (2)

19return (StringComparer.OrdinalIgnoreCase.GetHashCode(obj.Key) * 17) + 20StringComparer.OrdinalIgnoreCase.GetHashCode(obj.Value);

Settings\TemplateCache.cs (1)

247if (availableLocalizations.Contains(currentCulture.Name, StringComparer.OrdinalIgnoreCase))

Settings\TemplateInfoReader.cs (2)

284choices = new Dictionary<string, ParameterChoice>(StringComparer.OrdinalIgnoreCase); 328choices = new Dictionary<string, ParameterChoice>(StringComparer.OrdinalIgnoreCase);

Template\WellKnownSearchFilters.cs (2)

94if (template.Classifications?.Contains(tagFilter, StringComparer.OrdinalIgnoreCase) ?? false) 164if (!template.Classifications.Contains(part, StringComparer.OrdinalIgnoreCase))

VirtualEnvironment.cs (1)

27Dictionary<string, string> variables = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

ConfigModel\GeneratedSymbol.cs (2)

42Parameters = jObject.ToJsonNodeStringDictionary(StringComparer.OrdinalIgnoreCase, nameof(Parameters)); 63public IReadOnlyDictionary<string, string> Parameters { get; internal init; } = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

ConfigModel\ParameterSymbol.cs (1)

146internal init => _choices = value?.CloneIfDifferentComparer(StringComparer.OrdinalIgnoreCase);

ConfigModel\PostActionModel.cs (1)

120Dictionary<string, string> args = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

ConfigModel\SymbolValueFormsModel.cs (1)

56if (addIdentity && !globalForms.Contains(IdentityValueFormFactory.FormIdentifier, StringComparer.OrdinalIgnoreCase))

ConfigModel\TemplateConfigModel.cs (3)

101_tags = source.ToStringDictionary(StringComparer.OrdinalIgnoreCase, "tags"); 165IReadOnlyDictionary<string, JsonNode> allSpecialOpsConfig = source.ToJsonNodeDictionary(StringComparer.OrdinalIgnoreCase, nameof(SpecialCustomOperations)); 542IReadOnlyDictionary<string, JsonNode> templateDefinedForms = source.ToJsonNodeDictionary(StringComparer.OrdinalIgnoreCase, nameof(Forms));

PostAction.cs (1)

87processedArgs[arg.Key] = model.ApplyFileRenamesToArgs.Contains(arg.Key, StringComparer.OrdinalIgnoreCase)

ValueFormRegistry.cs (1)

37internal static IReadOnlyDictionary<string, IValueFormFactory> FormLookup => AllForms.ToDictionary(ff => ff.Identifier, ff => ff, StringComparer.OrdinalIgnoreCase);

CacheTag.cs (1)

20Choices = choices.CloneIfDifferentComparer(StringComparer.OrdinalIgnoreCase);

TemplateDiscoveryMetadata\BlobStorageTemplateInfo.cs (3)

258Dictionary<string, ParameterChoice> choicesAndDescriptions = new Dictionary<string, ParameterChoice>(StringComparer.OrdinalIgnoreCase); 259Dictionary<string, string> legacyChoices = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 363Dictionary<string, ParameterChoice> choices = new Dictionary<string, ParameterChoice>(StringComparer.OrdinalIgnoreCase);

TemplateDiscoveryMetadata\LegacySearchCacheReader.cs (2)

212additionalData = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase); 225Dictionary<string, object> workingAdditionalData = new(StringComparer.OrdinalIgnoreCase);

TemplateSearchCache\TemplateSearchCache.cs (1)

15TemplatePackages = data.OrderBy(x => x.Name, StringComparer.OrdinalIgnoreCase).ToArray();

TemplateSearchCache\TemplateSearchCache.Json.cs (1)

78Dictionary<string, object> additionalData = new(StringComparer.OrdinalIgnoreCase);

Helpers\MicrosoftTestingPlatformDetector.cs (1)

31private static readonly ConcurrentDictionary<string, bool> Cache = new(StringComparer.OrdinalIgnoreCase);

Client\TestLoggerManager.cs (2)

686? new Dictionary<string, string?>(parameters, StringComparer.OrdinalIgnoreCase) 687: new Dictionary<string, string?>(StringComparer.OrdinalIgnoreCase);

DataCollection\InProcDataCollectionExtensionManager.cs (1)

67CodeBasePaths = new HashSet<string?>(StringComparer.OrdinalIgnoreCase) { _defaultCodeBase };

Discovery\DiscovererEnumerator.cs (3)

294if (Constants.DefaultAdapters.Contains(discoverer.Metadata.DefaultExecutorUri.ToString(), StringComparer.OrdinalIgnoreCase)) 409StringComparer.OrdinalIgnoreCase)); 428.Except(matchingSources, StringComparer.OrdinalIgnoreCase)

Discovery\DiscoveryManager.cs (1)

248var verifiedSources = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

Execution\BaseRunTests.cs (1)

509if (!CrossPlatEngine.Constants.DefaultAdapters.Contains(executor.Metadata.ExtensionUri, StringComparer.OrdinalIgnoreCase))

Condition.cs (1)

264if (properties.Contains(Name, StringComparer.OrdinalIgnoreCase))

FastFilter.cs (2)

208private readonly Dictionary<string, ISet<string>> _filterDictionaryBuilder = new Dictionary<string, ISet<string>>(StringComparer.OrdinalIgnoreCase); 279values = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

Hosting\DotnetTestHostManager.cs (1)

243startInfo.EnvironmentVariables = environmentVariables ?? new Dictionary<string, string?>(StringComparer.OrdinalIgnoreCase);

DataCollection\DataCollectionManager.cs (2)

181var executionEnvironmentVariables = new Dictionary<string, string?>(StringComparer.OrdinalIgnoreCase); 655var dataCollectorEnvironmentVariable = new Dictionary<string, DataCollectionEnvironmentVariable>(StringComparer.OrdinalIgnoreCase);

ExtensionFramework\TestPluginCache.cs (1)

433.Distinct(StringComparer.OrdinalIgnoreCase).ToList();

src\vstest\src\Microsoft.TestPlatform.Filter.Source\Condition.cs (1)

264if (properties.Contains(Name, StringComparer.OrdinalIgnoreCase))

src\vstest\src\Microsoft.TestPlatform.Filter.Source\FastFilter.cs (2)

206private readonly ImmutableDictionary<string, ImmutableHashSet<string>.Builder>.Builder _filterDictionaryBuilder = ImmutableDictionary.CreateBuilder<string, ImmutableHashSet<string>.Builder>(StringComparer.OrdinalIgnoreCase); 277values = ImmutableHashSet.CreateBuilder<string>(StringComparer.OrdinalIgnoreCase);

ObjectModel\TestResult.cs (1)

199private readonly SortedList<string, object?> _resultFiles = new(StringComparer.OrdinalIgnoreCase);

Nuget.Frameworks\CompatibilityProvider.cs (4)

187result = result && StringComparer.OrdinalIgnoreCase.Equals(target.Platform, "android"); 191result = result && StringComparer.OrdinalIgnoreCase.Equals(target.Platform, "tizen"); 202&& StringComparer.OrdinalIgnoreCase.Equals(target.Profile, candidate.Profile); 207&& StringComparer.OrdinalIgnoreCase.Equals(target.Platform, candidate.Platform)

Nuget.Frameworks\FrameworkNameProvider.cs (23)

Nuget.Frameworks\FrameworkRange.cs (2)

88return StringComparer.OrdinalIgnoreCase.Equals(x.Framework, y.Framework) 89&& (StringComparer.OrdinalIgnoreCase.Equals(x.Profile, y.Profile));

Nuget.Frameworks\FrameworkRangeComparer.cs (1)

34return StringComparer.OrdinalIgnoreCase.Equals(x.FrameworkIdentifier, y.FrameworkIdentifier) &&

Nuget.Frameworks\FrameworkReducer.cs (8)

Nuget.Frameworks\HashCodeCombiner.cs (1)

81AddHashCode(StringComparer.OrdinalIgnoreCase.GetHashCode(s));

Nuget.Frameworks\NuGetFramework.cs (4)

68IsNet5Era = (_frameworkVersion.Major >= Version5 && StringComparer.OrdinalIgnoreCase.Equals(FrameworkConstants.FrameworkIdentifiers.NetCoreApp, _frameworkIdentifier)); 246var sortedFrameworks = required.Select(e => e.GetShortFolderName(mappings)).OrderBy(e => e, StringComparer.OrdinalIgnoreCase); 336get { return StringComparer.OrdinalIgnoreCase.Equals(Framework, FrameworkConstants.FrameworkIdentifiers.Portable) && Version.Major < 5; } 498StringComparer.OrdinalIgnoreCase);

Nuget.Frameworks\NuGetFrameworkFactory.cs (10)

Nuget.Frameworks\NuGetFrameworkFullComparer.cs (3)

36&& StringComparer.OrdinalIgnoreCase.Equals(x.Framework, y.Framework) 37&& StringComparer.OrdinalIgnoreCase.Equals(x.Profile, y.Profile) 38&& StringComparer.OrdinalIgnoreCase.Equals(x.Platform, y.Platform)

Nuget.Frameworks\NuGetFrameworkNameComparer.cs (1)

36return StringComparer.OrdinalIgnoreCase.Equals(x.Framework, y.Framework);

Nuget.Frameworks\NuGetFrameworkSorter.cs (3)

69var result = StringComparer.OrdinalIgnoreCase.Compare(x.Framework, y.Framework); 83result = StringComparer.OrdinalIgnoreCase.Compare(x.Profile, y.Profile); 90result = StringComparer.OrdinalIgnoreCase.Compare(x.Platform, y.Platform);

Nuget.Frameworks\NuGetFrameworkUtility.cs (1)

132&& StringComparer.OrdinalIgnoreCase.Equals(

XmlTransforms.cs (1)

551Dictionary<string, string> paramDictionary = new Dictionary<string, string>(4, StringComparer.OrdinalIgnoreCase);

Mono.Cecil\BaseAssemblyResolver.cs (1)

189 var result = new Dictionary<string, string> (StringComparer.OrdinalIgnoreCase);

CommandLine\CommandLineSwitches.cs (2)

610commandLineA.Sort(StringComparer.OrdinalIgnoreCase); 611commandLineB.Sort(StringComparer.OrdinalIgnoreCase);

FilteredBinlogReplay.cs (1)

168HashSet<string> outputPaths = new(NativeMethodsShared.IsWindows ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal);

OutOfProcTaskAppDomainWrapperBase.cs (1)

453IDictionary<string, Object> finalParameterValues = new Dictionary<string, Object>(StringComparer.OrdinalIgnoreCase);

OutOfProcTaskHostNode.cs (3)

1196StringComparer.OrdinalIgnoreCase); 1893updatedEnvironment = new Dictionary<string, string>(environment, StringComparer.OrdinalIgnoreCase); 1953updatedEnvironment ??= new Dictionary<string, string>(environment, StringComparer.OrdinalIgnoreCase);

parent\Shared\TaskHostBuildRequest.cs (2)

87result[i] = new Dictionary<string, string>(globalProperties[i].Count, StringComparer.OrdinalIgnoreCase); 176translator.TranslateDictionary(ref dict, StringComparer.OrdinalIgnoreCase);

parent\Shared\TaskHostBuildResponse.cs (4)

64var dict = new Dictionary<string, ITaskItem[]>(projectOutputs.Count, StringComparer.OrdinalIgnoreCase); 95var dict = new Dictionary<string, TaskParameter>(projectOutputs?.Count ?? 0, StringComparer.OrdinalIgnoreCase); 139translator.TranslateDictionary(ref dict, StringComparer.OrdinalIgnoreCase, TaskParameter.FactoryForDeserialization); 148translator.TranslateDictionary(ref dict, StringComparer.OrdinalIgnoreCase, TaskParameter.FactoryForDeserialization);

parent\Shared\TaskHostConfiguration.cs (9)

parent\Shared\TaskHostTaskComplete.cs (5)

126_taskOutputParameters = new Dictionary<string, TaskParameter>(StringComparer.OrdinalIgnoreCase); 204_taskOutputParameters = new Dictionary<string, TaskParameter>(StringComparer.OrdinalIgnoreCase); 263translator.TranslateDictionary(ref _taskOutputParameters, StringComparer.OrdinalIgnoreCase, TaskParameter.FactoryForDeserialization); 282translator.TranslateDictionary(ref _buildProcessEnvironment, StringComparer.OrdinalIgnoreCase); 287translator.TranslateDictionary(ref _buildProcessEnvironment, StringComparer.OrdinalIgnoreCase);

parent\Shared\TypeLoader.cs (3)

695_typeNameToType = new(StringComparer.OrdinalIgnoreCase); 696_publicTypeNameToType = new Dictionary<string, Type>(StringComparer.OrdinalIgnoreCase); 697_publicTypeNameToLoadedType = new(StringComparer.OrdinalIgnoreCase);

TaskHostEnvironment.cs (1)

29Dictionary<string, KeyValuePair<string?, string?>> mismatches = new(StringComparer.OrdinalIgnoreCase);

XMake.cs (3)

3338ISet<string> warningSwitches = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 3638HashSet<string> extensionsToIgnore = new HashSet<string>(projectsExtensionsToIgnore ?? [], StringComparer.OrdinalIgnoreCase); 3858Dictionary<string, string> properties = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

CheckForDuplicateNuGetItemsTask.cs (1)

49var itemGroups = Items.GroupBy(i => i.ItemSpec, StringComparer.OrdinalIgnoreCase);

GetCentralPackageVersionsTask.cs (1)

43var seenIds = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

GetGlobalPropertyValueTask.cs (1)

38var dictionaryWithOrdinal = globalProperties.ToDictionary(i => i.Key, i => i.Value, StringComparer.OrdinalIgnoreCase);

GetRestoreFrameworkReferencesTask.cs (1)

40var seenIds = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

GetRestorePackageDownloadsTask.cs (1)

40var seenIds = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

GetRestorePackageReferencesTask.cs (1)

40var seenIds = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

StaticGraphRestoreTaskBase.cs (2)

323Dictionary<string, string> newGlobalProperties = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 370return new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)

MSBuildStaticGraphRestore.cs (3)

331var result = new Dictionary<string, CentralPackageVersion>(StringComparer.OrdinalIgnoreCase); 407var result = new Dictionary<string, PrunePackageReference>(StringComparer.OrdinalIgnoreCase); 686return options.TryGetValue(name, out string value) && StringComparer.OrdinalIgnoreCase.Equals(value, bool.TrueString);

Program.cs (2)

147var properties = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 284globalProperties = new Dictionary<string, string>(capacity: count, StringComparer.OrdinalIgnoreCase);

ProjectItemInstanceEvaluatedIncludeComparer.cs (1)

43public int GetHashCode(IMSBuildItem obj) => StringComparer.OrdinalIgnoreCase.GetHashCode(obj.Identity);

RestoreProjectAdapter.cs (1)

22_targetFrameworks = new(StringComparer.OrdinalIgnoreCase);

PackTaskLogic.cs (6)

229var frameworksWithSuppressedDependencies = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 408var tfmSpecificRefs = new Dictionary<string, IList<string>>(StringComparer.OrdinalIgnoreCase); 634packArgs.Exclude = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 995var packageSpecificNoWarnProperties = new Dictionary<string, HashSet<(NuGetLogCode, NuGetFramework)>>(StringComparer.OrdinalIgnoreCase); 1146var dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 1196return new HashSet<string>(outputExtensions.Distinct(StringComparer.OrdinalIgnoreCase));

Commands\Package\PackageWithVersionRange.cs (1)

88hash.Add(obj.Id, StringComparer.OrdinalIgnoreCase);

Commands\Package\Update\PackageUpdateCommandRunner.cs (17)

Commands\Package\Update\PackageUpdateIO.cs (1)

401sourceMappedSources.AddRange(_enabledSources.Where(ps => allowedSources.Contains(ps.Name, StringComparer.OrdinalIgnoreCase)));

Commands\PackageReferenceCommands\AddPackageReferenceCommandRunner.cs (3)

210.Select(t => t.Graph.TargetAlias), StringComparer.OrdinalIgnoreCase); 217StringComparer.OrdinalIgnoreCase); 495StringComparer.OrdinalIgnoreCase);

Commands\PackageReferenceCommands\ListPackage\ListPackageCommandRunner.cs (1)

452List<string> allPackages = intermediateEnumerable.Select(p => p.Name).Distinct(StringComparer.OrdinalIgnoreCase).ToList();

Commands\Why\DependencyGraphFinder.cs (2)

35var result = new Dictionary<string, List<DependencyNode>?>(StringComparer.OrdinalIgnoreCase); 110.ToDictionary(l => Path.GetFullPath(Path.Combine(projectDirectory, l.Path)), l => l, StringComparer.OrdinalIgnoreCase);

Commands\Why\DependencyGraphPrinter.cs (2)

66foreach (var node in topLevelNodes.OrderByDescending(c => c.Id, StringComparer.OrdinalIgnoreCase)) 85foreach (var child in current.Node.Children.OrderByDescending(c => c.Id, StringComparer.OrdinalIgnoreCase))

Commands\Why\DependencyNode.cs (4)

41hash.Add(Id, StringComparer.OrdinalIgnoreCase); 42foreach (var child in Children.OrderBy(c => c.Id, StringComparer.OrdinalIgnoreCase)) 70hash.Add(Id, StringComparer.OrdinalIgnoreCase); 73foreach (var child in Children.OrderBy(c => c.Id, StringComparer.OrdinalIgnoreCase))

src\nuget-client\build\Shared\HashCodeCombiner.cs (1)

81AddHashCode(StringComparer.OrdinalIgnoreCase.GetHashCode(s));

Utility\MSBuildAPIUtility.cs (4)

89return StringComparer.OrdinalIgnoreCase.Equals( 311var globalProperties = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) 932var globalProperties = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) 997var globalProperties = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)

CommandArgs\PackArgs.cs (1)

21private readonly Dictionary<string, string> _properties = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

CommandRunners\LocalsCommandRunner.cs (1)

287foreach (var failedDelete in failedDeletes.OrderBy(f => f, StringComparer.OrdinalIgnoreCase))

CommandRunners\PackCommandRunner.cs (2)

31private static readonly HashSet<string> AllowedExtensions = new HashSet<string>(StringComparer.OrdinalIgnoreCase) 57private readonly HashSet<string> _excludes = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

PackagesLockFileBuilder.cs (1)

59dep => StringComparer.OrdinalIgnoreCase.Equals(dep.Name, library.Name));

PackCommand\Logging\PackageSpecificWarningProperties.cs (1)

64frameworksByLibraryId = new Dictionary<string, ISet<NuGetFramework>>(StringComparer.OrdinalIgnoreCase);

RestoreCommand\CompatibilityChecker.cs (2)

65var runtimeAssemblies = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 66var compileAssemblies = new Dictionary<string, LibraryIdentity>(StringComparer.OrdinalIgnoreCase);

RestoreCommand\ContentFiles\ContentFileUtils.cs (4)

41var groupsByLanguage = new Dictionary<string, List<ContentItemGroup>>(StringComparer.OrdinalIgnoreCase); 90var entryMappings = new Dictionary<string, List<ContentFilesEntry>>(StringComparer.OrdinalIgnoreCase); 91var languageMappings = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 111Dictionary<string, List<ContentFilesEntry>> relativePathToEntries = new(entryMappings.Count, StringComparer.OrdinalIgnoreCase);

RestoreCommand\DependencyGraphResolver.cs (3)

384if (StringComparer.OrdinalIgnoreCase.Equals(childLibraryDependency.Name, resolvedDependencyGraphItem.Item.Key.Name) || StringComparer.OrdinalIgnoreCase.Equals(childLibraryDependency.Name, rootGraphNode.Key.Name)) 1421if (StringComparer.OrdinalIgnoreCase.Equals(frameworkName.Framework, FrameworkConstants.FrameworkIdentifiers.NetCoreApp))

RestoreCommand\DependencyGraphResolver.DependencyGraphItemIndexer.cs (1)

60private readonly ConcurrentDictionary<string, LibraryDependencyIndex> _libraryDependencyTable = new ConcurrentDictionary<string, LibraryDependencyIndex>(StringComparer.OrdinalIgnoreCase);

RestoreCommand\Diagnostics\IndexedRestoreTargetGraph.cs (2)

19= new Dictionary<string, GraphItem<RemoteResolveResult>>(StringComparer.OrdinalIgnoreCase); 21private readonly HashSet<string> _idsWithErrors = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

RestoreCommand\Diagnostics\UnexpectedDependencyMessages.cs (7)

29var ignoreIds = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 78.Where(e => !ignoreIds.Contains(e.Child.Name, StringComparer.OrdinalIgnoreCase) 80.OrderBy(e => e.Child.Name, StringComparer.OrdinalIgnoreCase) 82.ThenBy(e => e.Parent.Name, StringComparer.OrdinalIgnoreCase) 149if (ignoreIds.Contains(dependency.Name, StringComparer.OrdinalIgnoreCase) 186.OrderBy(e => e.Name, StringComparer.OrdinalIgnoreCase) 202.OrderBy(e => e.Name, StringComparer.OrdinalIgnoreCase)

RestoreCommand\Diagnostics\UnresolvedMessages.cs (3)

123.OrderBy(e => e, StringComparer.OrdinalIgnoreCase)); 208.OrderBy(e => e, StringComparer.OrdinalIgnoreCase)); 281.ThenBy(e => e.Key.Source, StringComparer.OrdinalIgnoreCase)

RestoreCommand\LockFileBuilder.cs (2)

468var seen = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 554dependencyDictionary = rootNode.Item.Data.Dependencies.ToDictionary(x => x.Name, x => x, StringComparer.OrdinalIgnoreCase);

RestoreCommand\Logging\PackageSpecificWarningProperties.cs (2)

85frameworksByLibraryId = new Dictionary<string, ISet<string>>(StringComparer.OrdinalIgnoreCase); 91frameworks = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

RestoreCommand\Logging\TransitiveNoWarnUtils.cs (11)

RestoreCommand\Logging\WarningPropertiesCollection.cs (2)

214EqualityUtility.OrderedEquals(ProjectFrameworks, other.ProjectFrameworks, (fx) => fx, orderComparer: StringComparer.OrdinalIgnoreCase, StringComparer.OrdinalIgnoreCase);

RestoreCommand\MonoAndroidDeprecation.cs (2)

42return StringComparer.OrdinalIgnoreCase.Equals(framework.Framework, FrameworkConstants.FrameworkIdentifiers.NetCoreApp) 56&& StringComparer.OrdinalIgnoreCase.Equals(

RestoreCommand\RequestFactory\DependencyGraphSpecRequestProvider.cs (1)

150.Distinct(StringComparer.OrdinalIgnoreCase);

RestoreCommand\RequestFactory\MSBuildItemIdentityComparer.cs (1)

33return StringComparer.OrdinalIgnoreCase.GetHashCode(obj.Identity);

RestoreCommand\RestoreCommand.cs (13)

RestoreCommand\Utility\BuildAssetsUtils.cs (9)

RestoreCommand\Utility\IncludeFlagUtils.cs (2)

37var result = new Dictionary<string, LibraryIncludeFlags>(StringComparer.OrdinalIgnoreCase); 84var unifiedNodes = new Dictionary<string, GraphItem<RemoteResolveResult>>(StringComparer.OrdinalIgnoreCase);

RestoreCommand\Utility\LockFileUtils.cs (4)

446var referenceFilter = new HashSet<string>(referenceSet.Items, StringComparer.OrdinalIgnoreCase); 586var fileLookup = new Dictionary<string, ProjectRestoreMetadataFile>(StringComparer.OrdinalIgnoreCase); 873var ordered = items.OrderBy(c => c.Path, StringComparer.OrdinalIgnoreCase) 976.ThenBy(item => item.Path, StringComparer.OrdinalIgnoreCase)

RestoreCommand\Utility\MSBuildRestoreUtility.cs (10)

RestoreCommand\Utility\PackageSpecFactory.cs (2)

695var result = new Dictionary<string, PrunePackageReference>(StringComparer.OrdinalIgnoreCase); 824var result = new Dictionary<string, CentralPackageVersion>(StringComparer.OrdinalIgnoreCase);

RestoreCommand\Utility\ProjectItemIdentityComparer.cs (1)

15private IEqualityComparer<string> _identityComparer = StringComparer.OrdinalIgnoreCase;

RestoreCommand\Utility\SpecValidationUtility.cs (3)

226if (!EqualityUtility.OrderedEquals(aliases, spec.RestoreMetadata.OriginalTargetFrameworks, e => e, StringComparer.OrdinalIgnoreCase, StringComparer.OrdinalIgnoreCase)) 240var uniqueAliases = new HashSet<string>(aliases, StringComparer.OrdinalIgnoreCase);

RestoreCommand\Utility\ToolRestoreUtility.cs (2)

103foreach (var toolIdGroup in tools.GroupBy(e => GetToolIdOrNullFromSpec(e.Request.Project), StringComparer.OrdinalIgnoreCase)) 173.FirstOrDefault(l => StringComparer.OrdinalIgnoreCase.Equals(toolId, l.Name));

src\nuget-client\build\Shared\HashCodeCombiner.cs (1)

81AddHashCode(StringComparer.OrdinalIgnoreCase.GetHashCode(s));

Utility\MSBuildProjectFrameworkUtility.cs (2)

138var frameworks = new SortedSet<string>(StringComparer.OrdinalIgnoreCase); 241if (StringComparer.OrdinalIgnoreCase.Equals(effectivePlatformIdentifier, "UAP"))

AuthTypeFilteredCredentials.cs (1)

42return authType == null || !AuthTypes.Any() || AuthTypes.Any(x => StringComparer.OrdinalIgnoreCase.Equals(x, authType))

ComparisonUtility.cs (1)

10public static readonly StringComparer FrameworkReferenceNameComparer = StringComparer.OrdinalIgnoreCase;

PathUtil\PathUtility.cs (1)

29return StringComparer.OrdinalIgnoreCase;

UriUtility.cs (1)

167if (StringComparer.OrdinalIgnoreCase.Equals(uri.Host, "nuget.org")

ClientCertificate\ClientCertificateProvider.cs (1)

67var groupedByPackageSourceItems = result.ToLookup(i => i.PackageSource, i => i, StringComparer.OrdinalIgnoreCase);

PackageSource\MinPublishAgeExceptions.cs (1)

34var itemsByPattern = new Dictionary<string, MinPublishAgeExceptionItem>(items.Count, StringComparer.OrdinalIgnoreCase);

PackageSource\PackageSourceProvider.cs (7)

98var packageSourceLookup = new Dictionary<string, IndexedPackageSource>(StringComparer.OrdinalIgnoreCase); 135var packageSourceLookup = new Dictionary<string, IndexedPackageSource>(StringComparer.OrdinalIgnoreCase); 820existingDisabledSourcesLookup = existingDisabledSources?.ToDictionary(setting => setting.Key, StringComparer.OrdinalIgnoreCase); 825.GroupBy(s => s.Key, StringComparer.OrdinalIgnoreCase) 836var existingCredentialsLookup = existingCredentials?.ToDictionary(setting => setting.ElementName, StringComparer.OrdinalIgnoreCase); 878var existingsourceCredentialsLookup = sourceCredentialsSettings?.ToDictionary(setting => setting.ElementName, StringComparer.OrdinalIgnoreCase); 981var existingSettingsLookup = new Dictionary<string, SourceItem>(StringComparer.OrdinalIgnoreCase);

Settings\Items\MinPublishAgeExceptionItem.cs (1)

105public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Pattern);

Settings\Items\PackagePatternItem.cs (1)

66public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Pattern);

Settings\Items\StoreClientCertItem.cs (3)

170StringComparer.OrdinalIgnoreCase) 185StringComparer.OrdinalIgnoreCase) 207StringComparer.OrdinalIgnoreCase)

Settings\SettingElement.cs (2)

73MutableAttributes = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 105MutableAttributes = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

Settings\SettingFactory.cs (3)

127return StringComparer.OrdinalIgnoreCase.Compare( 144return StringComparer.OrdinalIgnoreCase.Equals( 156return StringComparer.OrdinalIgnoreCase.GetHashCode(obj.ElementName + string.Join("", obj.Attributes.Select(a => a.Value)));

src\nuget-client\build\Shared\HashCodeCombiner.cs (1)

81AddHashCode(StringComparer.OrdinalIgnoreCase.GetHashCode(s));

PluginCredentialProviderBuilder.cs (1)

78.SelectMany(g => g.OrderBy(Path.GetFileName, StringComparer.OrdinalIgnoreCase))

GraphModel\GraphOperations.cs (3)

149if (sideNode != node && StringComparer.OrdinalIgnoreCase.Equals(sideNode.Key.Name, node.Key.Name)) 228if (StringComparer.OrdinalIgnoreCase.Equals(candidateNode.Key.Name, item)) 782return new Dictionary<string, GraphNode<TItem>>(StringComparer.OrdinalIgnoreCase);

GraphModel\Tracker.cs (1)

13private readonly Dictionary<string, Entry> _entryByLibraryName = new(StringComparer.OrdinalIgnoreCase);

LibraryRangeCacheKey.cs (1)

55&& StringComparer.OrdinalIgnoreCase.Equals(Alias, other.Alias);

LockFileCacheKey.cs (1)

53&& StringComparer.OrdinalIgnoreCase.Equals(TargetAlias, other.TargetAlias);

Remote\RemoteDependencyWalker.cs (7)

46var result = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 152if (StringComparer.OrdinalIgnoreCase.Equals(dependency.Name, currentLibraryRange.Name)) 278if (StringComparer.OrdinalIgnoreCase.Equals(runtimeDependency.Id, libraryRange.Name)) 385if (StringComparer.OrdinalIgnoreCase.Equals(item.Data.Match.Library.Name, childDependencyLibrary.Name)) 490int compareResult = StringComparer.OrdinalIgnoreCase.Compare( 636_transitiveCentralPackageVersions = new Dictionary<string, List<GraphNode<RemoteResolveResult>>>(StringComparer.OrdinalIgnoreCase); 683return StringComparer.OrdinalIgnoreCase.GetHashCode(obj.Name);

Remote\RemoteWalkContext.cs (1)

83if (StringComparer.OrdinalIgnoreCase.Equals(sources[j], current.Source?.Name))

ResolverUtility.cs (1)

234var library = libraries.FirstOrDefault(lib => StringComparer.OrdinalIgnoreCase.Equals(lib.Name, libraryRange.Name));

src\nuget-client\build\Shared\HashCodeCombiner.cs (1)

81AddHashCode(StringComparer.OrdinalIgnoreCase.GetHashCode(s));

comparers\FrameworkRangeComparer.cs (1)

31return StringComparer.OrdinalIgnoreCase.Equals(x.FrameworkIdentifier, y.FrameworkIdentifier) &&

comparers\NuGetFrameworkFullComparer.cs (3)

33&& StringComparer.OrdinalIgnoreCase.Equals(x.Framework, y.Framework) 34&& StringComparer.OrdinalIgnoreCase.Equals(x.Profile, y.Profile) 35&& StringComparer.OrdinalIgnoreCase.Equals(x.Platform, y.Platform)

comparers\NuGetFrameworkNameComparer.cs (1)

33return StringComparer.OrdinalIgnoreCase.Equals(x.Framework, y.Framework);

comparers\NuGetFrameworkSorter.cs (3)

66var result = StringComparer.OrdinalIgnoreCase.Compare(x.Framework, y.Framework); 80result = StringComparer.OrdinalIgnoreCase.Compare(x.Profile, y.Profile); 87result = StringComparer.OrdinalIgnoreCase.Compare(x.Platform, y.Platform);

CompatibilityListProvider.cs (1)

45.GroupBy(f => f.Framework, StringComparer.OrdinalIgnoreCase)

CompatibilityProvider.cs (5)

187result = result && StringComparer.OrdinalIgnoreCase.Equals(target.Platform, "android"); 191result = result && StringComparer.OrdinalIgnoreCase.Equals(target.Platform, "tizen"); 202&& StringComparer.OrdinalIgnoreCase.Equals(target.Profile, candidate.Profile); 216&& StringComparer.OrdinalIgnoreCase.Equals(target.Platform, "windows") 226&& StringComparer.OrdinalIgnoreCase.Equals(target.Platform, candidate.Platform)

FrameworkNameProvider.cs (23)

FrameworkRange.cs (2)

88return StringComparer.OrdinalIgnoreCase.Equals(x.Framework, y.Framework) 89&& (StringComparer.OrdinalIgnoreCase.Equals(x.Profile, y.Profile));

FrameworkReducer.cs (8)

NuGetFramework.cs (4)

68IsNet5Era = (_frameworkVersion.Major >= Version5 && StringComparer.OrdinalIgnoreCase.Equals(FrameworkConstants.FrameworkIdentifiers.NetCoreApp, _frameworkIdentifier)); 246var sortedFrameworks = required.Select(e => e.GetShortFolderName(mappings)).OrderBy(e => e, StringComparer.OrdinalIgnoreCase); 337get { return StringComparer.OrdinalIgnoreCase.Equals(Framework, FrameworkConstants.FrameworkIdentifiers.Portable) && Version.Major < 5; } 499StringComparer.OrdinalIgnoreCase);

NuGetFrameworkFactory.cs (10)

NuGetFrameworkUtility.cs (1)

129&& StringComparer.OrdinalIgnoreCase.Equals(

src\nuget-client\build\Shared\HashCodeCombiner.cs (1)

81AddHashCode(StringComparer.OrdinalIgnoreCase.GetHashCode(s));

CentralPackageVersionNameComparer.cs (1)

34return StringComparer.OrdinalIgnoreCase.GetHashCode(obj.Name);

LibraryType.cs (2)

11private static ConcurrentDictionary<string, LibraryType> _knownLibraryTypes = new ConcurrentDictionary<string, LibraryType>(StringComparer.OrdinalIgnoreCase); 104return StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

src\nuget-client\build\Shared\HashCodeCombiner.cs (1)

81AddHashCode(StringComparer.OrdinalIgnoreCase.GetHashCode(s));

InstallationCompatibility.cs (1)

50StringComparer.OrdinalIgnoreCase);

NuGetPackageManager.cs (12)

PackageDownloader.cs (1)

134!configuredPackageSources.Contains(source.PackageSource.Name, StringComparer.OrdinalIgnoreCase))

Projects\MSBuildNuGetProject.cs (1)

626Constants.AssemblyReferencesExtensions.Contains(Path.GetExtension(filePath), StringComparer.OrdinalIgnoreCase);

Resolution\GatherExceptionHelpers.cs (2)

47&& StringComparer.OrdinalIgnoreCase.Equals(target, reference.PackageIdentity.Id)); 57var packagesForId = availablePackages.Where(package => StringComparer.OrdinalIgnoreCase.Equals(target, package.Id));

Resolution\PrunePackageTree.cs (12)

Resolution\ResolverGather.cs (7)

33private readonly HashSet<string> _idsSearched = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 35private readonly ConcurrentDictionary<string, TimeSpan> _timeTaken = new ConcurrentDictionary<string, TimeSpan>(StringComparer.OrdinalIgnoreCase); 98var allPrimaryTargets = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 175var missingIds = closureIds.Except(_idsSearched, StringComparer.OrdinalIgnoreCase); 325var closureIds = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 339StringComparer.OrdinalIgnoreCase); 570!configuredPackageSources.Contains(source.Source.PackageSource.Name, StringComparer.OrdinalIgnoreCase))

src\nuget-client\build\Shared\HashCodeCombiner.cs (1)

81AddHashCode(StringComparer.OrdinalIgnoreCase.GetHashCode(s));

Utility\JsonConfigUtility.cs (2)

132if (StringComparer.OrdinalIgnoreCase.Equals(dependencyProperty.Name, packageId)) 212var sortedChildren = parent.Children().OrderByDescending(child => GetChildKey(child), StringComparer.OrdinalIgnoreCase);

Core\comparers\PackageDependencyComparer.cs (5)

49var result = StringComparer.OrdinalIgnoreCase.Equals(x.Id, y.Id); 58result = x.Include.OrderedEquals(y.Include, s => s, StringComparer.OrdinalIgnoreCase, StringComparer.OrdinalIgnoreCase); 63result = x.Exclude.OrderedEquals(y.Exclude, s => s, StringComparer.OrdinalIgnoreCase, StringComparer.OrdinalIgnoreCase);

Core\comparers\PackageIdentityComparer.cs (3)

84&& StringComparer.OrdinalIgnoreCase.Equals(x.Id, y.Id); 99combiner.AddObject(obj.Id, StringComparer.OrdinalIgnoreCase); 125int result = StringComparer.OrdinalIgnoreCase.Compare(x.Id, y.Id);

Core\NuspecCoreReaderBase.cs (1)

164var metadataValues = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

Core\PackageDependencyGroup.cs (1)

94&& Packages.OrderedEquals(other.Packages, p => p.Id, StringComparer.OrdinalIgnoreCase);

Core\PackageDependencyInfo.cs (1)

82return string.Format(CultureInfo.InvariantCulture, "{0} : {1}", base.ToString(), string.Join(", ", Dependencies.Select(e => e.ToString()).OrderBy(e => e, StringComparer.OrdinalIgnoreCase)));

Core\PackageType.cs (2)

22public static readonly StringComparer PackageTypeNameComparer = StringComparer.OrdinalIgnoreCase; 86combiner.AddObject(Name, StringComparer.OrdinalIgnoreCase);

Core\RepositoryMetadata.cs (1)

79combiner.AddObject(Type, StringComparer.OrdinalIgnoreCase);

NuspecReader.cs (5)

248items = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 260var group = new FrameworkSpecificGroup(framework, items.OrderBy(item => item, StringComparer.OrdinalIgnoreCase)); 565return StringComparer.OrdinalIgnoreCase.Equals(bool.TrueString, GetMetadataValue("requireLicenseAcceptance")); 645var set = new HashSet<string>(splitFlags.Length, StringComparer.OrdinalIgnoreCase); 658result.Sort(StringComparer.OrdinalIgnoreCase);

PackageCreation\Authoring\Manifest.cs (1)

299var dependencyHash = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

PackageCreation\Authoring\ManifestSchemaUtility.cs (1)

120return VersionToSchemaMappings.Contains(schemaNamespace, StringComparer.OrdinalIgnoreCase);

PackageCreation\Authoring\PackageBuilder.cs (4)

157Properties = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); 506select Path.GetFileName(file.Path), StringComparer.OrdinalIgnoreCase); 694var set = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 941var extensions = new SortedSet<string>(StringComparer.OrdinalIgnoreCase);

PackageCreation\Extensions\FrameworksExtensions.cs (1)

16bool isNet5Era = (self.Version.Major >= 5 && StringComparer.OrdinalIgnoreCase.Equals(FrameworkConstants.FrameworkIdentifiers.NetCoreApp, self.Framework));

PackageFileExtractor.cs (2)

47if (refAndLibFiles.Contains(dllFile, StringComparer.OrdinalIgnoreCase)) 55if (refAndLibFiles.Contains(resourceDll, StringComparer.OrdinalIgnoreCase))

PackageFolderReader.cs (1)

180&& !StringComparer.OrdinalIgnoreCase.Equals(parent.FullName, root.FullName))

PackageReaderBase.cs (7)

297if (referenceGroup.Items.Any(s => StringComparer.OrdinalIgnoreCase.Equals(s, file))) 448yield return new FrameworkSpecificGroup(framework, items.OrderBy(e => e, StringComparer.OrdinalIgnoreCase)); 498return StringComparer.OrdinalIgnoreCase.Equals(file, string.Format(CultureInfo.InvariantCulture, "{0}.targets", packageId)) 499|| StringComparer.OrdinalIgnoreCase.Equals(file, string.Format(CultureInfo.InvariantCulture, "{0}.props", packageId)); 511if (StringComparer.OrdinalIgnoreCase.Equals(extension, ".dll")) 518else if (StringComparer.OrdinalIgnoreCase.Equals(extension, ".winmd")) 522else if (StringComparer.OrdinalIgnoreCase.Equals(extension, ".exe"))

PackageReaderExtensions.cs (1)

41.Contains(packageLanguage, StringComparer.OrdinalIgnoreCase));

PackagesConfig.cs (1)

67if (StringComparer.OrdinalIgnoreCase.Equals(value, "true"))

PackagesConfigReader.cs (1)

205var duplicates = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

Rules\InvalidFrameworkFolderRule.cs (1)

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

Rules\InvalidUndottedFrameworkRule.cs (2)

192var set = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 289StringComparer.OrdinalIgnoreCase.Equals(FrameworkConstants.FrameworkIdentifiers.NetCoreApp, framework.Framework))

RuntimeModel\RuntimeDependencySet.cs (3)

34: this(id, dependencies?.ToDictionary(d => d.Id, StringComparer.OrdinalIgnoreCase)) 57&& Dependencies.OrderedEquals(other.Dependencies, p => p.Key, StringComparer.OrdinalIgnoreCase); 68combiner.AddObject(Id, StringComparer.OrdinalIgnoreCase);

RuntimeModel\RuntimeDescription.cs (3)

46runtimeDependencySets?.ToDictionary(d => d.Id, StringComparer.OrdinalIgnoreCase)) 71&& RuntimeDependencySets.OrderedEquals(other.RuntimeDependencySets, p => p.Key, StringComparer.OrdinalIgnoreCase); 101var newSets = new Dictionary<string, RuntimeDependencySet>(StringComparer.OrdinalIgnoreCase);

RuntimeModel\RuntimeGraph.cs (3)

264StringComparer.OrdinalIgnoreCase); 399&& StringComparer.OrdinalIgnoreCase.Equals(PackageId, other.PackageId); 407hashCode.AddObject(PackageId, StringComparer.OrdinalIgnoreCase);

Signing\Authoring\SigningOptions.cs (1)

127if (StringComparer.OrdinalIgnoreCase.Equals(NormalizeFilePath(inputPackageFilePath), NormalizeFilePath(outputPackageFilePath)))

Signing\Verification\AllowListVerificationProvider.cs (2)

85StringComparer.OrdinalIgnoreCase.Equals(certificateHashEntry.Fingerprint, primarySignatureCertificateFingerprint)) 112StringComparer.OrdinalIgnoreCase.Equals(certificateHashEntry.Fingerprint, countersignatureCertificateFingerprint))

src\nuget-client\build\Shared\HashCodeCombiner.cs (1)

81AddHashCode(StringComparer.OrdinalIgnoreCase.GetHashCode(s));

TopologicalSortUtility.cs (1)

85StringComparer.OrdinalIgnoreCase,

CentralTransitiveDependencyGroup.cs (1)

47return EqualityUtility.OrderedEquals(TransitiveDependencies, other.TransitiveDependencies, dep => dep.Name, StringComparer.OrdinalIgnoreCase);

DependencyGraphSpec.cs (2)

97if (!StringComparer.OrdinalIgnoreCase.Equals( 103if (closure.Any(e => StringComparer.OrdinalIgnoreCase.Equals(

JsonPackageSpecReader.Utf8JsonStreamReader.cs (1)

1518packagesToPrune ??= new Dictionary<string, PrunePackageReference>(StringComparer.OrdinalIgnoreCase);

LockFile\BuildAction.cs (2)

11private static readonly ConcurrentDictionary<string, BuildAction> KnownBuildActions = new ConcurrentDictionary<string, BuildAction>(StringComparer.OrdinalIgnoreCase); 83return StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

LockFile\LockFile.cs (3)

69&& ProjectFileDependencyGroups.OrderedEquals(other.ProjectFileDependencyGroups, group => group.FrameworkName, StringComparer.OrdinalIgnoreCase) 70&& Libraries.OrderedEquals(other.Libraries, library => library.Name, StringComparer.OrdinalIgnoreCase) 75&& CentralTransitiveDependencyGroups.OrderedEquals(other.CentralTransitiveDependencyGroups, group => group.FrameworkName, StringComparer.OrdinalIgnoreCase);

LockFile\LockFileExtensions.cs (2)

36return assetsFile.Targets.Where(target => message.TargetGraphs.Contains(target.TargetAlias + (string.IsNullOrEmpty(target.RuntimeIdentifier) ? "" : "/" + target.RuntimeIdentifier), StringComparer.OrdinalIgnoreCase)); 72return target.Libraries.FirstOrDefault(e => StringComparer.OrdinalIgnoreCase.Equals(libraryId, e.Name));

LockFile\LockFileTarget.cs (1)

54return Libraries.OrderedEquals(other.Libraries, library => library.Name, StringComparer.OrdinalIgnoreCase);

LockFile\LockFileTargetLibrary.cs (5)

185&& IsListOrderedEqual<string>(FrameworkAssembliesKey, static o => o, sequenceComparer: StringComparer.OrdinalIgnoreCase) 186&& IsListOrderedEqual<string>(FrameworkReferencesKey, static o => o, sequenceComparer: StringComparer.OrdinalIgnoreCase) 209return thisList.OrderedEquals<T, string>(thatList, accessor, orderComparer: StringComparer.OrdinalIgnoreCase, sequenceComparer: sequenceComparer); 227combiner.AddUnorderedSequence(FrameworkAssemblies, StringComparer.OrdinalIgnoreCase); 228combiner.AddUnorderedSequence(FrameworkReferences, StringComparer.OrdinalIgnoreCase);

PackageSpec.cs (1)

115EqualityUtility.OrderedEquals(TargetFrameworks, other.TargetFrameworks, tfm => tfm.TargetAlias, StringComparer.OrdinalIgnoreCase) &&

PackageSpecOperations.cs (2)

177Dictionary<string, CentralPackageVersion> result = new(dictSize, StringComparer.OrdinalIgnoreCase); 260return StringComparer.OrdinalIgnoreCase.Equals(dependency.Name, dependencyName);

PackageSpecReferenceDependencyProvider.cs (7)

25= new Dictionary<string, ExternalProjectReference>(StringComparer.OrdinalIgnoreCase); 28= new Dictionary<string, ExternalProjectReference>(StringComparer.OrdinalIgnoreCase); 176var projectNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 226.Distinct(StringComparer.OrdinalIgnoreCase) 286dependencies.RemoveAll(e => StringComparer.OrdinalIgnoreCase.Equals(dependency.Name, e.Name)); 350StringComparer.OrdinalIgnoreCase); 377var dependencyNamesSet = new HashSet<string>(targetFrameworkInfo.Dependencies.Select(d => d.Name), StringComparer.OrdinalIgnoreCase);

PackageSpecWriter.cs (4)

234foreach (var framework in msbuildMetadata.TargetFrameworks.OrderBy(c => c.TargetAlias, StringComparer.OrdinalIgnoreCase)) 532foreach (var framework in frameworks.OrderBy(c => c.TargetAlias, StringComparer.OrdinalIgnoreCase)) 600foreach (var dependency in centralPackageVersions.OrderBy(dep => dep.Name, StringComparer.OrdinalIgnoreCase)) 617foreach (var dependency in packagesToPrune.OrderBy(dep => dep.Key, StringComparer.OrdinalIgnoreCase))

ProjectFileDependencyGroup.cs (3)

41return Dependencies.OrderedEquals(other.Dependencies, s => s, StringComparer.OrdinalIgnoreCase, StringComparer.OrdinalIgnoreCase); 57combiner.AddUnorderedSequence(Dependencies, StringComparer.OrdinalIgnoreCase);

ProjectLockFile\LockFileDependencyIdVersionComparer.cs (1)

26return StringComparer.OrdinalIgnoreCase.Equals(x.Id, y.Id) &&

ProjectLockFile\PackagesLockFileTarget.cs (1)

60&& StringComparer.OrdinalIgnoreCase.Equals(TargetAlias, other.TargetAlias)

ProjectLockFile\PackagesLockFileUtilities.cs (7)

202StringComparer.OrdinalIgnoreCase.Equals(dep.Id, p2pProjectName)); 303(nuGetLockFile.Version != 3 || StringComparer.OrdinalIgnoreCase.Equals(target.TargetAlias, targetAlias))) 347StringComparer.OrdinalIgnoreCase.Equals(actual.Targets[i].TargetAlias, expectedTarget.TargetAlias) && 382StringComparer.OrdinalIgnoreCase.Equals(t.TargetAlias, expectedTarget.TargetAlias) && 439var lockFileDependency = lockFileDependencies.FirstOrDefault(d => StringComparer.OrdinalIgnoreCase.Equals(d.Id, dependency.Name)); 500var matchedP2PLibrary = projectDependency.Dependencies.FirstOrDefault(dep => StringComparer.OrdinalIgnoreCase.Equals(dep.Id, dependency.Name)); 524var matchedP2PLibrary = projectDependency.Dependencies.FirstOrDefault(dep => StringComparer.OrdinalIgnoreCase.Equals(dep.Id, referenceSpec.Name));

ProjectRestoreMetadata.cs (6)

182hashCode.AddUnorderedSequence(OriginalTargetFrameworks, StringComparer.OrdinalIgnoreCase); 228GetSources(Sources).SetEqualsWithNullCheck(GetSources(other.Sources), StringComparer.OrdinalIgnoreCase) && 232EqualityUtility.OrderedEquals(TargetFrameworks, other.TargetFrameworks, dep => dep.TargetAlias, StringComparer.OrdinalIgnoreCase) && 233OriginalTargetFrameworks.OrderedEquals(other.OriginalTargetFrameworks, fw => fw, StringComparer.OrdinalIgnoreCase, StringComparer.OrdinalIgnoreCase) && 258var setSources = new HashSet<string>(sources.Count, StringComparer.OrdinalIgnoreCase);

ProjectRestoreMetadataFrameworkInfo.cs (1)

72StringComparer.OrdinalIgnoreCase.Equals(TargetAlias, other.TargetAlias) &&

ProjectRestoreReference.cs (1)

66&& StringComparer.OrdinalIgnoreCase.Equals(ProjectUniqueName, other.ProjectUniqueName)

RestoreLockProperties.cs (1)

69return StringComparer.OrdinalIgnoreCase.Equals(RestorePackagesWithLockFile, other.RestorePackagesWithLockFile) &&

src\nuget-client\build\Shared\HashCodeCombiner.cs (1)

81AddHashCode(StringComparer.OrdinalIgnoreCase.GetHashCode(s));

TargetFrameworkInformation.cs (5)

192EqualityUtility.OrderedEquals(Dependencies, other.Dependencies, dependency => dependency.Name, StringComparer.OrdinalIgnoreCase) && 196EqualityUtility.OrderedEquals(DownloadDependencies, other.DownloadDependencies, e => e.Name, StringComparer.OrdinalIgnoreCase) && 198EqualityUtility.OrderedEquals(CentralPackageVersions.Values, other.CentralPackageVersions.Values, e => e.Name, StringComparer.OrdinalIgnoreCase) && 199EqualityUtility.OrderedEquals(PackagesToPrune.Values, other.PackagesToPrune.Values, e => e.Name, StringComparer.OrdinalIgnoreCase) && 201StringComparer.OrdinalIgnoreCase.Equals(TargetAlias, other.TargetAlias);

LegacyFeed\LegacyFeedCapabilityResourceV2Feed.cs (4)

114public HashSet<string> SupportedMethodNames { get; set; } = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 116public HashSet<string> SupportedProperties { get; set; } = new HashSet<string>(StringComparer.OrdinalIgnoreCase); 161StringComparer.OrdinalIgnoreCase), 165StringComparer.OrdinalIgnoreCase)

LegacyFeed\ODataServiceDocumentResourceV2Provider.cs (1)

30_cache = new ConcurrentDictionary<string, ODataServiceDocumentCacheInfo>(StringComparer.OrdinalIgnoreCase);

LegacyFeed\V2FeedParser.cs (2)

354var requireLicenseAcceptance = StringComparer.OrdinalIgnoreCase.Equals(bool.TrueString, GetString(properties, _xnameRequireLicenseAcceptance)); 436var uris = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

LocalRepositories\FindLocalPackagesResourceUnzipped.cs (2)

35return _packages.Value.Where(package => StringComparer.OrdinalIgnoreCase.Equals(id, package.Identity.Id)).ToArray(); 111var validSet = new HashSet<string>(directories.Select(dir => dir.Name), StringComparer.OrdinalIgnoreCase);

LocalRepositories\LocalAutoCompleteResource.cs (1)

83.Distinct(StringComparer.OrdinalIgnoreCase)

LocalRepositories\LocalPackageSearchResource.cs (1)

215if (!first && !StringComparer.OrdinalIgnoreCase.Equals(element.Identity.Id, previousElement!.Identity.Id))

LocalRepositories\LocalV2FindPackageByIdResource.cs (1)

31= new ConcurrentDictionary<string, IReadOnlyList<LocalPackageInfo>>(StringComparer.OrdinalIgnoreCase);

LocalRepositories\LocalV3FindPackageByIdResource.cs (1)

31= new ConcurrentDictionary<string, List<NuGetVersion>>(StringComparer.OrdinalIgnoreCase);

PackagesFolder\NuGetv3LocalRepository.cs (2)

28= new ConcurrentDictionary<string, List<LocalPackageInfo>>(StringComparer.OrdinalIgnoreCase); 32= new ConcurrentDictionary<string, object>(StringComparer.OrdinalIgnoreCase);

Plugins\PluginManager.cs (1)

351StringComparer.OrdinalIgnoreCase);

Plugins\PluginPackageReader.cs (4)

71_fileStreams = new ConcurrentDictionary<string, Lazy<Task<FileStreamCreator?>>>(StringComparer.OrdinalIgnoreCase); 855if (referenceGroup.Items.Any(s => StringComparer.OrdinalIgnoreCase.Equals(s, file))) 995var isContentFolder = StringComparer.OrdinalIgnoreCase.Equals(folder, PackagingConstants.Folders.Content); 1015.Select(framework => new FrameworkSpecificGroup(framework, groups[framework].OrderBy(e => e, StringComparer.OrdinalIgnoreCase)));

Providers\ServiceIndexResourceV3Provider.cs (1)

49_cache = new ConcurrentDictionary<string, ServiceIndexCacheInfo>(StringComparer.OrdinalIgnoreCase);

RemoteRepositories\HttpFileSystemBasedFindPackageByIdResource.cs (1)

42new ConcurrentDictionary<string, AsyncLazy<HashSet<NuGetVersion>?>>(StringComparer.OrdinalIgnoreCase);

RemoteRepositories\PluginFindPackageByIdResource.cs (1)

29new ConcurrentDictionary<string, AsyncLazy<SortedDictionary<NuGetVersion, PackageInfo>>>(StringComparer.OrdinalIgnoreCase);

RemoteRepositories\RemoteV2FindPackageByIdResource.cs (2)

38private readonly TaskResultCache<string, List<PackageInfo>> _packageVersionsCache = new(StringComparer.OrdinalIgnoreCase); 468var uris = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

RemoteRepositories\RemoteV3FindPackageByIdResource.cs (1)

29private readonly TaskResultCache<string, IEnumerable<RemoteSourceDependencyInfo>> _packageVersionsCache = new(StringComparer.OrdinalIgnoreCase);

src\nuget-client\build\Shared\HashCodeCombiner.cs (1)

81AddHashCode(StringComparer.OrdinalIgnoreCase.GetHashCode(s));

Utility\LocalFolderUtility.cs (2)

114if (StringComparer.OrdinalIgnoreCase.Equals(id, package.Identity.Id)) 217if (StringComparer.OrdinalIgnoreCase.Equals(

PackageResolver.cs (10)

PackageResolverContext.cs (3)

70TargetIds = new HashSet<string>(targetIds, StringComparer.OrdinalIgnoreCase); 72RequiredPackageIds = new HashSet<string>(requiredPackageIds, StringComparer.OrdinalIgnoreCase); 80Debug.Assert(PreferredVersions.GroupBy(p => p.Id, StringComparer.OrdinalIgnoreCase)

ResolverComparer.cs (1)

119if (_targetIds.Contains(x.Id, StringComparer.OrdinalIgnoreCase))

ResolverInputSort.cs (8)

ResolverPackage.cs (1)

47_dependencyIds = new SortedDictionary<string, VersionRange>(StringComparer.OrdinalIgnoreCase);

ResolverUtility.cs (32)

src\nuget-client\build\Shared\HashCodeCombiner.cs (1)

81AddHashCode(StringComparer.OrdinalIgnoreCase.GetHashCode(s));

src\nuget-client\build\Shared\HashCodeCombiner.cs (1)

81AddHashCode(StringComparer.OrdinalIgnoreCase.GetHashCode(s));

VersionComparer.cs (5)

128var comparer = StringComparer.OrdinalIgnoreCase; 138combiner.AddObject(version.Metadata, StringComparer.OrdinalIgnoreCase); 223result = StringComparer.OrdinalIgnoreCase.Compare(x.Metadata ?? string.Empty, y.Metadata ?? string.Empty); 351result = StringComparer.OrdinalIgnoreCase.Compare(version1, version2); 410if (!StringComparer.OrdinalIgnoreCase.Equals(xLabels[i], yLabels[i]))

MS\Internal\Tasks\IncrementalCompileAnalyzer.cs (1)

391HashSet<string> localMarkupPages = new HashSet<string>(_mcPass1.PageMarkup.Select(x => x.GetMetadata(SharedStrings.FullPath)), StringComparer.OrdinalIgnoreCase);

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

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

src\wpf\src\Microsoft.DotNet.Wpf\src\Shared\System\Windows\Markup\ReflectionHelper.cs (2)

60_cachedMetadataLoadContextAssemblies = new Dictionary<string, Assembly>(StringComparer.OrdinalIgnoreCase); 61_cachedMetadataLoadContextAssembliesByNameNoExtension = new Dictionary<string, Assembly>(StringComparer.OrdinalIgnoreCase);

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

150new(StringComparer.OrdinalIgnoreCase);

MS\Internal\FontCache\FamilyCollection.cs (1)

473Dictionary<string, Text.TextInterface.Font> faces = new Dictionary<string, Text.TextInterface.Font>(StringComparer.OrdinalIgnoreCase);

MS\Internal\FontCache\FontResourceCache.cs (1)

82folderResourceMap = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);

MS\Internal\Resources\ContentFileHelper.cs (1)

63contentFiles = new HashSet<string>(assemblyAttributes.Length, StringComparer.OrdinalIgnoreCase);

MS\Internal\IO\Packaging\XamlFilter.cs (1)

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

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

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

BatchHelixWorkItems.cs (3)

49var eligibleGroups = new Dictionary<string, List<ITaskItem>>(StringComparer.OrdinalIgnoreCase); 95foreach (var group in eligibleGroups.OrderBy(pair => pair.Key, StringComparer.OrdinalIgnoreCase)) 97var orderedItems = group.Value.OrderBy(item => item.ItemSpec, StringComparer.OrdinalIgnoreCase).ToList();

FileUtilities.cs (1)

16StringComparer.OrdinalIgnoreCase);

ResolveDotnetToolPackagePaths.cs (1)

52var toolsByPackageId = new Dictionary<string, JsonElement>(StringComparer.OrdinalIgnoreCase);

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

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

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

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

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

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

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

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

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

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

src\roslyn\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\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyComparer.cs (1)

35? StringComparer.OrdinalIgnoreCase

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

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

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

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

BasicInvokeTheCorrectPropertyToEnsureCorrectUseSiteDiagnostics.vb (1)

29Private Shared ReadOnly s_propertiesToValidateMap As ImmutableDictionary(Of String, String) = New Dictionary(Of String, String)(StringComparer.OrdinalIgnoreCase) From

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Services\SemanticFacts\VisualBasicSemanticFacts.vb (1)

158Dim builder = ImmutableHashSet.CreateBuilder(Of String)(StringComparer.OrdinalIgnoreCase)

DefaultExtensionAssemblyLoader.cs (3)

30_loadedByPath = new Dictionary<string, (Assembly assembly, AssemblyIdentity identity)>(StringComparer.OrdinalIgnoreCase); 32_identityCache = new Dictionary<string, AssemblyIdentity>(StringComparer.OrdinalIgnoreCase); 33_wellKnownAssemblies = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);

GenerateCommand.cs (1)

410var cssScopeAssociations = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);

MetadataCache.cs (1)

17new(CacheSize, StringComparer.OrdinalIgnoreCase);

IncrementalLayout.cs (1)

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

WorkloadManifestLayout.cs (1)

142return distinctSiblingExists ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase;

Http\ClientCredentialTypeTests.4.1.0.cs (1)

127Assert.Equal("100-Continue", expectHeader, StringComparer.OrdinalIgnoreCase);

Https\HttpsTests.4.1.0.cs (1)

432Assert.Equal("100-Continue", expectHeader, StringComparer.OrdinalIgnoreCase);

GraphAffectedProjects.cs (3)

88private static readonly StringComparer s_pathComparer = StringComparer.OrdinalIgnoreCase; 236var globalProperties = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) 310var itemTypes = new HashSet<string>(s_indexedItemTypes, StringComparer.OrdinalIgnoreCase);

Microsoft\VisualBasic\VBCodeGenerator.cs (1)

2233var importList = new SortedSet<string>(StringComparer.OrdinalIgnoreCase);

src\runtime\src\libraries\Common\src\System\IO\TempFileCollection.cs (1)

41_files = new Hashtable(StringComparer.OrdinalIgnoreCase);

System\CodeDom\CodeNamespaceImportCollection.cs (1)

12private readonly Dictionary<string, CodeNamespaceImport> _keys = new Dictionary<string, CodeNamespaceImport>(StringComparer.OrdinalIgnoreCase);

System\CodeDom\Compiler\CodeDomProvider.cs (2)

16private static readonly Dictionary<string, CompilerInfo> s_compilerLanguages = new Dictionary<string, CompilerInfo>(StringComparer.OrdinalIgnoreCase); 17private static readonly Dictionary<string, CompilerInfo> s_compilerExtensions = new Dictionary<string, CompilerInfo>(StringComparer.OrdinalIgnoreCase);

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

206(ReferenceEquals(comparer, EqualityComparer<TKey>.Default) || ReferenceEquals(comparer, StringComparer.Ordinal) || ReferenceEquals(comparer, StringComparer.OrdinalIgnoreCase))) 233KeyAnalyzer.AnalysisResults analysis = KeyAnalyzer.Analyze(keys, ReferenceEquals(stringComparer, StringComparer.OrdinalIgnoreCase), minLength, maxLength);

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

136(ReferenceEquals(comparer, EqualityComparer<T>.Default) || ReferenceEquals(comparer, StringComparer.Ordinal) || ReferenceEquals(comparer, StringComparer.OrdinalIgnoreCase))) 164KeyAnalyzer.AnalysisResults analysis = KeyAnalyzer.Analyze(entries, ReferenceEquals(stringComparer, StringComparer.OrdinalIgnoreCase), minLength, maxLength);

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

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

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

23Debug.Assert(comparer == EqualityComparer<string>.Default || comparer == StringComparer.Ordinal || comparer == StringComparer.OrdinalIgnoreCase); 29_ignoreCase = ReferenceEquals(comparer, StringComparer.OrdinalIgnoreCase); 96if (StringComparer.OrdinalIgnoreCase.Equals(key, keys[index]))

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

21Debug.Assert(comparer == EqualityComparer<string>.Default || comparer == StringComparer.Ordinal || comparer == StringComparer.OrdinalIgnoreCase); 26_ignoreCase = ReferenceEquals(comparer, StringComparer.OrdinalIgnoreCase); 91if (StringComparer.OrdinalIgnoreCase.Equals(item, items[index]))

System\Collections\Frozen\String\OrdinalStringFrozenDictionary_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\OrdinalStringFrozenDictionary.cs (1)

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

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

26private protected override bool Equals(string? x, string? y) => StringComparer.OrdinalIgnoreCase.Equals(x, y);

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

26private protected override bool Equals(string? x, string? y) => StringComparer.OrdinalIgnoreCase.Equals(x, y);

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

24private protected override bool Equals(string? x, string? y) => StringComparer.OrdinalIgnoreCase.Equals(x, y);

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

24private protected override bool Equals(string? x, string? y) => StringComparer.OrdinalIgnoreCase.Equals(x, y);

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

24private protected override bool Equals(string? x, string? y) => StringComparer.OrdinalIgnoreCase.Equals(x, y);

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

24private protected override bool Equals(string? x, string? y) => StringComparer.OrdinalIgnoreCase.Equals(x, y);

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

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

Argument.cs (1)

163.OrderBy(c => c.SortText, StringComparer.OrdinalIgnoreCase);

Command.cs (1)

335.ThenBy(symbol => symbol.Label, StringComparer.OrdinalIgnoreCase);

Help\HelpBuilder.Default.cs (2)

140.OrderBy(r => r.Prefix, StringComparer.OrdinalIgnoreCase) 141.ThenBy(r => r.Alias, StringComparer.OrdinalIgnoreCase)

Option.cs (1)

153.ThenBy(symbol => symbol.Label, StringComparer.OrdinalIgnoreCase);

CompletionsCommandParser.cs (1)

27ShellProviders = providers.ToDictionary(s => s.ArgumentName, StringComparer.OrdinalIgnoreCase);

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

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

System\ComponentModel\ComponentResourceManager.cs (2)

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

System\ComponentModel\PropertyDescriptorCollection.cs (1)

186_cachedFoundProperties = new Hashtable(StringComparer.OrdinalIgnoreCase);

src\runtime\src\libraries\Common\src\System\IO\TempFileCollection.cs (1)

41_files = new Hashtable(StringComparer.OrdinalIgnoreCase);

System\Configuration\BaseConfigurationRecord.cs (1)

3413_children ??= new Hashtable(StringComparer.OrdinalIgnoreCase);

System\Configuration\ConnectionStringSettingsCollection.cs (1)

12: base(StringComparer.OrdinalIgnoreCase)

System\Configuration\DictionarySectionHandler.cs (1)

32res = new Hashtable(StringComparer.OrdinalIgnoreCase);

System\Configuration\KeyValueConfigurationCollection.cs (1)

12base(StringComparer.OrdinalIgnoreCase)

System\Configuration\MgmtConfigurationRecord.cs (1)

302_locationTags ??= new Hashtable(StringComparer.OrdinalIgnoreCase);

System\Configuration\NameValueSectionHandler.cs (1)

33result = new ReadOnlyNameValueCollection(StringComparer.OrdinalIgnoreCase);

System\Configuration\Provider\ProviderCollection.cs (1)

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

System\Configuration\ProviderSettingsCollection.cs (1)

12base(StringComparer.OrdinalIgnoreCase)

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

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

Common\System\Data\Common\DbConnectionStringCommon.cs (18)

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

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

DbConnectionOptions.cs (1)

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

DbConnectionStringCommon.cs (8)

138if (StringComparer.OrdinalIgnoreCase.Equals(svalue, "true") || StringComparer.OrdinalIgnoreCase.Equals(svalue, "yes")) 140else if (StringComparer.OrdinalIgnoreCase.Equals(svalue, "false") || StringComparer.OrdinalIgnoreCase.Equals(svalue, "no")) 145if (StringComparer.OrdinalIgnoreCase.Equals(tmp, "true") || StringComparer.OrdinalIgnoreCase.Equals(tmp, "yes")) 147else if (StringComparer.OrdinalIgnoreCase.Equals(tmp, "false") || StringComparer.OrdinalIgnoreCase.Equals(tmp, "no"))

OleDbConnectionStringBuilder.cs (4)

39private static readonly Dictionary<string, Keywords> s_keywords = new Dictionary<string, Keywords>(5, StringComparer.OrdinalIgnoreCase) 230if (StringComparer.OrdinalIgnoreCase.Equals(s, keyword)) 252if (StringComparer.OrdinalIgnoreCase.Equals(s, keyword)) 419providerInfo = new Dictionary<string, OleDbPropertyInfo>(StringComparer.OrdinalIgnoreCase);

PropertyInfoSet.cs (1)

68propertyLookup = new Dictionary<string, OleDbPropertyInfo>(StringComparer.OrdinalIgnoreCase);

System\Diagnostics\DsesActivitySourceListener.cs (3)

74var allSources = _listenToActivitySourceNames ??= new(StringComparer.OrdinalIgnoreCase); 237hash = ((hash << 5) + hash) + StringComparer.OrdinalIgnoreCase.GetHashCode(obj.activitySourceName); 238hash = ((hash << 5) + hash) + (obj.activityName == null ? 0 : StringComparer.OrdinalIgnoreCase.GetHashCode(obj.activityName));

System\Diagnostics\EventLogInternal.cs (2)

73private static readonly Hashtable listenerInfos = new Hashtable(StringComparer.OrdinalIgnoreCase); 278return messageLibraries ??= new Hashtable(StringComparer.OrdinalIgnoreCase);

System\Diagnostics\PerformanceCounterLib.cs (5)

146Hashtable tempCategoryTable = new Hashtable(numPerfObjects, StringComparer.OrdinalIgnoreCase); 661Interlocked.CompareExchange(ref _customCategoryTable, new Hashtable(StringComparer.OrdinalIgnoreCase), null) ?? 1404_instanceNameTable = new Hashtable(StringComparer.OrdinalIgnoreCase); 1477_instanceNameTable = new Hashtable(1, StringComparer.OrdinalIgnoreCase); 1488_instanceNameTable = new Hashtable(instanceNumber, StringComparer.OrdinalIgnoreCase);

System\Diagnostics\ProcessStartInfo.cs (1)

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

System\DirectoryServices\Design\DirectoryEntryConverter.cs (1)

13private static readonly Hashtable s_componentsCreated = new Hashtable(StringComparer.OrdinalIgnoreCase);

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

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

System\Management\WMIGenerator.cs (4)

99private SortedList PublicProperties = new SortedList(StringComparer.OrdinalIgnoreCase); 100private SortedList PublicMethods = new SortedList(StringComparer.OrdinalIgnoreCase); 101private SortedList PublicNamesUsed = new SortedList(StringComparer.OrdinalIgnoreCase); 102private SortedList PrivateNamesUsed = new SortedList(StringComparer.OrdinalIgnoreCase);

src\runtime\src\libraries\Common\src\System\Net\CredentialCacheKey.cs (1)

85StringComparer.OrdinalIgnoreCase.GetHashCode(AuthenticationType) ^

System\Net\Http\Headers\AuthenticationHeaderValue.cs (1)

86int result = StringComparer.OrdinalIgnoreCase.GetHashCode(_scheme);

System\Net\Http\Headers\CacheControlHeaderValue.cs (4)

314HeaderUtilities.AreEqualCollections(_noCacheHeaders, other._noCacheHeaders, StringComparer.OrdinalIgnoreCase) && 315HeaderUtilities.AreEqualCollections(_privateHeaders, other._privateHeaders, StringComparer.OrdinalIgnoreCase) && 325(_noCacheHeaders is null ? 0 : _noCacheHeaders.GetHashCode(StringComparer.OrdinalIgnoreCase)), 326(_privateHeaders is null ? 0 : _privateHeaders.GetHashCode(StringComparer.OrdinalIgnoreCase)),

System\Net\Http\Headers\ContentDispositionHeaderValue.cs (1)

175return StringComparer.OrdinalIgnoreCase.GetHashCode(_dispositionType) ^ NameValueHeaderValue.GetHashCode(_parameters);

System\Net\Http\Headers\ContentRangeHeaderValue.cs (1)

103StringComparer.OrdinalIgnoreCase.GetHashCode(_unit),

System\Net\Http\Headers\GenericHeaderParser.cs (2)

15internal static readonly GenericHeaderParser HostParser = new GenericHeaderParser(false, ParseHost, StringComparer.OrdinalIgnoreCase); 16internal static readonly GenericHeaderParser TokenListParser = new GenericHeaderParser(true, ParseTokenList, StringComparer.OrdinalIgnoreCase);

System\Net\Http\Headers\HeaderDescriptor.cs (1)

56public override int GetHashCode() => _descriptor is KnownHeader knownHeader ? knownHeader.GetHashCode() : StringComparer.OrdinalIgnoreCase.GetHashCode(_descriptor);

System\Net\Http\Headers\KnownHeaders.cs (1)

391if (candidate != null && StringComparer.OrdinalIgnoreCase.Equals(name, candidate.Name))

System\Net\Http\Headers\MediaTypeHeaderValue.cs (1)

144return StringComparer.OrdinalIgnoreCase.GetHashCode(_mediaType!) ^ NameValueHeaderValue.GetHashCode(_parameters);

System\Net\Http\Headers\NameValueHeaderValue.cs (2)

64int nameHashCode = StringComparer.OrdinalIgnoreCase.GetHashCode(_name); 75return nameHashCode ^ StringComparer.OrdinalIgnoreCase.GetHashCode(_value);

System\Net\Http\Headers\ProductHeaderValue.cs (2)

75int result = StringComparer.OrdinalIgnoreCase.GetHashCode(_name); 79result ^= StringComparer.OrdinalIgnoreCase.GetHashCode(_version);

System\Net\Http\Headers\RangeHeaderValue.cs (1)

99int result = StringComparer.OrdinalIgnoreCase.GetHashCode(_unit);

System\Net\Http\Headers\StringWithQualityHeaderValue.cs (1)

62HashCode.Combine(StringComparer.OrdinalIgnoreCase.GetHashCode(_value), _quality);

System\Net\Http\Headers\TransferCodingHeaderValue.cs (1)

136return StringComparer.OrdinalIgnoreCase.GetHashCode(_value) ^ NameValueHeaderValue.GetHashCode(_parameters);

System\Net\Http\Headers\ViaHeaderValue.cs (3)

113StringComparer.OrdinalIgnoreCase.GetHashCode(_protocolVersion), 114StringComparer.OrdinalIgnoreCase.GetHashCode(_receivedBy), 115_protocolName is null ? 0 : StringComparer.OrdinalIgnoreCase.GetHashCode(_protocolName),

System\Net\Http\Headers\WarningHeaderValue.cs (1)

111StringComparer.OrdinalIgnoreCase.GetHashCode(_agent),

System\Net\Http\HttpMethod.cs (1)

67_hashcode = StringComparer.OrdinalIgnoreCase.GetHashCode(_method);

System\Net\Http\SocketsHttpHandler\AuthenticationHelper.cs (3)

48if (StringComparer.OrdinalIgnoreCase.Equals(scheme, ahv.Scheme)) 71if (StringComparer.OrdinalIgnoreCase.Equals(NegotiateScheme, ahv.Scheme) || StringComparer.OrdinalIgnoreCase.Equals(NtlmScheme, ahv.Scheme))

System\Net\Http\SocketsHttpHandler\AuthenticationHelper.Digest.cs (1)

238internal readonly Dictionary<string, string> Parameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

System\Net\Mail\MailHeaderInfo.cs (1)

74var headers = new Dictionary<string, int>((int)MailHeaderID.ZMaxEnumValue + 1, StringComparer.OrdinalIgnoreCase);

System\Net\Mime\ContentDisposition.cs (1)

257public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(ToString());

System\Net\Mime\ContentType.cs (1)

214public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(ToString());

System\Net\Mime\HeaderCollection.cs (1)

17internal HeaderCollection() : base(StringComparer.OrdinalIgnoreCase)

System\Net\Mime\MediaTypeMap.cs (2)

20private static readonly Dictionary<string, string>.AlternateLookup<ReadOnlySpan<char>> s_extensionToMediaType = new Dictionary<string, string>(ExtensionToMediaTypeCount, StringComparer.OrdinalIgnoreCase) 428private static readonly Dictionary<string, string>.AlternateLookup<ReadOnlySpan<char>> s_mediaTypeToExtension = new Dictionary<string, string>(MediaTypeToExtensionCount, StringComparer.OrdinalIgnoreCase)

System\Net\DnsResolverPal.Managed.cs (1)

215glue ??= new Dictionary<string, List<AddressRecord>>(StringComparer.OrdinalIgnoreCase);

src\runtime\src\libraries\Common\src\System\Net\CredentialCacheKey.cs (1)

85StringComparer.OrdinalIgnoreCase.GetHashCode(AuthenticationType) ^

System\Net\Cookie.cs (2)

636StringComparer.OrdinalIgnoreCase.GetHashCode(Name), 639StringComparer.OrdinalIgnoreCase.GetHashCode(DomainKey),

System\Net\CredentialCache.cs (2)

366StringComparer.OrdinalIgnoreCase.GetHashCode(AuthenticationType) ^ 367StringComparer.OrdinalIgnoreCase.GetHashCode(Host) ^

System\Net\DnsEndPoint.cs (2)

40StringComparer.OrdinalIgnoreCase.Equals(_host, dnsComparand._host); 46StringComparer.OrdinalIgnoreCase.GetHashCode(_host));

System\Net\HeaderInfoTable.cs (1)

87var headers = new Hashtable(Items * 2, StringComparer.OrdinalIgnoreCase)

System\Net\WebHeaderCollection.cs (1)

51private NameValueCollection InnerCollection => _innerCollection ??= new NameValueCollection(ApproxHighAvgNumHeaders, StringComparer.OrdinalIgnoreCase);

src\runtime\src\libraries\System.Private.CoreLib\src\Internal\Runtime\InteropServices\ComponentLoadContext.cs (1)

26private static readonly StringComparer s_pathComparer = OperatingSystem.IsWindows() ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;

src\runtime\src\libraries\System.Private.CoreLib\src\Internal\Runtime\InteropServices\ComponentLoadContextManager.cs (1)

22private static readonly StringComparer s_pathComparer = OperatingSystem.IsWindows() ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;

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

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

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

153new Dictionary<string, string>(255, StringComparer.OrdinalIgnoreCase)

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

19return StringComparer.OrdinalIgnoreCase;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Resources\ResourceSet.cs (1)

217caseTable = new Dictionary<string, object?>(copyOfTable.Count, StringComparer.OrdinalIgnoreCase);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Resources\RuntimeResourceSet.cs (1)

313caseInsensitiveTable = new Dictionary<string, ResourceLocator>(StringComparer.OrdinalIgnoreCase);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\OSPlatform.cs (1)

52return Name == null ? 0 : StringComparer.OrdinalIgnoreCase.GetHashCode(Name);

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

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

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

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

src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\EncodingTable.cs (1)

37Interlocked.CompareExchange(ref s_nameToCodePage, new(StringComparer.OrdinalIgnoreCase), null);

src\runtime\src\libraries\System.Private.CoreLib\src\System\TimeZoneInfo.cs (3)

762public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(_id); 1206cachedData._timeZonesUsingAlternativeIds ??= new Dictionary<string, TimeZoneInfo>(StringComparer.OrdinalIgnoreCase); 1293cachedData._systemTimeZones ??= new Dictionary<string, TimeZoneInfo>(StringComparer.OrdinalIgnoreCase)

src\runtime\src\libraries\System.Private.CoreLib\src\System\TimeZoneInfo.Unix.cs (2)

291cachedData._systemTimeZones ??= new Dictionary<string, TimeZoneInfo>(StringComparer.OrdinalIgnoreCase) 304Dictionary<string, TimeZoneInfo> filteredTimeZones = new Dictionary<string, TimeZoneInfo>(capacity: initialCapacity, comparer: StringComparer.OrdinalIgnoreCase)

System\Uri.cs (1)

1555return StringComparer.OrdinalIgnoreCase.GetHashCode(remoteUrl);

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

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

System\Reflection\PathAssemblyResolver.cs (1)

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

src\runtime\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\runtime\src\libraries\System.Private.CoreLib\src\System\Resources\RuntimeResourceSet.cs (1)

313caseInsensitiveTable = new Dictionary<string, ResourceLocator>(StringComparer.OrdinalIgnoreCase);

src\runtime\src\libraries\Common\src\System\Resources\ResourceWriter.cs (2)

55_caseInsensitiveDups = new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase); 74_caseInsensitiveDups = new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase);

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

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

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

48_clrNamespaces = new Dictionary<string, string?>(StringComparer.OrdinalIgnoreCase); 1541Dictionary<string, object?> fragments = new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase);

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

54return _memberNames ??= new HashSet<string>(StringComparer.OrdinalIgnoreCase);

System\Security\Cryptography\CryptoConfig.cs (4)

42private static readonly ConcurrentDictionary<string, Type> appNameHT = new ConcurrentDictionary<string, Type>(StringComparer.OrdinalIgnoreCase); 43private static readonly ConcurrentDictionary<string, string> appOidHT = new ConcurrentDictionary<string, string>(StringComparer.OrdinalIgnoreCase); 55Dictionary<string, string> ht = new Dictionary<string, string>(capacity, StringComparer.OrdinalIgnoreCase); 119Dictionary<string, object> ht = new Dictionary<string, object>(capacity: capacity, comparer: StringComparer.OrdinalIgnoreCase);

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

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

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

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

System\Security\Principal\NTAccount.cs (1)

128return StringComparer.OrdinalIgnoreCase.GetHashCode(_name);

System\ServiceModel\Channels\HttpResponseMessageExtensionMethods.cs (1)

17internal static HashSet<string> s_wellKnownContentHeaders = new HashSet<string>(StringComparer.OrdinalIgnoreCase)

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

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

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

491: base(StringComparer.OrdinalIgnoreCase)

System\IdentityModel\Claims\ClaimComparer.cs (3)

89s_dnsComparer = new ClaimComparer(StringComparer.OrdinalIgnoreCase); 312if (StringComparer.OrdinalIgnoreCase.Equals(obj1 as string, obj2 as string)) 365return StringComparer.OrdinalIgnoreCase.GetHashCode(upn);

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

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

System\ServiceModel\EndpointAddress.cs (1)

386return StringComparer.OrdinalIgnoreCase.GetHashCode(uriString);

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

19StringComparer.OrdinalIgnoreCase

System\Text\EncodingTable.cs (1)

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

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

281? StringComparer.OrdinalIgnoreCase

System\Text\Json\Serialization\Converters\FSharp\FSharpUnionConverter.cs (2)

51? new Dictionary<string, CaseInfo>(unionCases.Length, StringComparer.OrdinalIgnoreCase) 117fields is not null && options.PropertyNameCaseInsensitive ? BuildFieldIndexMap(fields, StringComparer.OrdinalIgnoreCase, typeof(T), discriminatorName) : null,

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

63_enumFieldInfoIndex = new(StringComparer.OrdinalIgnoreCase);

System\Text\Json\Serialization\JsonUnionTypeStructuralClassifier.cs (1)

138caseInsensitivePocoPropertyIndex ??= new(StringComparer.OrdinalIgnoreCase);

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

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

JsonSourceGenerator.Parser.cs (1)

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

System\Web\HttpUtility.cs (1)

46: base(StringComparer.OrdinalIgnoreCase)

System\Windows\Forms\Controls\GroupBox\GroupBox.Modern.cs (1)

18new(StringComparer.OrdinalIgnoreCase);

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

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

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

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

System\Xaml\XamlSchemaContext.cs (1)

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

src\roslyn\src\Compilers\Shared\BuildServerConnection.cs (1)

491foreach (var kvp in environmentVariables.OrderBy(kvp => kvp.Key, StringComparer.OrdinalIgnoreCase))

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

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

src\roslyn\src\Compilers\Server\VBCSCompiler\CompilationCache.cs (2)

703.GroupBy(d => d.DllName, StringComparer.OrdinalIgnoreCase) 704.OrderBy(g => g.Key, StringComparer.OrdinalIgnoreCase);

src\roslyn\src\Compilers\Shared\BuildServerConnection.cs (1)

491foreach (var kvp in environmentVariables.OrderBy(kvp => kvp.Key, StringComparer.OrdinalIgnoreCase))

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

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

CommandLine\Executor.cs (1)

359var commandSeenCount = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);

Processors\AeDebuggerArgumentProcessor.cs (2)

105if (aeDebuggerArgumentList.Contains(InstallCommandArgumentName, StringComparer.OrdinalIgnoreCase)) 110if (aeDebuggerArgumentList.Contains(UninstallCommandArgumentName, StringComparer.OrdinalIgnoreCase))

Processors\ArtifactProcessingPostProcessModeProcessor.cs (2)

55(args?.Contains("--artifactsProcessingMode-postprocess", StringComparer.OrdinalIgnoreCase) == true || 56args?.Contains(CommandName, StringComparer.OrdinalIgnoreCase) == true);

Processors\EnableBlameArgumentProcessor.cs (4)

30public static HashSet<string> CrashDumpKeys { get; } = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "CollectAlways", "DumpType" }; 31public static HashSet<string> HangDumpKeys { get; } = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "TestTimeout", "HangDumpType" }; 220.ToDictionary(p => p.Key, p => p.Value, StringComparer.OrdinalIgnoreCase) 236.ToDictionary(p => p.Key, p => p.Value, StringComparer.OrdinalIgnoreCase)

Processors\ShowDeprecateDotnetVStestMessageArgumentProcessor.cs (1)

27args?.Contains("--ShowDeprecateDotnetVSTestMessage", StringComparer.OrdinalIgnoreCase) == true;

Processors\Utilities\ArgumentProcessorFactory.cs (2)

258_commandToProcessorMap = new Dictionary<string, IArgumentProcessor>(StringComparer.OrdinalIgnoreCase); 259_specialCommandToProcessorMap = new Dictionary<string, IArgumentProcessor>(StringComparer.OrdinalIgnoreCase);

Processors\Utilities\ArgumentProcessorUtilities.cs (1)

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

TestPlatformHelpers\TestRequestManager.cs (1)

1544}, StringComparer.OrdinalIgnoreCase);

parent\vstest.console\CommandLine\Executor.cs (1)

359var commandSeenCount = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);

parent\vstest.console\Processors\AeDebuggerArgumentProcessor.cs (2)

105if (aeDebuggerArgumentList.Contains(InstallCommandArgumentName, StringComparer.OrdinalIgnoreCase)) 110if (aeDebuggerArgumentList.Contains(UninstallCommandArgumentName, StringComparer.OrdinalIgnoreCase))

parent\vstest.console\Processors\ArtifactProcessingPostProcessModeProcessor.cs (2)

55(args?.Contains("--artifactsProcessingMode-postprocess", StringComparer.OrdinalIgnoreCase) == true || 56args?.Contains(CommandName, StringComparer.OrdinalIgnoreCase) == true);

parent\vstest.console\Processors\EnableBlameArgumentProcessor.cs (4)

30public static HashSet<string> CrashDumpKeys { get; } = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "CollectAlways", "DumpType" }; 31public static HashSet<string> HangDumpKeys { get; } = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "TestTimeout", "HangDumpType" }; 220.ToDictionary(p => p.Key, p => p.Value, StringComparer.OrdinalIgnoreCase) 236.ToDictionary(p => p.Key, p => p.Value, StringComparer.OrdinalIgnoreCase)

parent\vstest.console\Processors\ShowDeprecateDotnetVStestMessageArgumentProcessor.cs (1)

27args?.Contains("--ShowDeprecateDotnetVSTestMessage", StringComparer.OrdinalIgnoreCase) == true;

parent\vstest.console\Processors\Utilities\ArgumentProcessorFactory.cs (2)

258_commandToProcessorMap = new Dictionary<string, IArgumentProcessor>(StringComparer.OrdinalIgnoreCase); 259_specialCommandToProcessorMap = new Dictionary<string, IArgumentProcessor>(StringComparer.OrdinalIgnoreCase);

parent\vstest.console\Processors\Utilities\ArgumentProcessorUtilities.cs (1)

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

parent\vstest.console\TestPlatformHelpers\TestRequestManager.cs (1)

1544}, StringComparer.OrdinalIgnoreCase);