StartsWith

2165 references to StartsWith

aspire (142)

Acquisition\IdentityChannelReader.cs (1)

142if (!value.StartsWith(PrChannelPrefix, StringComparison.Ordinal))

Acquisition\InstallationDiscovery.cs (1)

345if (string.IsNullOrEmpty(label) || !label.StartsWith("pr-", StringComparison.Ordinal))

Agents\AspireSkills\AspireSkillsBundleProvider.cs (8)

Agents\AspireSkills\AspireSkillsInstaller.cs (5)

987if (version.StartsWith(".", StringComparison.Ordinal)) 1089return name.StartsWith(".github-", StringComparison.Ordinal) || 1090name.StartsWith(".embedded-", StringComparison.Ordinal) || 1091name.StartsWith(".extract-", StringComparison.Ordinal) || 1092name.StartsWith(".stage-", StringComparison.Ordinal);

Agents\Copilot\CopilotAppInstallationDetector.cs (1)

156line.StartsWith("Exec=", StringComparison.Ordinal) &&

Agents\SkillDefinition.cs (1)

166if (!relativePath.StartsWith(excludedPath, StringComparison.Ordinal))

Backchannel\AuxiliaryBackchannelMonitor.cs (1)

234if (relativePath.StartsWith("..", StringComparison.Ordinal) || Path.IsPathRooted(relativePath))

Bundles\BundleService.cs (2)

895if (!fullPath.StartsWith(normalizedDestination + Path.DirectorySeparatorChar, StringComparison.Ordinal) && 929if (!linkTarget.StartsWith(normalizedDestination + Path.DirectorySeparatorChar, StringComparison.Ordinal) &&

Certificates\CertificateGeneration\UnixCertificateManager.cs (1)

384var prettyCertDir = certDir.StartsWith(homeDirectoryWithSlash, StringComparison.Ordinal)

Commands\AddCommand.cs (3)

336.Where(s => !s.StartsWith("http", StringComparison.OrdinalIgnoreCase)) 770var xStarts = x.StartsWith(prefix, StringComparison.OrdinalIgnoreCase); 771var yStarts = y.StartsWith(prefix, StringComparison.OrdinalIgnoreCase);

Commands\AgentInitCommand.cs (1)

620if (simplified.StartsWith("**", StringComparison.Ordinal))

Commands\AppHostLauncher.cs (6)

393name.StartsWith(ExtensionEnvironmentVariablePrefix, StringComparison.OrdinalIgnoreCase); 1129if (entry.Category is CliLogFormat.Categories.Build or CliLogFormat.Categories.AppHost || entry.Category.StartsWith(CliLogFormat.Categories.AppHostPrefix, StringComparison.Ordinal)) 1135&& entry.Message.StartsWith(CliLogFormat.MessagePrefixes.Executing, StringComparison.Ordinal)) 1163if (entry.Category is CliLogFormat.Categories.Build or CliLogFormat.Categories.AppHost || entry.Category.StartsWith(CliLogFormat.Categories.AppHostPrefix, StringComparison.Ordinal)) 1170&& entry.Message.StartsWith("AppHost server process has exited.", StringComparison.Ordinal)) 1206&& entry.Message.StartsWith(CliLogFormat.MessagePrefixes.Executing, StringComparison.Ordinal);

Commands\ConfigCommand.cs (1)

281.Where(kvp => kvp.Key.StartsWith(featurePrefix, StringComparison.Ordinal))

Commands\DashboardRunCommand.cs (2)

250if (unmatchedTokens[i].StartsWith(prefix, StringComparison.OrdinalIgnoreCase)) 326if (arg.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))

Commands\DescribeCommand.cs (1)

425.ThenByDescending(e => e.Url.StartsWith("https", StringComparison.OrdinalIgnoreCase))

Commands\GroupedHelpWriter.cs (2)

327var longName = option.Name.StartsWith("--", StringComparison.Ordinal) 329: option.Aliases.FirstOrDefault(static alias => alias.StartsWith("--", StringComparison.Ordinal)) ?? option.Name;

Commands\PipelineCommandBase.cs (3)

525else if (token.StartsWith("--format=", StringComparison.Ordinal)) 587token == "--format" || token.StartsWith("--format=", StringComparison.Ordinal); 593if (!tokens[i].StartsWith("-", StringComparison.Ordinal))

Commands\ResourceCommand.cs (3)

491return value is not "--" && value.StartsWith("-", StringComparison.Ordinal); 847if (optionName.StartsWith("--", StringComparison.Ordinal)) 851else if (!optionName.StartsWith("-", StringComparison.Ordinal))

Commands\ResourceCommandHelper.cs (1)

211return argumentName.StartsWith("-", StringComparison.Ordinal) ? argumentName : $"--{ToKebabCase(argumentName)}";

Commands\ResourceCommandHelpParser.cs (1)

66return value.StartsWith("-", StringComparison.Ordinal);

Commands\Sdk\SdkExportCommand.cs (1)

165candidate.LanguageId.Value.StartsWith(language, StringComparison.OrdinalIgnoreCase) ||

Commands\Sdk\SdkGenerateCommand.cs (2)

101l.LanguageId.Value.StartsWith(language, StringComparison.OrdinalIgnoreCase) || 176if (!filePath.StartsWith(outputDirFullPath, StringComparison.OrdinalIgnoreCase))

Documentation\ApiDocs\ApiDocsIndexService.cs (2)

1098if (item.NameLower.StartsWith(queryToken, StringComparison.Ordinal)) 1105.Where(segment => segment.StartsWith(queryToken, StringComparison.Ordinal))

DotNet\DotNetCliRunner.cs (3)

1217var successLine = lines.SingleOrDefault(x => x.StartsWith("Success: Aspire.ProjectTemplates", StringComparison.Ordinal)); 1735if (line.StartsWith("Project(s)", StringComparison.OrdinalIgnoreCase) || 1736line.StartsWith("----------", StringComparison.Ordinal))

Git\GitWorktree.cs (1)

277if (!line.StartsWith(GitDirPrefix, StringComparison.OrdinalIgnoreCase))

Interaction\SpectreConsoleLoggerProvider.cs (1)

40(categoryName.StartsWith("Aspire.Cli", StringComparison.Ordinal) || logLevel >= LogLevel.Warning);

Mcp\Tools\ListIntegrationsTool.cs (2)

175if (packageId.StartsWith("CommunityToolkit.Aspire.Hosting.", StringComparison.Ordinal)) 181if (packageId.StartsWith("Aspire.Hosting.", StringComparison.Ordinal))

Npm\INpmProvenanceChecker.cs (1)

158if (!refString.StartsWith("refs/", StringComparison.Ordinal))

Npm\SigstoreNpmProvenanceChecker.cs (2)

302if (sriIntegrity is not null && sriIntegrity.StartsWith("sha512-", StringComparison.OrdinalIgnoreCase)) 351!sriIntegrity.StartsWith("sha512-", StringComparison.OrdinalIgnoreCase) ||

NuGet\NuGetPackageCache.cs (9)

Packaging\NuGetConfigMerger.cs (1)

650return pattern.StartsWith("Aspire", StringComparison.OrdinalIgnoreCase);

Packaging\PackageChannel.cs (2)

116var aspireMapping = mappings.FirstOrDefault(m => m.PackageFilter.StartsWith("Aspire", StringComparison.OrdinalIgnoreCase)); 815return mapping.PackageFilter.StartsWith("Aspire", StringComparison.OrdinalIgnoreCase) &&

Packaging\PackageMapping.cs (1)

21PackageFilter.StartsWith("Aspire", StringComparison.OrdinalIgnoreCase) &&

Packaging\PackageSourceOverrideMappings.cs (2)

61if (mapping.PackageFilter.StartsWith("Aspire", StringComparison.OrdinalIgnoreCase)) 156if (source.StartsWith("file:", StringComparison.OrdinalIgnoreCase) &&

Packaging\PackagingService.cs (1)

290if (!identityChannel.StartsWith("pr-", StringComparison.OrdinalIgnoreCase) ||

Projects\AppHostCandidateFinder.cs (3)

266|| candidate.StartsWith(ancestor + Path.DirectorySeparatorChar, pathComparison); 298if (relative == "." || relative.StartsWith("..", StringComparison.Ordinal)) 592|| directoryPath.StartsWith(_excludePath + Path.DirectorySeparatorChar, _pathComparison);

Projects\AppHostEnvironmentDefaults.cs (2)

93if (argument.StartsWith(EnvironmentArgumentName + "=", StringComparison.Ordinal)) 98if (argument.StartsWith(EnvironmentArgumentAlias + "=", StringComparison.Ordinal))

Projects\DotNetAppHostProject.cs (5)

181if (trimmedLine.StartsWith("#:sdk Aspire.AppHost.Sdk", StringComparison.Ordinal)) 477var startsWithThisFileDirectory = trimmed.StartsWith(thisFileDirectory, StringComparison.OrdinalIgnoreCase); 612if (!start.StartsWith(thisFileDirectory, StringComparison.OrdinalIgnoreCase)) 955if (!start.StartsWith(thisFileDirectory, StringComparison.OrdinalIgnoreCase)) 1348trimmedSdk.StartsWith(AspireAppHostSdkName + "/", StringComparison.OrdinalIgnoreCase))

Projects\DotNetBasedAppHostServerProject.cs (5)

194else if (integration.Name.StartsWith("Aspire.Hosting", StringComparison.OrdinalIgnoreCase) && 293integration.Name.StartsWith("Aspire.AppHost.Sdk", StringComparison.OrdinalIgnoreCase)) 773!configDir.StartsWith(globalNuGetPath, StringComparison.OrdinalIgnoreCase) && 774(workingDirFullPath.StartsWith(configDir, StringComparison.OrdinalIgnoreCase) || 775configDir.StartsWith(workingDirFullPath, StringComparison.OrdinalIgnoreCase)))

Projects\FallbackProjectParser.cs (1)

205if (trimmedSdk.StartsWith(sdkPrefix + "/", StringComparison.OrdinalIgnoreCase))

Projects\GuestAppHostProject.cs (1)

2009if (!fullPath.StartsWith(root + Path.DirectorySeparatorChar, PathComparison))

Projects\ILanguageDiscovery.cs (1)

112if (pattern.StartsWith("*.", StringComparison.Ordinal))

Projects\JavaAppHostToolchainResolver.cs (1)

851.. baseCompile.UpToDateCheck.Inputs.Where(static input => !input.StartsWith("src/main/java", StringComparison.Ordinal)),

Projects\PrebuiltAppHostServer.cs (4)

1054if (hasOverride && mapping.PackageFilter.StartsWith("Aspire", StringComparison.OrdinalIgnoreCase)) 1316mapping.PackageFilter.StartsWith("Aspire", StringComparison.OrdinalIgnoreCase); 1335var shouldUseExactAspirePackageVersion = useExactPackageVersions && packageName.StartsWith("Aspire", StringComparison.OrdinalIgnoreCase); 1670pkg.Name.StartsWith("Aspire.AppHost.Sdk", StringComparison.OrdinalIgnoreCase))

Projects\ProjectLocator.cs (1)

632return filePath.StartsWith(prefix, StringComparisons.FileSystemPath);

Projects\ProjectUpdater.cs (6)

213return path.StartsWith(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), StringComparison.Ordinal); 218return path.StartsWith(globalNuGetFolder, StringComparison.Ordinal); 625trimmedSdk.StartsWith(AspireAppHostSdkName + "/", StringComparison.OrdinalIgnoreCase)) 648trimmedSdk.StartsWith(AspireAppHostSdkName + "/", StringComparison.OrdinalIgnoreCase)) 1029return packageId.StartsWith("Aspire.", StringComparison.Ordinal); 1167return value.StartsWith("$(", StringComparison.Ordinal) && value.EndsWith(")", StringComparison.Ordinal) && value.Length > 3;

Projects\TypeScriptAppHostToolchainResolver.cs (2)

420if (!packageManager.StartsWith(yarnPackageManagerPrefix, StringComparison.OrdinalIgnoreCase)) 435if (!packageManager.StartsWith(denoPackageManagerPrefix, StringComparison.OrdinalIgnoreCase))

Scaffolding\PackageJsonMerger.cs (2)

160if (name.StartsWith(AspirePrefix, StringComparison.Ordinal)) 195if (name.StartsWith(AspirePrefix, StringComparison.Ordinal))

src\Shared\BackchannelConstants.cs (5)

368if (fileName.StartsWith($"{SocketPrefix}.", StringComparison.Ordinal)) 376if (fileName.StartsWith("aux.sock.", StringComparison.Ordinal)) 560if (!fileName.StartsWith(prefixFileName + ".", StringComparison.Ordinal)) 639if (socketPrefix.StartsWith("cli", StringComparison.OrdinalIgnoreCase)) 644if (socketPrefix.StartsWith("apphost", StringComparison.OrdinalIgnoreCase))

src\Shared\IntegrationPackageProbeManifest.cs (1)

233if (fileNameWithoutExtension.StartsWith("lib", StringComparison.OrdinalIgnoreCase) &&

src\Shared\NpmVersionHelper.cs (5)

34normalizedVersion.StartsWith("workspace:", StringComparison.OrdinalIgnoreCase) || 35normalizedVersion.StartsWith("file:", StringComparison.OrdinalIgnoreCase) || 36normalizedVersion.StartsWith("link:", StringComparison.OrdinalIgnoreCase)) 44if (normalizedVersion.StartsWith(">=", StringComparison.Ordinal) || 45normalizedVersion.StartsWith("<=", StringComparison.Ordinal))

Telemetry\InternalMicrosoftDetector.cs (1)

888if (name.StartsWith("COPILOT_GH_ACCOUNT_", StringComparison.OrdinalIgnoreCase) && value is not null && LooksLikeGitHubToken(value))

Templating\CliTemplateFactory.cs (1)

311.Where(name => name.StartsWith(resourcePrefix, StringComparison.Ordinal))

Utils\ArchiveHelper.cs (3)

49if (!fullPath.StartsWith(normalizedDestination + Path.DirectorySeparatorChar, StringComparison.Ordinal) && 89if (!fullPath.StartsWith(normalizedDestination + Path.DirectorySeparatorChar, StringComparison.Ordinal) && 123if (!linkTarget.StartsWith(normalizedDestination + Path.DirectorySeparatorChar, StringComparison.Ordinal) &&

Utils\CliPathHelper.cs (2)

258if (string.IsNullOrEmpty(path) || !path.StartsWith("/private/", StringComparison.Ordinal)) 266path.StartsWith(firmlink, StringComparison.Ordinal) &&

Utils\DotNetToolDetection.cs (1)

254if (!packageId.StartsWith(ridSpecificPackagePrefix, StringComparison.OrdinalIgnoreCase))

Utils\EnvironmentChecker\DcpKubeconfig.cs (1)

110if (!trimmed.StartsWith(prefix, StringComparison.Ordinal))

Utils\EnvironmentChecker\DeprecatedWorkloadCheck.cs (4)

125if (trimmedLine.StartsWith("Installed", StringComparison.OrdinalIgnoreCase) || 126trimmedLine.StartsWith("Workload version:", StringComparison.OrdinalIgnoreCase) || 127trimmedLine.StartsWith("---", StringComparison.Ordinal) || 128trimmedLine.StartsWith("Use", StringComparison.OrdinalIgnoreCase) ||

Utils\EnvironmentChecker\VsCodeExtensionCheck.cs (1)

215return folderName.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)

Utils\MissingJavaScriptToolWarning.cs (1)

26if (s_missingToolPrefixes.Any(prefix => line.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)))

Utils\PackageSourceRedactor.cs (2)

45sourceToParse.StartsWith("http://", StringComparison.OrdinalIgnoreCase) || 46sourceToParse.StartsWith("https://", StringComparison.OrdinalIgnoreCase);

Utils\ReparsePoint.cs (1)

320target.StartsWith(ntLocalPathPrefix, StringComparison.Ordinal) &&

Utils\StringUtils.cs (1)

65if (targetLower.StartsWith(searchLower, StringComparison.Ordinal))

Utils\VersionHelper.cs (2)

22channelName.StartsWith("pr-", StringComparison.OrdinalIgnoreCase) || 23channelName.StartsWith("run-", StringComparison.OrdinalIgnoreCase));

aspire-managed (4)

NuGet\Commands\NuGetPackageAssetResolver.cs (3)

182if (!relativePath.StartsWith("runtimes/", StringComparison.OrdinalIgnoreCase) && 209if (relativePath.StartsWith("runtimes/", StringComparison.OrdinalIgnoreCase)) 238if (!relativePath.StartsWith(runtimePrefix, StringComparison.OrdinalIgnoreCase) ||

src\Shared\IntegrationPackageProbeManifest.cs (1)

233if (fileNameWithoutExtension.StartsWith("lib", StringComparison.OrdinalIgnoreCase) &&

Aspire.Acquisition.Tests (3)

Scripts\Common\FakeArchiveHelper.cs (1)

20var isWindows = platform.StartsWith("win", StringComparison.OrdinalIgnoreCase);

Scripts\Common\RealGitHubPRFixture.cs (2)

165var hasCliNativeArchives = artifactNames.Any(n => n.StartsWith("cli-native-", StringComparison.OrdinalIgnoreCase)); 167var hasBuiltNugetsRid = artifactNames.Any(n => n.StartsWith("built-nugets-for", StringComparison.OrdinalIgnoreCase));

Aspire.Azure.AI.Inference (1)

AspireAzureAIInferenceExtensions.cs (1)

491|| path.StartsWith($"{expectedPath}/", StringComparison.OrdinalIgnoreCase);

Aspire.Cli.EndToEnd.Tests (10)

EmulatedLocalReleaseBuildTests.cs (1)

385if (package.Name.StartsWith("Aspire.", StringComparison.OrdinalIgnoreCase) &&

Helpers\CaptureWorkspaceOnFailureAttribute.cs (4)

64if (kvp.Key.StartsWith("CapturePath:", StringComparison.Ordinal) && 72if (kvp.Key.StartsWith("CaptureFile:", StringComparison.Ordinal) && 96if (kvp.Key.StartsWith("CapturePath:", StringComparison.Ordinal) && 105if (kvp.Key.StartsWith("CaptureFile:", StringComparison.Ordinal) &&

Helpers\CliE2ETestHelpers.cs (3)

1039if (!packageFiles.Any(file => Path.GetFileName(file).StartsWith("Aspire.Hosting.", StringComparison.OrdinalIgnoreCase))) 1048if (!packageFiles.Any(file => Path.GetFileName(file).StartsWith(prefix, StringComparison.OrdinalIgnoreCase))) 1163if (captureFileName.StartsWith(".", StringComparison.Ordinal))

JavaScriptPublishTests.cs (1)

231if (packageManager?.StartsWith("yarn@", StringComparison.OrdinalIgnoreCase) == true)

tests\Shared\CliPackageDiscovery.cs (1)

56|| !fileName.StartsWith(AspireCliPackagePrefix, StringComparison.OrdinalIgnoreCase)

Aspire.Cli.Tests (62)

Acquisition\InstallationDiscoveryDiscoverAllTests.cs (2)

711info.Path.StartsWith(toolStore, StringComparison.Ordinal) || 712(info.CanonicalPath?.StartsWith(toolStore, StringComparison.Ordinal) ?? false));

Agents\CommonAgentApplicatorsTests.cs (2)

171if (!normalizedContent.StartsWith("---\n", StringComparison.Ordinal)) 192if (!line.StartsWith(keyPrefix, StringComparison.Ordinal))

CliBootstrapTests.cs (1)

65s_fixedChannels.Contains(channel) || channel.StartsWith("pr-", StringComparison.Ordinal),

Commands\DescribeCommandTests.cs (14)

Commands\LogsCommandTests.cs (6)

544var logLines = outputWriter.Logs.Where(l => l.StartsWith("2025-", StringComparison.Ordinal)).ToList(); 567var logLines = outputWriter.Logs.Where(l => l.StartsWith("[", StringComparison.Ordinal)).ToList(); 601var logLine = Assert.Single(outputWriter.Logs, l => l.StartsWith("[", StringComparison.Ordinal)); 920Assert.Single(outputWriter.Logs, l => l.TrimStart().StartsWith("{", StringComparison.Ordinal)); 943Assert.Single(outputWriter.Logs, l => l.TrimStart().StartsWith("{", StringComparison.Ordinal)); 1438if (line.StartsWith("[", StringComparison.Ordinal))

Commands\NewCommandChannelResolutionTests.cs (2)

671!identityChannel.StartsWith("pr-", StringComparison.OrdinalIgnoreCase); 719if (identityChannel.StartsWith("pr-", StringComparison.OrdinalIgnoreCase) &&

Commands\NewCommandTemplateConfigPersistenceTests.cs (1)

440var isPrChannel = identityChannel.StartsWith("pr-", StringComparison.OrdinalIgnoreCase);

Commands\TelemetryTracesCommandTests.cs (2)

295var summaryLine = outputWriter.Logs.Last(l => l.StartsWith("Showing", StringComparison.Ordinal)); 346var summaryLine = outputWriter.Logs.Last(l => l.StartsWith("Showing", StringComparison.Ordinal));

Commands\UpdateCommandTests.cs (1)

2875if (hive.Name.StartsWith("pr-", StringComparison.OrdinalIgnoreCase))

DotNet\DotNetCliRunnerTests.cs (3)

557var binlogArgument = Assert.Single(args, arg => arg.StartsWith("/bl:", StringComparison.Ordinal)); 594Assert.DoesNotContain(args, arg => arg.StartsWith("/bl:", StringComparison.Ordinal)); 2261Assert.DoesNotContain(args, a => a.StartsWith("-t:", StringComparison.Ordinal));

Mcp\ApiDocs\ApiDocsCacheTests.cs (2)

42Assert.DoesNotContain(cacheFiles, static file => file.StartsWith("https___aspire.dev_", StringComparison.Ordinal)); 68Assert.DoesNotContain(cacheFiles, static file => file.StartsWith("https___aspire.dev_", StringComparison.Ordinal));

Mcp\ApiDocs\ApiDocsIndexServiceTests.cs (2)

107result.Id.StartsWith("csharp/aspire.test.package/resourcebuilderextensions/methods#withenvironment-", StringComparison.Ordinal)); 109result.Id.StartsWith("csharp/aspire.test.package/resourcebuilderextensions/methods#withenvironment-", StringComparison.Ordinal));

Mcp\ApiDocs\ApiMemberMarkdownParserTests.cs (1)

100Assert.True(item.Id.StartsWith("csharp/aspire.test.package/resourcebuilderextensions/methods#withenvironment-", StringComparison.Ordinal), item.Id);

Npm\AspireJsLauncherTests.cs (4)

198if (rid.StartsWith("win-", StringComparison.Ordinal)) 203if (rid.StartsWith("osx-", StringComparison.Ordinal)) 208if (rid.StartsWith("linux-musl-", StringComparison.Ordinal)) 213if (rid.StartsWith("linux-", StringComparison.Ordinal))

Packaging\NuGetConfigMergerSnapshotTests.cs (5)

77if (channelName.StartsWith("pr-", StringComparison.OrdinalIgnoreCase)) 139if (channelName.StartsWith("pr-", StringComparison.OrdinalIgnoreCase)) 200if (channelName.StartsWith("pr-", StringComparison.OrdinalIgnoreCase)) 259if (channelName.StartsWith("pr-", StringComparison.OrdinalIgnoreCase)) 323if (channelName.StartsWith("pr-", StringComparison.OrdinalIgnoreCase))

Projects\PrebuiltAppHostServerTests.cs (4)

579var isUnderRoot = workingDirectory.StartsWith(rootDirectory, StringComparison.OrdinalIgnoreCase); 772gpfValue!.StartsWith(tempConfigDir, StringComparison.Ordinal), 829gpfValue!.StartsWith(tempConfigDir, StringComparison.Ordinal), 952gpfValue!.StartsWith(tempConfigDir, StringComparison.Ordinal),

Projects\ProjectUpdaterTests.cs (2)

3839var addCalls = calls.Where(c => c.StartsWith("add:", StringComparison.Ordinal)).ToList(); 3844var restoreCalls = calls.Where(c => c.StartsWith("restore:", StringComparison.Ordinal)).ToList();

Telemetry\TelemetryConfigurationTests.cs (1)

392t.Key.StartsWith("aspire.cli.microsoft_internal", StringComparison.Ordinal))];

Templating\JavaAppHostTemplateTests.cs (1)

19Assert.DoesNotContain(lines, line => line.TrimStart().StartsWith("package ", StringComparison.Ordinal));

TestServices\FakeNuGetPackageCache.cs (1)

43if (packageId.StartsWith("tags:", StringComparison.OrdinalIgnoreCase))

TestServices\TestAppHostAuxiliaryBackchannel.cs (1)

220|| l.ResourceName.StartsWith(resourceName + "-", StringComparison.OrdinalIgnoreCase));

TestServices\TestAppHostProjectFactory.cs (2)

127if (trimmedLine.StartsWith("#:sdk Aspire.AppHost.Sdk", StringComparison.Ordinal)) 265if (trimmedLine.StartsWith("#:sdk Aspire.AppHost.Sdk", StringComparison.Ordinal))

Utils\PathNormalizerTests.cs (2)

179var logicalPath = file.FullName.StartsWith("/private/var/", StringComparison.Ordinal) 183Assert.SkipWhen(!logicalPath.StartsWith("/var/", StringComparison.Ordinal), $"Temp path '{logicalPath}' is not under /var.");

Aspire.Components.Common.TestUtilities (2)

ConformanceTests.cs (2)

347? loggerFactory.Categories.Any(c => c.StartsWith(req.Name, StringComparison.Ordinal)) 369Assert.Contains(loggerFactory.Categories, c => c.StartsWith(req.Name, StringComparison.Ordinal));

Aspire.Dashboard (10)

Components\Controls\StructuredLogDetails.razor.cs (1)

98MoveAttributes(attributes, _exceptionAttributes, a => a.Name.StartsWith("exception.", StringComparison.OrdinalIgnoreCase));

Model\ConnectionStringParser.cs (4)

190var uriValue = connectionString.StartsWith(jdbcPrefix, StringComparison.OrdinalIgnoreCase) 223if (connectionString.StartsWith("jdbc:", StringComparison.OrdinalIgnoreCase)) 572connectionString.StartsWith("./", StringComparison.Ordinal) || connectionString.StartsWith("../", StringComparison.Ordinal) ||

Model\GenAI\GenAIVisualizerDialogViewModel.cs (1)

465if (attr.Key.StartsWith(prefix, StringComparison.Ordinal))

Model\ResourceUrlHelpers.cs (1)

55.ThenByDescending(e => e.Url?.StartsWith("https", StringComparison.Ordinal) == true)

Otlp\Model\OtlpHelpers.cs (1)

505return existingId.StartsWith(incomingId, StringComparison.OrdinalIgnoreCase);

Otlp\Storage\ResourceKey.cs (1)

22instanceId.StartsWith(name, StringComparisons.ResourceName) &&

ServiceClient\DashboardSqliteDatabase.cs (1)

194.Where(name => name.StartsWith(SchemaResourcePrefix, StringComparison.Ordinal) && name.EndsWith(".sql", StringComparison.Ordinal))

Aspire.Dashboard.Components.Tests (4)

Controls\LogViewerTests.cs (2)

433Assert.True(background.StartsWith("var(", StringComparison.Ordinal), $"Unexpected background style: {style}"); 458if (declaration.StartsWith(propertyPrefix, StringComparison.OrdinalIgnoreCase))

Dialogs\ManageDataDialogTests.cs (2)

359(accessibleName.StartsWith("Select ", StringComparison.Ordinal) || 360accessibleName.StartsWith("Deselect ", StringComparison.Ordinal));

Aspire.Dashboard.Tests (11)

Integration\FrontendBrowserTokenAuthTests.cs (3)

158var httpsCookie = Assert.Single(httpsResponse.Headers.GetValues("Set-Cookie"), c => c.StartsWith(".Aspire.Dashboard.Auth=", StringComparison.Ordinal)); 159var httpCookie = Assert.Single(httpResponse.Headers.GetValues("Set-Cookie"), c => c.StartsWith(".Aspire.Dashboard.Auth.Http=", StringComparison.Ordinal)); 276var cookie = Assert.Single(response.Headers.GetValues("Set-Cookie"), c => c.StartsWith(".Aspire.Dashboard.Auth=", StringComparison.Ordinal));

Model\DashboardDataSourceTests.cs (1)

261Assert.False(runDirectory.StartsWith(workspace.Path, StringComparison.OrdinalIgnoreCase));

Model\SqliteResourceRepositoryTests.cs (1)

975Assert.Single(queries, query => query.TrimStart().StartsWith($"INSERT INTO {table} ", StringComparison.Ordinal));

TelemetryRepositoryTests\MetricsTests.cs (6)

2169Assert.Single(queries, query => query.StartsWith("DELETE FROM telemetry_metric_points", StringComparison.Ordinal)); 2170var insertQuery = Assert.Single(queries, query => query.StartsWith("INSERT INTO telemetry_metric_points", StringComparison.Ordinal)); 2293var exemplarInsert = Assert.Single(queries, query => query.StartsWith("INSERT OR IGNORE INTO telemetry_metric_exemplars", StringComparison.Ordinal)); 2295Assert.Single(queries, query => query.StartsWith("INSERT INTO telemetry_metric_exemplar_attributes", StringComparison.Ordinal)); 2356Assert.DoesNotContain(queries, query => query.StartsWith("UPDATE telemetry_resources SET has_metrics", StringComparison.Ordinal)); 2357Assert.DoesNotContain(queries, query => query.StartsWith("DELETE FROM telemetry_metric_points", StringComparison.Ordinal));

Aspire.Deployment.EndToEnd.Tests (5)

AzureResourceScopeDeploymentTests.cs (1)

180if (!line.StartsWith(sdkDirectivePrefix, StringComparison.Ordinal))

AzureSandboxesDeploymentTests.cs (1)

439File.ReadLines(appHostFilePath).Where(line => line.StartsWith("#:", StringComparison.Ordinal)));

FoundryHostedAgentDeploymentTests.cs (1)

618.Where(line => line.StartsWith("data:", StringComparison.Ordinal))

Helpers\DeploymentReporter.cs (1)

82if (errorMessage.StartsWith(XunitDynamicSkipToken, StringComparison.Ordinal))

tests\Shared\CliPackageDiscovery.cs (1)

56|| !fileName.StartsWith(AspireCliPackagePrefix, StringComparison.OrdinalIgnoreCase)

Aspire.Hosting (19)

ApplicationModel\ExecutableLaunchRecipe.cs (2)

827argument.StartsWith("[env:", StringComparison.OrdinalIgnoreCase) && argument.EndsWith(']'); 892value.StartsWith(option + "=", StringComparison.Ordinal)))

ApplicationModel\McpServerEndpointAnnotation.cs (1)

60if (!normalizedPath.StartsWith("/", StringComparison.Ordinal))

ContainerResourceBuilderExtensions.cs (1)

448if (!parsedReference.Digest.StartsWith(prefix, StringComparison.Ordinal))

Dashboard\DashboardEventHandlers.cs (2)

591if (name.StartsWith("ASPIRE_DASHBOARD_", StringComparison.OrdinalIgnoreCase) && 1004if (category.StartsWith("Aspire.Dashboard.", StringComparison.Ordinal))

McpServerResourceBuilderExtensions.cs (1)

101if (!normalizedPath.StartsWith("/", StringComparison.Ordinal))

Pipelines\Internal\FileDeploymentStateManager.cs (3)

281sectionName.StartsWith($"{name}:", StringComparison.Ordinal))) 287foreach (var claimedSectionName in _claimedSectionNames.Where(name => name.StartsWith($"{sectionName}:", StringComparison.Ordinal))) 364name.StartsWith($"{sectionName}:", StringComparison.Ordinal));

Publishing\ContainerImageInspectionResult.cs (1)

213!digest.StartsWith(Prefix, StringComparison.Ordinal))

Publishing\PodmanContainerRuntime.cs (2)

318var remoteImageName = imageName.StartsWith("docker://", StringComparison.OrdinalIgnoreCase) 362var localImageName = imageName.StartsWith("docker://", StringComparison.OrdinalIgnoreCase)

ResourceBuilderExtensions.cs (1)

3947if (mediaType.StartsWith("text/", StringComparison.OrdinalIgnoreCase) ||

src\Shared\BackchannelConstants.cs (5)

Aspire.Hosting.Analyzers (1)

Infrastructure\WellKnownTypes.cs (1)

122if (type.ContainingAssembly.Identity.Name.StartsWith("Aspire.", StringComparison.Ordinal))

Aspire.Hosting.Azure (5)

AzureEnvironmentResource.cs (1)

305var shortType = type.StartsWith("Microsoft.", StringComparison.OrdinalIgnoreCase)

AzureProvisioningController.cs (1)

1005state?.StartsWith(ProvisioningStatePrefix, StringComparison.Ordinal) == true;

AzureProvisioningFailureDetails.cs (1)

448=> propertyName.StartsWith(PropertyPrefix, StringComparison.Ordinal);

Provisioning\Provisioners\BicepProvisioner.cs (2)

1197if (!properties.Any(static property => property.Name.StartsWith(DeploymentOperationPropertyPrefix, StringComparison.Ordinal))) 1205return [.. properties.Where(static property => !property.Name.StartsWith(DeploymentOperationPropertyPrefix, StringComparison.Ordinal))];

Aspire.Hosting.Azure.AppContainers (1)

AzureContainerAppExtensions.cs (1)

227if (normalizedExpression.StartsWith(TakePrefix, StringComparison.Ordinal) &&

Aspire.Hosting.Azure.ContainerRegistry (1)

AzureContainerRegistryExtensions.cs (1)

194.Where(t => t.Name.Value?.StartsWith(prefix, StringComparison.Ordinal) == true)

Aspire.Hosting.Azure.Kubernetes.Tests (15)

AzureKubernetesInfrastructureTests.cs (13)

tests\Shared\FakeHelmRunner.cs (2)

57if (arguments.StartsWith("version", StringComparison.OrdinalIgnoreCase)) 74if (arguments.StartsWith("uninstall", StringComparison.OrdinalIgnoreCase))

Aspire.Hosting.Azure.Kusto.Tests (1)

KustoFunctionalTests.cs (1)

277return (record.Category ?? string.Empty).StartsWith("Aspire.Hosting.Tests.Resources", StringComparison.OrdinalIgnoreCase);

Aspire.Hosting.Azure.Sandboxes (2)

AzureSandboxContainerDeployment.cs (2)

685!imageReference.StartsWith($"{registryEndpoint}/", StringComparison.OrdinalIgnoreCase)) 1877return sectionName.StartsWith(SandboxStateSectionPrefix, StringComparison.Ordinal)

Aspire.Hosting.Azure.Tests (7)

AzureAppServiceEnvironmentExtensionsTests.cs (2)

155Assert.Null(model.Resources.OfType<AzureRoleAssignmentResource>().SingleOrDefault(resource => resource.Name.StartsWith("env-mi-roles-", StringComparison.Ordinal))); 176Assert.Null(model.Resources.OfType<AzureRoleAssignmentResource>().SingleOrDefault(resource => resource.Name.StartsWith("env-mi-roles-", StringComparison.Ordinal)));

AzureBicepProvisionerTests.cs (2)

1226property.Name.StartsWith("azure.deployment.operations.", StringComparison.Ordinal) && 1295Assert.DoesNotContain(resourceEvent.Snapshot.Properties, p => p.Name.StartsWith("azure.deployment.operations.", StringComparison.Ordinal));

AzureContainerAppEnvironmentExtensionsTests.cs (2)

402Assert.Null(model.Resources.OfType<AzureRoleAssignmentResource>().SingleOrDefault(resource => resource.Name.StartsWith("env-mi-roles-", StringComparison.Ordinal))); 422Assert.Null(model.Resources.OfType<AzureRoleAssignmentResource>().SingleOrDefault(resource => resource.Name.StartsWith("env-mi-roles-", StringComparison.Ordinal)));

DefaultArmClientProviderTests.cs (1)

53Assert.DoesNotContain(credential.Scopes, static scope => scope.StartsWith("https://management.azure.com", StringComparison.OrdinalIgnoreCase));

Aspire.Hosting.Browsers (3)

BrowserLogsArtifacts.cs (1)

67var extension = fileExtension.StartsWith(".", StringComparison.Ordinal) ? fileExtension : "." + fileExtension;

ChromiumBrowserResolver.cs (1)

310directoryName.StartsWith("Profile ", StringComparison.OrdinalIgnoreCase);

ChromiumDevToolsActivePortParser.cs (1)

38if (!browserPathLine.StartsWith("/", StringComparison.Ordinal))

Aspire.Hosting.Browsers.Tests (5)

BrowserHostTests.cs (2)

64Assert.DoesNotContain(capturedArguments, static argument => argument.StartsWith("--remote-debugging-address=", StringComparison.Ordinal)); 65Assert.DoesNotContain(capturedArguments, static argument => argument.StartsWith("--remote-debugging-port=", StringComparison.Ordinal));

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

67var extension = fileExtension.StartsWith(".", StringComparison.Ordinal) ? fileExtension : "." + fileExtension;

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

310directoryName.StartsWith("Profile ", StringComparison.OrdinalIgnoreCase);

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

38if (!browserPathLine.StartsWith("/", StringComparison.Ordinal))

Aspire.Hosting.CodeGeneration.Go (4)

AtsGoCodeGenerator.cs (4)

2157typeName.StartsWith("*", StringComparison.Ordinal) || 2158typeName.StartsWith("[]", StringComparison.Ordinal) || 2159typeName.StartsWith("map[", StringComparison.Ordinal) || 2161typeName.StartsWith("func(", StringComparison.Ordinal);

Aspire.Hosting.CodeGeneration.Java (20)

AtsJavaCodeGenerator.cs (20)

Aspire.Hosting.CodeGeneration.Python (5)

AtsPythonCodeGenerator.cs (5)

739if (methodName.StartsWith("with_", StringComparison.Ordinal)) 749if (methodName.StartsWith("With", StringComparison.Ordinal)) 1227if (setterMethodName.StartsWith("set", StringComparison.OrdinalIgnoreCase) && setterMethodName.Length > 3) 2660if (optionType.StartsWith("(", StringComparison.Ordinal)) 2743else if (currentOption.StartsWith("(", StringComparison.Ordinal)) // Tuple of parameters

Aspire.Hosting.CodeGeneration.Rust.Tests (1)

RustLanguageSupportTests.cs (1)

136else if (inBinTable && trimmed.StartsWith(namePrefix, StringComparison.Ordinal))

Aspire.Hosting.CodeGeneration.TypeScript (6)

src\Shared\NpmVersionHelper.cs (5)

TypeScriptApiProjector.cs (1)

2587if (setterMethodName.StartsWith("set", StringComparison.OrdinalIgnoreCase) && setterMethodName.Length > 3)

Aspire.Hosting.CodeGeneration.TypeScript.Tests (8)

AtsTypeScriptCodeGeneratorTests.cs (6)

1509Assert.Contains(lines, line => line.StartsWith("withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ", StringComparison.Ordinal)); 2423method.Name.StartsWith("WithDeno", StringComparison.Ordinal)) 2428Assert.Contains(denoMethods, method => method.Name.StartsWith("WithDeno", StringComparison.Ordinal)); 2630declaration => declaration.Content.StartsWith( 2786declaration => declaration.Content.StartsWith("export interface RunAsEmulatorOptions ", StringComparison.Ordinal)); 2789declaration => declaration.Content.StartsWith("export interface RunAsEmulatorOptions ", StringComparison.Ordinal));

TypeScriptLanguageSupportTests.cs (2)

239var httpsPort = GetPort(applicationUrls.Single(url => url.StartsWith("https://", StringComparison.OrdinalIgnoreCase))); 240var httpPort = GetPort(applicationUrls.Single(url => url.StartsWith("http://", StringComparison.OrdinalIgnoreCase)));

Aspire.Hosting.DevTunnels (1)

DevTunnelCliClient.cs (1)

45.FirstOrDefault(l => l.StartsWith(prefix, StringComparison.OrdinalIgnoreCase));

Aspire.Hosting.DevTunnels.Tests (1)

TestDevTunnelCli.cs (1)

40["create", ..] => (nameof(CreateTunnelAsync), args.Length > 1 && !args[1].StartsWith("--", StringComparison.Ordinal) ? args[1] : null, _createResults),

Aspire.Hosting.Docker (1)

DockerComposeEnvironmentContext.cs (1)

157.Where(kvp => kvp.Value is EndpointReference epRef && epRef.Scheme == "https" && kvp.Key.StartsWith("services__", StringComparison.Ordinal))

Aspire.Hosting.Dotnet (1)

DotnetProjectBuildArtifactManager.cs (1)

228if (!fileName.StartsWith(BuildProjectFilePrefix, StringComparison.Ordinal) ||

Aspire.Hosting.EntityFrameworkCore (4)

EFCoreOperationExecutor.cs (1)

181if (frameworkCandidate.StartsWith("net", StringComparison.OrdinalIgnoreCase))

EFMigrationResourceBuilderExtensions.cs (2)

496if (tfm is null || !tfm.StartsWith("net", StringComparison.OrdinalIgnoreCase) || tfm.Length <= 3) 559targetRuntime is not null && targetRuntime.StartsWith("win", StringComparison.OrdinalIgnoreCase);

EFResourceBuilderExtensions.cs (1)

402? runtime.StartsWith("win", StringComparison.OrdinalIgnoreCase)

Aspire.Hosting.Foundry (4)

HostedAgent\HostedAgentConfiguration.cs (2)

203name.StartsWith("FOUNDRY_", StringComparison.OrdinalIgnoreCase) || 204name.StartsWith("AGENT_", StringComparison.OrdinalIgnoreCase);

Toolbox\FoundryToolboxReadinessProbe.cs (2)

99name.StartsWith($"{label}.", StringComparison.Ordinal))); 199.Where(line => line.StartsWith("data:", StringComparison.Ordinal))

Aspire.Hosting.Foundry.Tests (1)

ProjectWithReferenceTests.cs (1)

65kvp.Key.StartsWith("ConnectionStrings__", StringComparison.Ordinal));

Aspire.Hosting.Integration.Analyzers (2)

AspireExportAnalyzer.cs (1)

846if (shortName.StartsWith("Azure", StringComparison.Ordinal))

src\Aspire.Hosting.Analyzers\Infrastructure\WellKnownTypes.cs (1)

122if (type.ContainingAssembly.Identity.Name.StartsWith("Aspire.", StringComparison.Ordinal))

Aspire.Hosting.Java (9)

JavaDockerfileGenerator.cs (4)

343if (normalized.StartsWith("./", StringComparison.Ordinal)) 426if (normalized.StartsWith("./", StringComparison.Ordinal)) 590if (normalized.StartsWith("./", StringComparison.Ordinal)) 1043if (relative.StartsWith("../", StringComparison.Ordinal) || IsPathRootedOnAnyPlatform(relative))

JavaHostingExtensions.cs (1)

1949return entryPoint.StartsWith("org.springframework.boot.loader.", StringComparison.Ordinal)

JavaVersionDetector.cs (4)

215_ when argument.StartsWith("-P=", StringComparison.Ordinal) => argument[3..], 216_ when argument.StartsWith("-P", StringComparison.Ordinal) => argument[2..], 217_ when argument.StartsWith("--activate-profiles=", StringComparison.Ordinal) => 1073if (value.StartsWith("1.", StringComparison.Ordinal))

Aspire.Hosting.Java.Tests (1)

AddJavaAppPublishTests.cs (1)

177.Where(line => line.StartsWith("COPY ", StringComparison.Ordinal))

Aspire.Hosting.JavaScript (8)

DenoHostingExtensions.cs (4)

262if (feature.StartsWith("--", StringComparison.Ordinal) && 263!feature.StartsWith("--unstable-", StringComparison.Ordinal)) 268annotation.UnstableFlags.Add(feature.StartsWith("--unstable-", StringComparison.Ordinal) ? feature : $"--unstable-{feature}"); 974argument.StartsWith("--env-file=", StringComparison.Ordinal)))

JavaScriptHostingExtensions.cs (4)

2063string s when !string.IsNullOrEmpty(s) && !s.StartsWith("--", StringComparison.Ordinal) => s, 2713packageManager.StartsWith("pnpm@", StringComparison.Ordinal)) 3233if (normalizedPath.StartsWith("./", StringComparison.Ordinal)) 3357if (cleaned.StartsWith(op, StringComparison.Ordinal))

Aspire.Hosting.JavaScript.Tests (6)

AddDenoAppTests.cs (3)

160dockerfileContents.Split('\n').Select(line => line.TrimEnd('\r')).Where(line => line.StartsWith("ENV DENO_DIR", StringComparison.Ordinal)), 712Assert.DoesNotContain(dockerfileContents.Split(Environment.NewLine), line => line.StartsWith("USER ", StringComparison.Ordinal)); 2702=> dockerfileContents.Split('\n').Select(line => line.TrimEnd('\r')).Single(line => line.StartsWith(prefix, StringComparison.Ordinal));

AddJavaScriptAppTests.cs (3)

150line.StartsWith("ARG NPM_", StringComparison.Ordinal) || 151line.StartsWith("RUN npm install", StringComparison.Ordinal) || 366line => line.StartsWith("COPY ", StringComparison.Ordinal)

Aspire.Hosting.Kubernetes (3)

Deployment\HelmDeploymentEngine.cs (1)

404if (path.StartsWith(".Values.", StringComparison.Ordinal))

KubernetesPublishingContext.cs (1)

391if (resourceName.StartsWith($"{baseName.ToLowerInvariant()}-", StringComparison.Ordinal))

KubernetesResource.cs (1)

492.Where(kvp => kvp.Value is EndpointReference epRef && epRef.Scheme == "https" && kvp.Key.StartsWith("services__", StringComparison.Ordinal))

Aspire.Hosting.Kubernetes.Tests (6)

KubernetesDeployTests.cs (3)

2039arguments => arguments.StartsWith("uninstall", StringComparison.OrdinalIgnoreCase))); 2054CommandResultFactory = arguments => arguments.StartsWith("uninstall", StringComparison.OrdinalIgnoreCase) 2086arguments => arguments.StartsWith("uninstall", StringComparison.OrdinalIgnoreCase));

KubernetesGatewayTests.cs (1)

196.First(e => e.Message.StartsWith("Gateway 'public'", StringComparison.Ordinal));

tests\Shared\FakeHelmRunner.cs (2)

57if (arguments.StartsWith("version", StringComparison.OrdinalIgnoreCase)) 74if (arguments.StartsWith("uninstall", StringComparison.OrdinalIgnoreCase))

Aspire.Hosting.Maui.Tests (1)

MauiPlatformExtensionsTests.cs (1)

619argument => argument.StartsWith("-p:CustomAfterMicrosoftCommonTargets=", StringComparison.Ordinal));

Aspire.Hosting.Python (1)

PythonAppResourceBuilderExtensions.cs (1)

770var isUnderAppHostParent = !relativePath.StartsWith("..", StringComparison.Ordinal) &&

Aspire.Hosting.Radius (3)

Publishing\RadiusInfrastructureBuilder.cs (2)

420resourceType.StartsWith("Applications.", StringComparison.Ordinal); 1141&& kvp.Key.StartsWith("services__", StringComparison.Ordinal))

Secrets\KubernetesName.cs (1)

68if (value is "." or ".." || value.StartsWith("..", StringComparison.Ordinal))

Aspire.Hosting.RemoteHost (20)

AssemblyLoader.cs (2)

286assemblyName.StartsWith("Aspire.AppHost.", StringComparison.OrdinalIgnoreCase)) 292assemblyName.StartsWith("Aspire.Hosting.", StringComparison.OrdinalIgnoreCase);

Ats\PolyglotCapabilityInvocationException.cs (4)

485var articleValue = name.StartsWith("a ", StringComparison.OrdinalIgnoreCase) 486|| name.StartsWith("an ", StringComparison.OrdinalIgnoreCase) 501if (value.StartsWith("URI", StringComparison.Ordinal) || 502value.StartsWith("URL", StringComparison.Ordinal))

Ats\ReferenceExpressionRef.cs (1)

246if (part.StartsWith("{", StringComparison.Ordinal) && part.EndsWith("}", StringComparison.Ordinal) &&

AtsCapabilityScanner.cs (9)

AtsContextFilter.cs (1)

675!location.StartsWith(knownAssemblyName, StringComparison.OrdinalIgnoreCase))

CodeGeneration\CodeGeneratorResolver.cs (1)

225&& assemblyName.StartsWith("Aspire.Hosting.CodeGeneration.", StringComparison.OrdinalIgnoreCase);

Language\LanguageSupportResolver.cs (1)

138&& assemblyName.StartsWith("Aspire.Hosting.CodeGeneration.", StringComparison.OrdinalIgnoreCase);

src\Shared\IntegrationPackageProbeManifest.cs (1)

233if (fileNameWithoutExtension.StartsWith("lib", StringComparison.OrdinalIgnoreCase) &&

Aspire.Hosting.RemoteHost.Tests (4)

AtsContextFilterTests.cs (4)

50context.HandleTypes.Where(type => type.AtsTypeId.StartsWith("Aspire.Hosting.Redis/", StringComparison.Ordinal)), 337Assert.Contains(unfilteredContext.Capabilities, c => c.CapabilityId.StartsWith("Aspire.Hosting/", StringComparison.Ordinal)); 338Assert.Contains(unfilteredContext.Capabilities, c => c.CapabilityId.StartsWith(testAssemblyName + "/", StringComparison.Ordinal)); 350c => c.CapabilityId.StartsWith("Aspire.Hosting/", StringComparison.Ordinal));

Aspire.Hosting.Rust (6)

RustDockerfileGenerator.cs (5)

240|| relativeManifest.StartsWith($"..{Path.DirectorySeparatorChar}", StringComparison.Ordinal) 241|| relativeManifest.StartsWith($"..{Path.AltDirectorySeparatorChar}", StringComparison.Ordinal)) 265|| relativePath.StartsWith($"..{Path.DirectorySeparatorChar}", StringComparison.Ordinal) 266|| relativePath.StartsWith($"..{Path.AltDirectorySeparatorChar}", StringComparison.Ordinal)) 333else if (cargoArgs[i].StartsWith("--config=", StringComparison.Ordinal))

RustHostingExtensions.cs (1)

633return candidate.StartsWith(prefix, StringComparison.Ordinal);

Aspire.Hosting.Rust.Tests (1)

AddRustAppPublishTests.cs (1)

1095static l => l.TrimStart().StartsWith("cargo build", StringComparison.Ordinal));

Aspire.Hosting.Sdk.Tests (4)

AppHostSdkTargetsTests.cs (4)

53Assert.DoesNotContain(packageReferences, static packageReference => packageReference.StartsWith("Aspire.Dashboard.Sdk.", StringComparison.Ordinal)); 54Assert.DoesNotContain(packageReferences, static packageReference => packageReference.StartsWith("Aspire.Hosting.Orchestration.", StringComparison.Ordinal)); 1594var dashboardReference = Assert.Single(packageReferences, static packageReference => packageReference.StartsWith("Aspire.Dashboard.Sdk.", StringComparison.Ordinal)); 1595var orchestrationReference = Assert.Single(packageReferences, static packageReference => packageReference.StartsWith("Aspire.Hosting.Orchestration.", StringComparison.Ordinal));

Aspire.Hosting.Testing (2)

DistributedApplicationFactory.cs (2)

306if (key.StartsWith("DOTNET_", StringComparison.OrdinalIgnoreCase)) 312if (key.StartsWith("ASPNETCORE_", StringComparison.OrdinalIgnoreCase))

Aspire.Hosting.Testing.Tests (2)

DashboardUrlTests.cs (2)

53cookie => cookie.StartsWith(".Aspire.Dashboard.Auth", StringComparison.Ordinal)); 189cookie => cookie.StartsWith(".Aspire.Dashboard.Auth", StringComparison.Ordinal));

Aspire.Hosting.Tests (4)

Backchannel\AuxiliaryBackchannelRpcTargetTests.cs (1)

1406Assert.DoesNotContain(snapshot.Properties.Keys, k => k.StartsWith("terminal.", StringComparison.Ordinal));

Dashboard\DashboardServiceDataTerminalTests.cs (1)

39Assert.DoesNotContain(snapshot.Properties, p => p.Name.StartsWith("terminal.", StringComparison.Ordinal));

MSBuildTests.cs (2)

1370Assert.DoesNotContain(archive.Entries, entry => entry.FullName.StartsWith("lib/", StringComparison.Ordinal)); 1397entry => entry.FullName.StartsWith("lib/", StringComparison.Ordinal)

Aspire.Hosting.TestUtilities (1)

Helpers\KubernetesHelper.cs (1)

19if ((name == resourceName || (name.StartsWith(resourceName + "-", StringComparison.Ordinal) && name.EndsWith("-" + resourceNameSuffix, StringComparison.Ordinal))) && ready(r))

Aspire.Templates.Tests (1)

LocalhostTldHostnameTests.cs (1)

101Assert.False(hostname.StartsWith("-", StringComparison.Ordinal),

Aspire.TerminalHost (1)

TerminalHostApp.cs (1)

435(Array.IndexOf(s_knownSources, name) >= 0 || name.StartsWith("OpenTelemetry-", StringComparison.Ordinal)))

Aspire.TestTools (1)

TrxReader.cs (1)

162if (methodName.StartsWith($"{className}.", StringComparison.Ordinal))

Aspire.TypeSystem (1)

AtsConstants.cs (1)

282public static bool IsEnum(string? typeId) => typeId?.StartsWith(EnumPrefix, StringComparison.Ordinal) == true;

blazor-gateway (1)

TelemetryFilters.cs (1)

35if (requestUri.AbsolutePath.StartsWith(excluded, StringComparison.OrdinalIgnoreCase))

BlazorHosted (1)

Program.cs (1)

28|| !request.RequestUri.AbsolutePath.StartsWith("/v1/", StringComparison.Ordinal));

ConfigurationSchemaGenerator (8)

ConfigSchemaEmitter.cs (8)

91foreach (var segment in path.Split(':').Where(segment => !segment.StartsWith(RootPathPrefix, StringComparison.Ordinal))) 565s.StartsWith("T:", StringComparison.Ordinal) || 566s.StartsWith("P:", StringComparison.Ordinal) || 567s.StartsWith("M:", StringComparison.Ordinal) || 568s.StartsWith("F:", StringComparison.Ordinal) || 569s.StartsWith("N:", StringComparison.Ordinal) || 570s.StartsWith("E:", StringComparison.Ordinal) => $"'{s.AsSpan(2)}'", 689if (excludedPath.StartsWith(currentPath, StringComparison.Ordinal) && excludedPath.EndsWith(property.ConfigurationKeyName, StringComparison.Ordinal))

Crossgen2Tasks (1)

CommonFilePulledFromSdkRepo\NuGetUtils.NuGet.cs (1)

50return file.StartsWith("analyzers", StringComparison.Ordinal)

csc (3)

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

536if (dotNetRoot != null && key.StartsWith(RuntimeHostInfo.DotNetRootEnvironmentName, Environment.EnvironmentVariableComparison))

src\roslyn\src\Compilers\Shared\NativeMethods.cs (2)

150if (s.StartsWith(@"\\?\UNC\", StringComparison.Ordinal)) 152if (s.StartsWith(@"\\?\", StringComparison.Ordinal))

CSharpSyntaxGenerator (4)

AbstractFileWriter.cs (2)

184return typeName.StartsWith("SeparatedSyntaxList<", StringComparison.Ordinal); 189return typeName.StartsWith("SyntaxList<", StringComparison.Ordinal);

SignatureWriter.cs (2)

117return typeName.StartsWith("SeparatedSyntaxList<", StringComparison.Ordinal); 122return typeName.StartsWith("SyntaxList<", StringComparison.Ordinal);

dotnet-aot (16)

parent\dotnet\CommandFactory\CommandResolution\LocalToolsCommandResolver.cs (2)

31if (!arguments.CommandName.StartsWith(LeadingDotnetPrefix, StringComparison.OrdinalIgnoreCase)) 49if (!arguments.CommandName.StartsWith(LeadingDotnetPrefix, StringComparison.OrdinalIgnoreCase) ||

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

1079&& !argument.StartsWith("--show-test-results=", StringComparison.Ordinal) 1080&& !argument.StartsWith("--show-test-results:", StringComparison.Ordinal)) 1092while (i + 1 < arguments.Count && !arguments[i + 1].StartsWith("-", StringComparison.Ordinal))

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

196if (_baseDirectory != null && path.StartsWith(_baseDirectory, FileUtilities.PathComparison))

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

430return runtimeIdentifier.StartsWith("browser-", StringComparison.OrdinalIgnoreCase) || 431runtimeIdentifier.StartsWith("wasi-", StringComparison.OrdinalIgnoreCase);

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

158&& !relative.StartsWith(".." + Path.DirectorySeparatorChar, StringComparison.Ordinal) 159&& !relative.StartsWith(".." + Path.AltDirectorySeparatorChar, StringComparison.Ordinal)

parent\dotnet\Commands\Workload\Install\WorkloadAdvertisingManifestUpdater.cs (1)

204Path.GetFileName(path).StartsWith(manifestPackageId.ToString(), StringComparison.OrdinalIgnoreCase) &&

parent\dotnet\FirstRunExperience.cs (1)

88switchIndicators.Any(i => t.Value.StartsWith(i + o, StringComparison.OrdinalIgnoreCase))));

parent\dotnet\LoggerUtility.cs (4)

96return arg.StartsWith("/bl:", comp) || arg.Equals("/bl", comp) 97|| arg.StartsWith("--binaryLogger:", comp) || arg.Equals("--binaryLogger", comp) 98|| arg.StartsWith("-bl:", comp) || arg.Equals("-bl", comp); 172if (arg.StartsWith("--", StringComparison.Ordinal))

dotnet-dev-certs (6)

src\aspnetcore\src\Shared\CertificateGeneration\UnixCertificateManager.cs (1)

360var prettyCertDir = certDir.StartsWith(homeDirectoryWithSlash, StringComparison.Ordinal)

src\aspnetcore\src\Shared\CommandLineUtils\CommandLine\CommandLineApplication.cs (2)

158if (arg.StartsWith("--", StringComparison.Ordinal)) 162else if (arg.StartsWith("-", StringComparison.Ordinal))

src\aspnetcore\src\Shared\CommandLineUtils\CommandLine\CommandOption.cs (3)

20if (part.StartsWith("--", StringComparison.Ordinal)) 24else if (part.StartsWith("-", StringComparison.Ordinal)) 38else if (part.StartsWith("<", StringComparison.Ordinal) && part.EndsWith(">", StringComparison.Ordinal))

dotnet-format (1)

Utilities\GeneratedCodeUtilities.cs (1)

42if (fileName.StartsWith("TemporaryGeneratedFile_", StringComparison.OrdinalIgnoreCase))

dotnet-getdocument (5)

src\aspnetcore\src\Shared\CommandLineUtils\CommandLine\CommandLineApplication.cs (2)

158if (arg.StartsWith("--", StringComparison.Ordinal)) 162else if (arg.StartsWith("-", StringComparison.Ordinal))

src\aspnetcore\src\Shared\CommandLineUtils\CommandLine\CommandOption.cs (3)

dotnet-openapi (6)

Commands\BaseCommand.cs (1)

142return Uri.TryCreate(file, UriKind.Absolute, out var _) && file.StartsWith("http", StringComparison.Ordinal);

src\aspnetcore\src\Shared\CommandLineUtils\CommandLine\CommandLineApplication.cs (2)

158if (arg.StartsWith("--", StringComparison.Ordinal)) 162else if (arg.StartsWith("-", StringComparison.Ordinal))

src\aspnetcore\src\Shared\CommandLineUtils\CommandLine\CommandOption.cs (3)

dotnet-sourcelink (1)

src\sourcelink\src\SourceLink.Tools\SourceLinkMap.cs (1)

212if (path.StartsWith(file.Path, StringComparison.OrdinalIgnoreCase))

dotnet-sql-cache (5)

src\aspnetcore\src\Shared\CommandLineUtils\CommandLine\CommandLineApplication.cs (2)

158if (arg.StartsWith("--", StringComparison.Ordinal)) 162else if (arg.StartsWith("-", StringComparison.Ordinal))

src\aspnetcore\src\Shared\CommandLineUtils\CommandLine\CommandOption.cs (3)

dotnet-suggest (2)

FileSuggestionRegistration.cs (1)

55if (line.StartsWith(soughtExecutable.FullName, StringComparison.OrdinalIgnoreCase))

SuggestionDispatcher.cs (1)

192if (fileNameWithoutExtension?.StartsWith("dotnet-", StringComparison.Ordinal) == true)

dotnet-svcutil-lib (56)

CodeDomFixup\CodeDomHelpers.cs (4)

103return (method.Name.StartsWith("Begin", StringComparison.Ordinal) || method.Name.StartsWith("OnBegin", StringComparison.Ordinal)) && 113return (method.Name.StartsWith("End", StringComparison.Ordinal) || method.Name.StartsWith("OnEnd", StringComparison.Ordinal)) &&

CodeDomFixup\CodeDomVisitors\EnsureAdditionalAssemblyReference.cs (1)

28if (!_alreadyAdded.Contains(_namespacesToMatch[ns]) && typeref.BaseType.StartsWith(ns, StringComparison.Ordinal))

CodeDomFixup\StringHelpers.cs (1)

13return s.StartsWith(prefix, StringComparison.Ordinal) ? s.Substring(prefix.Length) : s;

FrameworkFork\Microsoft.Xml\Xml\BinaryXml\XmlBinaryReader.cs (1)

1943if (!prefixStr.StartsWith("xmlns", StringComparison.Ordinal))

FrameworkFork\Microsoft.Xml\Xml\Resolvers\XmlPreloadedResolver.cs (2)

196if (relativeUri != null && relativeUri.StartsWith("-//", StringComparison.CurrentCulture)) 201if ((_preloadedDtds & XmlKnownDtds.Xhtml10) != 0 && relativeUri.StartsWith("-//W3C//", StringComparison.CurrentCulture))

FrameworkFork\Microsoft.Xml\Xml\schema\XdrBuilder.cs (1)

563!uri.StartsWith("x-schema:#", StringComparison.Ordinal);

FrameworkFork\Microsoft.Xml\Xml\schema\XmlSchemaDatatype.cs (2)

346if (uri.Length > 5 && uri.StartsWith("uuid:", StringComparison.Ordinal)) 350else if (uri.Length > 9 && uri.StartsWith("urn:uuid:", StringComparison.Ordinal))

FrameworkFork\Microsoft.Xml\Xml\schema\XmlSchemaException.cs (1)

41Debug.Assert(message == null || !message.StartsWith("Sch_", StringComparison.Ordinal), "Do not pass a resource here!");

FrameworkFork\Microsoft.Xml\Xml\Serialization\Mappings.cs (1)

234if (!Name.StartsWith("xml:", StringComparison.Ordinal))

FrameworkFork\Microsoft.Xml\Xml\Serialization\SourceInfo.cs (2)

143if (Arg.StartsWith("o.@", StringComparison.Ordinal) || MemberInfo != null) 145var = ILG.GetVariable(Arg.StartsWith("o.@", StringComparison.Ordinal) ? "o" : Arg);

FrameworkFork\Microsoft.Xml\Xml\Serialization\XmlSerializationILGen.cs (1)

570if (source.StartsWith("o.@", StringComparison.Ordinal))

FrameworkFork\Microsoft.Xml\Xml\Serialization\XmlSerializationReader.cs (2)

802if (!name.StartsWith("xmlns", StringComparison.Ordinal)) return false; 1520if (!href.StartsWith("#", StringComparison.Ordinal)) throw new InvalidOperationException(string.Format(ResXml.XmlMissingHref, href));

FrameworkFork\Microsoft.Xml\Xml\Serialization\XmlSerializationWriter.cs (3)

547if (name.Length > prefixLength && name.Length <= prefixLength + MaxInt32.Length && name.StartsWith(prefix, StringComparison.Ordinal)) 959if (localName == "xmlns" || localName.StartsWith("xmlns:", StringComparison.Ordinal)) 992if (localName == "xmlns" || localName.StartsWith("xmlns:", StringComparison.Ordinal))

FrameworkFork\Microsoft.Xml\Xml\Serialization\XmlSerializationWriterILGen.cs (2)

1093System.Diagnostics.Debug.Assert(xmlnsSource.StartsWith("o.@", StringComparison.Ordinal)); 2598if (initValue.Arg.StartsWith("o.@", StringComparison.Ordinal))

FrameworkFork\Microsoft.Xml\Xml\XmlException.cs (1)

41Debug.Assert(message == null || !message.StartsWith("Xml_", StringComparison.Ordinal), "Do not pass a resource here!");

FrameworkFork\Microsoft.Xml\Xml\XPath\Internal\BooleanFunctions.cs (1)

84lang.StartsWith(str, StringComparison.OrdinalIgnoreCase) &&

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

1433if (uriString.StartsWith(Globals.DataContractXsdBaseNamespace, StringComparison.Ordinal))

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

1836return uriString.StartsWith(Globals.DataContractXsdBaseNamespace, StringComparison.Ordinal) ? uriString.Substring(Globals.DataContractXsdBaseNamespace.Length) : uriString;

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

816return contentType == supportedContentType || contentType.StartsWith(supportedContentType, StringComparison.OrdinalIgnoreCase);

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

631if (requestProperty.QueryString.StartsWith("?", StringComparison.Ordinal))

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\MessageEncoder.cs (2)

150contentType.StartsWith(supportedContentType, StringComparison.Ordinal) && 155if (contentType.StartsWith(supportedContentType, StringComparison.OrdinalIgnoreCase))

FrameworkFork\System.ServiceModel\System\ServiceModel\Description\ServiceMetadataExtension.cs (2)

177else if (text.StartsWith(_oldValue, StringComparison.Ordinal)) 229text.StartsWith(ServiceMetadataExtension.BaseAddressPattern, StringComparison.Ordinal))

FrameworkFork\System.ServiceModel\System\ServiceModel\Description\ServiceReflector.cs (4)

40return baseUri + (path.StartsWith("/", StringComparison.Ordinal) ? path.Substring(1) : path); 44return baseUri + (path.StartsWith("/", StringComparison.Ordinal) ? path : "/" + path); 824if (!method.Name.StartsWith(BeginMethodNamePrefix, StringComparison.Ordinal) || 884if (!method.Name.StartsWith(EndMethodNamePrefix, StringComparison.Ordinal) ||

FrameworkFork\System.ServiceModel\System\ServiceModel\Description\WsdlImporter.cs (2)

1063string delimiter = ns.StartsWith("urn:", StringComparison.OrdinalIgnoreCase) ? ":" : "/"; 1953return this.XPath.StartsWith(CreateXPathString(item), StringComparison.Ordinal);

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

508string key = mappingKey.StartsWith(":", StringComparison.Ordinal) ? _keyBase + mappingKey : mappingKey;

Metadata\HttpAuthenticationHelper.cs (1)

144if (challenge.StartsWith(realmTokenStart, StringComparison.OrdinalIgnoreCase))

Metadata\MetadataDocumentLoader.cs (3)

265var isUrl = uri.StartsWith(MetadataConstants.Uri.UriSchemeHttp, StringComparison.OrdinalIgnoreCase) || 266uri.StartsWith(MetadataConstants.Uri.UriSchemeNetTcp, StringComparison.OrdinalIgnoreCase) || 267uri.StartsWith(MetadataConstants.Uri.UriSchemeNetPipe, StringComparison.OrdinalIgnoreCase);

Metadata\MetadataFileNameManager.cs (1)

109if (absoluteUriString.StartsWith(DataContractXsdBaseNamespace, StringComparison.Ordinal))

OutputPathHelper.cs (1)

121if (absoluteUriString.StartsWith(DataContractXsdBaseNamespace, StringComparison.Ordinal))

Shared\MSBuildProj.cs (3)

809t.Name.StartsWith(this.TargetFramework, StringComparison.InvariantCultureIgnoreCase) //this.TargetFramework:net7.0-windows, targets:net7.0-windows7.0 810|| this.TargetFramework.StartsWith(t.Name, StringComparison.InvariantCultureIgnoreCase));//this.TargetFramework:net7.0-windows10.0.19041.0, targets:net7.0-windows10.0.19041 1038if (string.IsNullOrEmpty(sdkVersion) || sdkVersion.StartsWith("1", StringComparison.OrdinalIgnoreCase))

Shared\Utilities\LogTag.cs (1)

37if (string.IsNullOrEmpty(tag) || tag.Length != LogTag.s_tagLength || !tag.StartsWith(s_tagStart, StringComparison.Ordinal) || !tag.EndsWith(s_tagEnd, StringComparison.Ordinal))

Shared\Utilities\PathHelper.cs (4)

57var isUrl = input.StartsWith("http", StringComparison.OrdinalIgnoreCase) || 58input.StartsWith("net.tcp", StringComparison.OrdinalIgnoreCase) || 59input.StartsWith("net.pipe", StringComparison.OrdinalIgnoreCase); 184if (childDir.Name.StartsWith(directoryName, RuntimeEnvironmentHelper.FileStringComparison))

ToolConsole.cs (1)

93if (message != null && !message.StartsWith(SR.WarningPrefix, StringComparison.CurrentCulture))

dotnet-svcutil.xmlserializer (1)

Microsoft\Tools\ServiceModel\SvcUtil\OutputModule.cs (1)

172if (absoluteUriString.StartsWith(DataContractXsdBaseNamespace, StringComparison.Ordinal))

dotnet-user-jwts (5)

src\aspnetcore\src\Shared\CommandLineUtils\CommandLine\CommandLineApplication.cs (2)

158if (arg.StartsWith("--", StringComparison.Ordinal)) 162else if (arg.StartsWith("-", StringComparison.Ordinal))

src\aspnetcore\src\Shared\CommandLineUtils\CommandLine\CommandOption.cs (3)

dotnet-user-secrets (5)

src\aspnetcore\src\Shared\CommandLineUtils\CommandLine\CommandLineApplication.cs (2)

158if (arg.StartsWith("--", StringComparison.Ordinal)) 162else if (arg.StartsWith("-", StringComparison.Ordinal))

src\aspnetcore\src\Shared\CommandLineUtils\CommandLine\CommandOption.cs (3)

dotnet-watch (1)

CommandLine\CommandLineOptions.cs (1)

298if (token.StartsWith(name, StringComparison.OrdinalIgnoreCase))

GenerateDocumentationAndConfigFiles (24)

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

745if (filePath.StartsWith(oldPrefix, StringComparison.Ordinal))

src\roslyn\src\Compilers\Core\Portable\SourceGeneration\GeneratedCodeUtilities.cs (1)

66if (fileName.StartsWith("TemporaryGeneratedFile_", StringComparison.OrdinalIgnoreCase))

src\roslyn\src\RoslynAnalyzers\Microsoft.CodeAnalysis.Analyzers\Core\MetaAnalyzers\ReleaseTrackingHelper.cs (7)

60if (string.IsNullOrWhiteSpace(lineText) || lineText.StartsWith(";", StringComparison.Ordinal)) 71if (lineText.StartsWith(ReleasePrefix, StringComparison.OrdinalIgnoreCase)) 96if (lineText.StartsWith(TableTitleNewRules, StringComparison.OrdinalIgnoreCase)) 101else if (lineText.StartsWith(TableTitleRemovedRules, StringComparison.OrdinalIgnoreCase)) 106else if (lineText.StartsWith(TableTitleChangedRules, StringComparison.OrdinalIgnoreCase)) 161if (lineText.StartsWith("## ", StringComparison.OrdinalIgnoreCase)) 165else if (lineText.StartsWith("### ", StringComparison.OrdinalIgnoreCase))

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (2)

372!method.Name.StartsWith("Add", StringComparison.Ordinal)) 531method.Name.StartsWith("IsNull", StringComparison.Ordinal) &&

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Options\AnalyzerOptionsExtensions.cs (1)

403if (!genericInterfaceFullName.StartsWith("T:", StringComparison.Ordinal))

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (4)

192var nameWithPrefix = (string.IsNullOrEmpty(optionalPrefix) || parts.SymbolName.StartsWith(optionalPrefix, StringComparison.Ordinal)) 311names.FirstOrDefault(kvp => symbolDeclarationId.StartsWith(kvp.Key, StringComparison.Ordinal)) is var prefixedFirstMatchOrDefault && 321value.FirstOrDefault(kvp => symbolDeclarationId.StartsWith(kvp.Key, StringComparison.Ordinal)) is var unprefixedFirstMatchOrDefault && 331allKindsValue.FirstOrDefault(kvp => symbol.Name.StartsWith(kvp.Key, StringComparison.Ordinal)) is var partialFirstMatchOrDefault &&

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\AbstractVirtualCharService.cs (1)

145if (startDelimiter.Length > 0 && !tokenText.StartsWith(startDelimiter, StringComparison.Ordinal))

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

97where kvp.Key.Trim().StartsWith("dotnet_naming_rule.", StringComparison.Ordinal)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\Option2.cs (3)

69Debug.Assert(LanguageName is null == (Definition.ConfigName.StartsWith(OptionDefinition.LanguageAgnosticConfigNamePrefix, StringComparison.Ordinal) || 71Debug.Assert(LanguageName is LanguageNames.CSharp == Definition.ConfigName.StartsWith(OptionDefinition.CSharpConfigNamePrefix, StringComparison.Ordinal)); 72Debug.Assert(LanguageName is LanguageNames.VisualBasic == Definition.ConfigName.StartsWith(OptionDefinition.VisualBasicConfigNamePrefix, StringComparison.Ordinal));

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

60Debug.Assert(!Definition.ConfigName.StartsWith(OptionDefinition.CSharpConfigNamePrefix, StringComparison.Ordinal)); 61Debug.Assert(!Definition.ConfigName.StartsWith(OptionDefinition.VisualBasicConfigNamePrefix, StringComparison.Ordinal));

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\PathMetadataUtilities.cs (1)

66if (rootNamespace is not null && @namespace.StartsWith(rootNamespace + ".", StringComparison.OrdinalIgnoreCase))

GetDocument.Insider (5)

src\aspnetcore\src\Shared\CommandLineUtils\CommandLine\CommandLineApplication.cs (2)

158if (arg.StartsWith("--", StringComparison.Ordinal)) 162else if (arg.StartsWith("-", StringComparison.Ordinal))

src\aspnetcore\src\Shared\CommandLineUtils\CommandLine\CommandOption.cs (3)

ilasm (5)

NativeCommandLine.cs (5)

135if (optionName.StartsWith("ARM64", StringComparison.OrdinalIgnoreCase)) 148else if (optionName.StartsWith("ARM", StringComparison.OrdinalIgnoreCase)) 228arg.StartsWith("--", StringComparison.Ordinal) || 268if (trimmedValue.StartsWith("IMP", StringComparison.OrdinalIgnoreCase)) 273if (trimmedValue.StartsWith("OPT", StringComparison.OrdinalIgnoreCase))

ilc (2)

ConfigurablePInvokePolicy.cs (1)

97bool hasLibPrefix = name.StartsWith(LibPrefix, StringComparison.Ordinal);

Program.cs (1)

831if (!id.StartsWith("IL", StringComparison.Ordinal) || !ushort.TryParse(id.AsSpan(2), out ushort code))

ILCompiler.Build.Tasks (1)

ComputeManagedAssembliesToCompileToNative.cs (1)

110bool isFromRuntimePack = taskItem.GetMetadata("NuGetPackageId")?.StartsWith("Microsoft.NETCore.App.Runtime.", StringComparison.OrdinalIgnoreCase) == true;

ILCompiler.Compiler (3)

Compiler\Logging\UnconditionalSuppressMessageAttributeState.cs (1)

189!warningId.StartsWith("IL", StringComparison.Ordinal) ||

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

273return assemblyName.StartsWith("System.Private.", StringComparison.Ordinal);

parent\parent\Common\Microsoft\SourceLink\Tools\SourceLinkMap.cs (1)

179if (path.StartsWith(file.Path, StringComparison.OrdinalIgnoreCase))

ILCompiler.ReadyToRun (3)

Compiler\ReadyToRunCodegenCompilation.cs (1)

469if (relativeMsilPath == inputFile || relativeMsilPath.StartsWith(s_folderUpPrefix, StringComparison.Ordinal))

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

273return assemblyName.StartsWith("System.Private.", StringComparison.Ordinal);

PortableCallHelpers\PInvokeCollector.cs (1)

282if (platformName?.StartsWith(targetOS, StringComparison.OrdinalIgnoreCase) != true)

ILCompiler.TypeSystem (2)

parent\parent\Common\TypeSystem\Common\Utilities\DebugNameFormatter.cs (1)

205if (assemblyName.StartsWith("System.Private", StringComparison.Ordinal))

parent\parent\Common\TypeSystem\IL\UnsafeAccessors.cs (1)

639bool isMethodParameter = name.StartsWith("!!", StringComparison.Ordinal);

illink (4)

Linker.Steps\DiscoverSerializationHandler.cs (1)

136if (attributeName.StartsWith("Xml", StringComparison.Ordinal)

Linker.Steps\RemoveResourcesStep.cs (2)

37=> resource.Name.StartsWith("FSharpSignatureData", StringComparison.Ordinal) 38|| resource.Name.StartsWith("FSharpOptimizationData", StringComparison.Ordinal);

Linker\Driver.cs (1)

1027if (!id.StartsWith("IL", StringComparison.Ordinal) || !ushort.TryParse(id.AsSpan(2), out ushort code))

Infrastructure.Tests (27)

Pipelines\ExtensionE2eRecorderStepTests.cs (3)

78var installAttempts = invocations.Count(line => line.StartsWith("apt-get install", StringComparison.Ordinal)); 89.Where(line => line.StartsWith("::warning::", StringComparison.Ordinal)) 97.Where(line => line.StartsWith("timeout ", StringComparison.Ordinal))

Pipelines\ReleasePublishNugetPipelineTests.cs (2)

766if (indent == markerIndent && line.StartsWith("- ", StringComparison.Ordinal)) 771if (indent > markerIndent && line.StartsWith(valueKey, StringComparison.Ordinal))

PowerShellScripts\AspireSkillsBundleHashTests.cs (1)

134.FirstOrDefault(static l => l.StartsWith("NAMES=", StringComparison.Ordinal));

PowerShellScripts\DownloadNativeArchivesTests.cs (1)

593if (path.StartsWith("/_artifact/", StringComparison.Ordinal))

TestTriggerMap\SelectTestsAcceptanceTests.cs (1)

1064|| name.StartsWith("Aspire.Hosting.CodeGeneration.", StringComparison.Ordinal);

TestTriggerMap\TestTriggerMapTests.cs (15)

WorkflowScripts\ExtensionReleaseWorkflowTests.cs (3)

467.Where(line => line.StartsWith("- ", StringComparison.Ordinal)) 518.Where(line => line.StartsWith("- ", StringComparison.Ordinal)) 538.Where(line => line.StartsWith("- ", StringComparison.Ordinal))

WorkflowScripts\ExtensionWorkflowTests.cs (1)

179steps.Where(step => Scalar(step, "name") is "Checkout code" or "Create test results directory" || Scalar(step, "uses")?.StartsWith("actions/download-artifact@", StringComparison.Ordinal) == true),

Microsoft.Analyzers.Local (2)

ApiLifecycle\AssemblyAnalysis.cs (2)

280if (typeSignature.StartsWith("class", StringComparison.Ordinal) 281|| typeSignature.StartsWith("record", StringComparison.Ordinal))

Microsoft.AspNetCore.Analyzers (2)

StartupFacts.cs (2)

66!symbol.Name.StartsWith(SymbolNames.ConfigureServicesMethodPrefix, StringComparison.OrdinalIgnoreCase) || 104!symbol.Name.StartsWith(SymbolNames.ConfigureMethodPrefix, StringComparison.OrdinalIgnoreCase))

Microsoft.AspNetCore.Antiforgery (3)

Internal\DefaultAntiforgeryTokenGenerator.cs (2)

163if (currentUsername.StartsWith("http://", StringComparison.OrdinalIgnoreCase) || 164currentUsername.StartsWith("https://", StringComparison.OrdinalIgnoreCase))

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

33contentType.StartsWith(MultipartFormContentType, StringComparison.OrdinalIgnoreCase);

Microsoft.AspNetCore.App.Analyzers (6)

Infrastructure\VirtualChars\AbstractVirtualCharService.cs (1)

142if (startDelimiter.Length > 0 && !tokenText.StartsWith(startDelimiter, StringComparison.Ordinal))

Infrastructure\VirtualChars\CSharpVirtualCharService.cs (1)

248if (startDelimiter.Length > 0 && !tokenText.StartsWith(startDelimiter, StringComparison.Ordinal))

RouteEmbeddedLanguage\Infrastructure\RouteUsageDetector.cs (1)

262if (!method.Name.StartsWith("Map", StringComparison.Ordinal))

RouteHandlers\RouteHandlerAnalyzer.cs (1)

200return targetMethod.Name.StartsWith("Map", StringComparison.Ordinal) &&

src\aspnetcore\src\Shared\RoslynUtils\WellKnownTypes.cs (2)

136if (type.ContainingAssembly.Identity.Name.StartsWith("System.", StringComparison.Ordinal) 137|| type.ContainingAssembly.Identity.Name.StartsWith("Microsoft.", StringComparison.Ordinal))

Microsoft.AspNetCore.Authentication.BearerToken (1)

BearerTokenHandler.cs (1)

98return authorization.StartsWith("Bearer ", StringComparison.Ordinal)

Microsoft.AspNetCore.Authentication.Cookies (2)

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

73if (value != null && value.StartsWith(ChunkCountPrefix, StringComparison.Ordinal)) 260Func<string, bool> predicate = value => keys.Any(k => value.StartsWith(k, StringComparison.OrdinalIgnoreCase));

Microsoft.AspNetCore.Authentication.DeviceBoundSessions (2)

DeviceBoundSessionHandler.cs (1)

346if (!value.StartsWith("=; ", StringComparison.Ordinal))

DeviceBoundSessionOptions.cs (1)

120if (value.StartsWith("//", StringComparison.Ordinal))

Microsoft.AspNetCore.Authentication.JwtBearer (2)

JwtBearerHandler.cs (1)

84if (authorization.StartsWith("Bearer ", StringComparison.OrdinalIgnoreCase))

JwtBearerPostConfigureOptions.cs (1)

47if (options.RequireHttpsMetadata && !options.MetadataAddress.StartsWith("https://", StringComparison.OrdinalIgnoreCase))

Microsoft.AspNetCore.Authentication.Negotiate (1)

NegotiateHandler.cs (1)

112if (authorization.StartsWith(AuthHeaderPrefix, StringComparison.OrdinalIgnoreCase))

Microsoft.AspNetCore.Authentication.OpenIdConnect (4)

OpenIdConnectHandler.cs (3)

129&& Request.ContentType.StartsWith("application/x-www-form-urlencoded", StringComparison.OrdinalIgnoreCase) 668&& Request.ContentType.StartsWith("application/x-www-form-urlencoded", StringComparison.OrdinalIgnoreCase) 1193if (Options.NonceCookie.Name is string name && nonceKey.StartsWith(name, StringComparison.Ordinal))

OpenIdConnectPostConfigureOptions.cs (1)

95if (options.RequireHttpsMetadata && !(options.MetadataAddress?.StartsWith("https://", StringComparison.OrdinalIgnoreCase) ?? false))

Microsoft.AspNetCore.Authentication.WsFederation (2)

WsFederationHandler.cs (1)

157&& Request.ContentType.StartsWith("application/x-www-form-urlencoded", StringComparison.OrdinalIgnoreCase)

WsFederationPostConfigureOptions.cs (1)

79if (options.RequireHttpsMetadata && !options.MetadataAddress.StartsWith("https://", StringComparison.OrdinalIgnoreCase))

Microsoft.AspNetCore.Components (5)

NavigationManager.cs (2)

326if (uri.StartsWith(_baseUri!.OriginalString, StringComparison.Ordinal)) 617if (uri.StartsWith(baseUri.OriginalString, StringComparison.Ordinal))

RenderTree\RenderTreeDiffBuilder.cs (1)

1019newFrame.AttributeNameField.StartsWith("on", StringComparison.Ordinal))

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

31if (parameter.StartsWith("**", StringComparison.Ordinal))

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

459if (routePattern.StartsWith("~/", StringComparison.Ordinal))

Microsoft.AspNetCore.Components.Analyzers (2)

ForLoopIteratorInClosureAnalyzer.cs (1)

199&& conversionOperation.Operand.Type.ContainingNamespace.ToString().StartsWith(ComponentsApi.AssemblyName, StringComparison.Ordinal))

VirtualizeSpacerElementAnalyzer.cs (1)

238!method.Name.StartsWith("CreateVirtualize_", StringComparison.Ordinal) ||

Microsoft.AspNetCore.Components.Endpoints (2)

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

Microsoft.AspNetCore.Components.Testing.Tasks (1)

GenerateE2EManifest.cs (1)

133? (runtimeIdentifier.StartsWith("win-", StringComparison.OrdinalIgnoreCase) ? ".exe" : "")

Microsoft.AspNetCore.Components.Web (2)

Forms\Mapping\FormMappingContext.cs (1)

137if (!errorKey.StartsWith(key, StringComparison.Ordinal))

Routing\NavLink.cs (1)

257return value.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)

Microsoft.AspNetCore.Components.WebAssembly.Server (6)

DebugProxyLauncher.cs (2)

111var keysToRemove = environment.Keys.Where(key => key.StartsWith("ASPNETCORE_", StringComparison.Ordinal)).ToList(); 154if (eventArgs.Data.StartsWith(prefix, StringComparison.Ordinal))

TargetPickerUi.cs (4)

172if (hasUrl && urlInTab.GetString()?.StartsWith("about:debugging#", StringComparison.InvariantCultureIgnoreCase) == true) 191else if (hasUrl && urlInTab.GetString()?.StartsWith("about:devtools", StringComparison.InvariantCultureIgnoreCase) == true) 211if (hasInput && input.GetString()?.StartsWith("AboutDebugging.actions.addNetworkLocation(", StringComparison.InvariantCultureIgnoreCase) == true) 215if (hasInput && input.GetString()?.StartsWith("if (AboutDebugging.store.getState()", StringComparison.InvariantCultureIgnoreCase) == true)

Microsoft.AspNetCore.Components.WebView (1)

IpcCommon.cs (1)

41if (message != null && message.StartsWith(_ipcMessagePrefix, StringComparison.Ordinal))

Microsoft.AspNetCore.Components.WebView.Maui (2)

src\BlazorWebView\src\SharedSource\StaticContentHotReloadManager.cs (2)

102 if (relativePath.StartsWith($"{assemblyName}.", StringComparison.Ordinal) && relativePath.EndsWith(".bundle.scp.css", StringComparison.Ordinal)) 112 else if (requestPath.StartsWith("_framework/", StringComparison.Ordinal))

Microsoft.AspNetCore.Components.WebView.WindowsForms (2)

src\BlazorWebView\src\SharedSource\StaticContentHotReloadManager.cs (2)

Microsoft.AspNetCore.Components.WebView.Wpf (2)

src\BlazorWebView\src\SharedSource\StaticContentHotReloadManager.cs (2)

Microsoft.AspNetCore.DataProtection (2)

TypeExtensions.cs (1)

48if (matchType.FullName != null && resolvedTypeName.StartsWith(matchType.FullName, StringComparison.Ordinal))

TypeForwardingActivator.cs (1)

68if (candidate || forwardedTypeName.StartsWith(CurrentNamespace + ".", StringComparison.Ordinal))

Microsoft.AspNetCore.DeveloperCertificates.XPlat (1)

src\aspnetcore\src\Shared\CertificateGeneration\UnixCertificateManager.cs (1)

360var prettyCertDir = certDir.StartsWith(homeDirectoryWithSlash, StringComparison.Ordinal)

Microsoft.AspNetCore.Diagnostics (1)

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

33contentType.StartsWith(MultipartFormContentType, StringComparison.OrdinalIgnoreCase);

Microsoft.AspNetCore.Diagnostics.Middleware (1)

Logging\HttpLoggingRedactionInterceptor.cs (1)

197if (path.StartsWith(excludedPath, StringComparison.OrdinalIgnoreCase))

Microsoft.AspNetCore.Grpc.JsonTranscoding (2)

Internal\JsonRequestHelpers.cs (1)

485variable.StartsWith(bodyFieldName, StringComparison.Ordinal) &&

Internal\JsonTranscodingRouteAdapter.cs (1)

223if (segment.StartsWith("**", StringComparison.Ordinal))

Microsoft.AspNetCore.Hosting (1)

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

33contentType.StartsWith(MultipartFormContentType, StringComparison.OrdinalIgnoreCase);

Microsoft.AspNetCore.Http (6)

BindingAddress.cs (2)

59public bool IsUnixPipe => Host.StartsWith(UnixPipeHostPrefix, StringComparison.Ordinal); 67public bool IsNamedPipe => Host.StartsWith(NamedPipeHostPrefix, StringComparison.Ordinal);

Internal\ResponseCookies.cs (4)

124value.StartsWith(encKeyPlusEquals, StringComparison.OrdinalIgnoreCase) && 131value.StartsWith(encKeyPlusEquals, StringComparison.OrdinalIgnoreCase) && 137value.StartsWith(encKeyPlusEquals, StringComparison.OrdinalIgnoreCase) && 142rejectPredicate = (value, encKeyPlusEquals, opts) => value.StartsWith(encKeyPlusEquals, StringComparison.OrdinalIgnoreCase);

Microsoft.AspNetCore.Http.Abstractions (3)

PathString.cs (3)

252if (value1.StartsWith(value2, comparisonType)) 303if (value1.StartsWith(value2, comparisonType)) 361if (value1.StartsWith(value2, comparisonType))

Microsoft.AspNetCore.Http.RequestDelegateGenerator (2)

src\aspnetcore\src\Shared\RoslynUtils\WellKnownTypes.cs (2)

136if (type.ContainingAssembly.Identity.Name.StartsWith("System.", StringComparison.Ordinal) 137|| type.ContainingAssembly.Identity.Name.StartsWith("Microsoft.", StringComparison.Ordinal))

Microsoft.AspNetCore.Identity.UI (1)

IdentityBuilderUIExtensions.cs (1)

156private static bool IsIdentityUIView(CompiledViewDescriptor desc) => desc.RelativePath.StartsWith("/Areas/Identity", StringComparison.OrdinalIgnoreCase) &&

Microsoft.AspNetCore.InternalTesting (8)

AssemblyTestLog.cs (1)

112if (className.StartsWith(assemblyName + ".", StringComparison.Ordinal))

TestFileOutputContext.cs (2)

59if (extension != null && !extension.StartsWith(".", StringComparison.Ordinal)) 109if (name.StartsWith(assemblyName + ".", StringComparison.Ordinal))

xunit\SkipOnAlpineAttribute.cs (1)

32line.StartsWith("ID=", StringComparison.Ordinal) && line.Substring(3).Trim('"', '\'') == "alpine");

xunit\SkipOnHelixAttribute.cs (4)

54if (Queues.Contains("All.OSX") && targetQueue.StartsWith("osx", StringComparison.OrdinalIgnoreCase)) 59if (Queues.Contains("All.Ubuntu") && targetQueue.StartsWith("ubuntu", StringComparison.OrdinalIgnoreCase)) 72.Any(q => q.Equals(targetQueue, StringComparison.Ordinal) || q.StartsWith(targetQueue, StringComparison.Ordinal) || 73targetQueue.StartsWith(q, StringComparison.Ordinal));

Microsoft.AspNetCore.JsonPatch (1)

Internal\PathHelpers.cs (1)

14if (path.Length > 0 && !path.StartsWith("/", StringComparison.Ordinal))

Microsoft.AspNetCore.Mvc.Abstractions (1)

ModelBinding\ModelStateDictionary.cs (1)

781if (!key.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))

Microsoft.AspNetCore.Mvc.Analyzers (1)

TopLevelParameterNameAnalyzer.cs (1)

144!@namespace.StartsWith("System.", StringComparison.Ordinal);

Microsoft.AspNetCore.Mvc.ApiExplorer (2)

EndpointMetadataApiDescriptionProvider.cs (2)

478return returnType.FullName.StartsWith("System.Threading.Tasks.Task`1[", StringComparison.Ordinal) || 479returnType.FullName.StartsWith("System.Threading.Tasks.ValueTask`1[", StringComparison.Ordinal);

Microsoft.AspNetCore.Mvc.Core (10)

ApiExplorer\ApiConventionMatcher.cs (1)

118if (!name.StartsWith(conventionName, StringComparison.Ordinal))

ApplicationModels\AttributeRouteModel.cs (2)

156(template.StartsWith("~/", StringComparison.Ordinal) || 226else if (result.StartsWith("~/", StringComparison.Ordinal))

ModelBinding\Binders\FormFileModelBinder.cs (2)

72!modelName.StartsWith(bindingContext.OriginalModelName + "[", StringComparison.Ordinal) && 73!modelName.StartsWith(bindingContext.OriginalModelName + ".", StringComparison.Ordinal))

ModelBinding\PrefixContainer.cs (3)

93else if (entry.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)) 202Debug.Assert(candidate.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)); 259Debug.Assert(candidate.StartsWith(prefix, StringComparison.OrdinalIgnoreCase));

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

Microsoft.AspNetCore.Mvc.Razor (2)

Compilation\DefaultRazorPageFactoryProvider.cs (1)

32if (relativePath.StartsWith("~/", StringComparison.Ordinal))

Infrastructure\DefaultFileVersionProvider.cs (1)

65resolvedPath.StartsWith(requestPathBase.Value, StringComparison.OrdinalIgnoreCase))

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

FileProviderRazorProjectItem.cs (1)

81PhysicalPath.StartsWith(_root, StringComparison.OrdinalIgnoreCase) &&

parent\parent\Mvc.RazorPages\src\ApplicationModels\PageRouteModelFactory.cs (2)

94!relativePath.StartsWith(_normalizedAreaRootDirectory, StringComparison.OrdinalIgnoreCase)) // The path must start with area root. 129Debug.Assert(path.StartsWith(rootDirectory, StringComparison.OrdinalIgnoreCase));

Microsoft.AspNetCore.Mvc.RazorPages (6)

ApplicationModels\CompiledPageRouteModelProvider.cs (2)

104if (relativePath.StartsWith(areaRootDirectory, StringComparison.OrdinalIgnoreCase)) 108else if (relativePath.StartsWith(rootDirectory, StringComparison.OrdinalIgnoreCase))

ApplicationModels\DefaultPageApplicationModelPartsProvider.cs (1)

217if (!methodName.StartsWith("On", StringComparison.Ordinal) || methodName.Length <= "On".Length)

ApplicationModels\PageConventionCollection.cs (1)

399viewEnginePath.StartsWith(folderPath, StringComparison.OrdinalIgnoreCase) &&

ApplicationModels\PageRouteModelFactory.cs (2)

Microsoft.AspNetCore.Mvc.TagHelpers (1)

ResourceCollectionUtilities.cs (1)

32if (pathBase.HasValue && url.StartsWith(pathBase, StringComparison.OrdinalIgnoreCase))

Microsoft.AspNetCore.OpenApi (4)

Extensions\JsonTypeInfoExtensions.cs (1)

103if (type.Name.StartsWith("<>f", StringComparison.Ordinal))

Services\Schemas\OpenApiSchemaService.cs (3)

463if (referenceId.StartsWith(componentsSchemasReferencePrefix, StringComparison.Ordinal)) 594refString.StartsWith(OpenApiConstants.RefPrefix, StringComparison.Ordinal)) 664if (!refPath.StartsWith(OpenApiConstants.RefPrefix, StringComparison.Ordinal))

Microsoft.AspNetCore.OpenApi.SourceGenerators (4)

XmlComments\XmlComment.cs (2)

29if (xml.StartsWith("<doc>", StringComparison.InvariantCulture) && xml.EndsWith("</doc>", StringComparison.InvariantCulture)) 163xmlText.StartsWith("<!-- Badly formed XML comment ignored for member ", StringComparison.Ordinal))

XmlComments\XmlComment.InheritDoc.cs (2)

206if (xpathValue.StartsWith("/", StringComparison.InvariantCulture)) 245if (docId != null && !docId.StartsWith("!", StringComparison.OrdinalIgnoreCase))

Microsoft.AspNetCore.Rewrite (2)

RedirectToNonWwwRule.cs (1)

46if (!request.Host.HasValue || !request.Host.Value.StartsWith(WwwDot, StringComparison.OrdinalIgnoreCase))

RedirectToWwwRule.cs (1)

46if (req.Host.HasValue && req.Host.Value.StartsWith(WwwDot, StringComparison.OrdinalIgnoreCase))

Microsoft.AspNetCore.Routing (4)

Matching\HostMatcherPolicy.cs (1)

421HasHostWildcard = Host.StartsWith(WildcardPrefix, StringComparison.Ordinal);

Patterns\RouteParameterParser.cs (1)

31if (parameter.StartsWith("**", StringComparison.Ordinal))

Patterns\RoutePatternParser.cs (1)

459if (routePattern.StartsWith("~/", StringComparison.Ordinal))

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

33contentType.StartsWith(MultipartFormContentType, StringComparison.OrdinalIgnoreCase);

Microsoft.AspNetCore.Server.HttpSys (2)

RequestProcessing\Request.cs (2)

98else if (originalPath.StartsWith(prefix.Path, StringComparison.Ordinal)) 104else if (originalPath.StartsWith(prefix.Path, StringComparison.OrdinalIgnoreCase))

Microsoft.AspNetCore.Server.IIS (2)

Core\IISHttpContext.cs (2)

201&& originalPath.StartsWith(pathBase, StringComparison.Ordinal)) 209&& originalPath.StartsWith(pathBase, StringComparison.OrdinalIgnoreCase))

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

Internal\SniOptionsSelector.cs (1)

104else if (name.StartsWith(WildcardPrefix, StringComparison.Ordinal))

src\aspnetcore\src\Shared\CertificateGeneration\UnixCertificateManager.cs (1)

360var prettyCertDir = certDir.StartsWith(homeDirectoryWithSlash, StringComparison.Ordinal)

Microsoft.AspNetCore.SignalR.Client.SourceGenerator (1)

HubServerProxyGenerator.SourceGenerationSpec.cs (1)

42.StartsWith("System.Threading.Tasks.ValueTask", StringComparison.Ordinal);

Microsoft.Build (35)

BackEnd\Components\Logging\ProjectTelemetry.cs (2)

103(baseTypeName.StartsWith("Microsoft.Build.Tasks.", StringComparison.Ordinal) || 104baseTypeName.StartsWith("Microsoft.Build.Utilities.", StringComparison.Ordinal)))

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

74return typeName!.StartsWith("Microsoft.Build", StringComparison.Ordinal) || 75typeName.StartsWith("Microsoft.NET.Build", StringComparison.Ordinal) || 76typeName.StartsWith("Microsoft.NET.Sdk", StringComparison.Ordinal);

BuildCheck\Checks\UntrustedLocationCheck.cs (1)

48context.Data.ProjectFileDirectory.StartsWith(PathsHelper.Downloads, FileUtilities.PathComparison))

BuildCheck\Infrastructure\ConfigurationProvider.cs (1)

168if (kv.Key.StartsWith(keyFilter, StringComparison.OrdinalIgnoreCase))

Construction\Solution\ProjectInSolution.cs (1)

581a.Name.StartsWith("xmlns:dd", StringComparison.OrdinalIgnoreCase));

Construction\Solution\SolutionFile.cs (13)

ElementLocation\XmlDocumentWithLocation.cs (4)

358if (Path.GetFileName(fullPath).StartsWith("Microsoft.", StringComparison.OrdinalIgnoreCase)) 366if ((!String.IsNullOrEmpty(windowsFolder) && directory.StartsWith(windowsFolder, StringComparison.OrdinalIgnoreCase)) || 367(!String.IsNullOrEmpty(FrameworkLocationHelper.programFiles32) && directory.StartsWith(FrameworkLocationHelper.programFiles32, StringComparison.OrdinalIgnoreCase)) || 368(!String.IsNullOrEmpty(FrameworkLocationHelper.programFiles64) && directory.StartsWith(FrameworkLocationHelper.programFiles64, StringComparison.OrdinalIgnoreCase)))

Evaluation\Expander.PropertyExpander.cs (2)

718if (!NativeMethodsShared.IsWindows && !registryKeyName.StartsWith("HKEY_CURRENT_USER", StringComparison.OrdinalIgnoreCase)) 723if (registryKeyName.StartsWith(

Evaluation\Expander\WellKnownFunctions.cs (1)

172returnVal = text.StartsWith(arg0, StringComparison.CurrentCulture);

Evaluation\IntrinsicFunctions.cs (1)

287if (!NativeMethodsShared.IsWindows && !keyName.StartsWith("HKEY_CURRENT_USER", StringComparison.OrdinalIgnoreCase))

Graph\ProjectGraph.cs (1)

700else if (targetName.StartsWith($"{baseProjectName}:", StringComparison.OrdinalIgnoreCase))

Instance\TaskRegistry.cs (1)

1745if (expandedType.StartsWith("Microsoft.Build.Framework.", StringComparison.OrdinalIgnoreCase) && !expandedType.Contains(","))

Logging\BinaryLogger\BinaryLogger.cs (2)

272bool hasPathPrefix = parameter.StartsWith(LogFileParameterPrefix, StringComparison.OrdinalIgnoreCase); 781bool hasPathPrefix = parameter.StartsWith(LogFileParameterPrefix, StringComparison.OrdinalIgnoreCase);

parent\Shared\TypeLoader.cs (1)

669_runtime = targetFramework.StartsWith(DotNetCoreIdentifier, StringComparison.Ordinal) ? MSBuildRuntimeValues.net : MSBuildRuntimeValues.clr4;

Utilities\FileSpecMatchTester.cs (1)

96return normalizedFileToMatch.StartsWith(_currentDirectory, StringComparison.OrdinalIgnoreCase);

Microsoft.Build.Framework (28)

EnvironmentUtilities.cs (3)

110=> propertyName.StartsWith("MSBUILD", StringComparison.OrdinalIgnoreCase) || 111propertyName.StartsWith("COMPLUS_", StringComparison.OrdinalIgnoreCase) || 112propertyName.StartsWith("DOTNET_", StringComparison.OrdinalIgnoreCase);

FileClassifier.cs (2)

219=> assemblyName.StartsWith("Microsoft.", StringComparison.OrdinalIgnoreCase); 410if (filePath.StartsWith(locations[i], PathComparison))

FileUtilities.cs (3)

732|| value.StartsWith("$(", comparisonType) || value.StartsWith("@(", comparisonType) 733|| value.StartsWith("\\\\", comparisonType))

Sdk\SdkReference.cs (1)

107sdkReference = parts[1].StartsWith("min=", StringComparison.OrdinalIgnoreCase)

Telemetry\CrashTelemetry.cs (2)

783|| (originNamespace.StartsWith(prefix, StringComparison.OrdinalIgnoreCase) 844if (message!.StartsWith(internalErrorPrefix, StringComparison.Ordinal))

Traits.cs (4)

556if (mode.StartsWith("no", comparison)) 561if (mode.StartsWith("default", comparison)) 566if (mode.StartsWith(nameof(SdkReferencePropertyExpansionMode.ExpandUnescape), comparison)) 571if (mode.StartsWith(nameof(SdkReferencePropertyExpansionMode.ExpandLeaveEscaped), comparison))

Utilities\FileMatcher.cs (12)

Utilities\FrameworkLocationHelper.cs (1)

852if (leaf.StartsWith(prefix, StringComparison.Ordinal) && architecture == DotNetFrameworkArchitecture.Current)

Microsoft.Build.Tasks.CodeAnalysis (7)

src\roslyn\src\Compilers\Core\MSBuildTask\ManagedCompiler.cs (1)

644if (var.StartsWith("LIB=", StringComparison.OrdinalIgnoreCase))

src\roslyn\src\Compilers\Core\MSBuildTask\ManagedToolTask.cs (2)

334.. EnvironmentVariables?.Where(static e => !e.StartsWith(RuntimeHostInfo.DotNetRootEnvironmentName, Environment.EnvironmentVariableComparison)) ?? [], 336.Where(e => e.Key.StartsWith(RuntimeHostInfo.DotNetRootEnvironmentName, Environment.EnvironmentVariableComparison))

src\roslyn\src\Compilers\Core\MSBuildTask\MapSourceRoots.cs (1)

194if (fullOriginalPath.StartsWith(containingRoot, StringComparison.OrdinalIgnoreCase))

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

536if (dotNetRoot != null && key.StartsWith(RuntimeHostInfo.DotNetRootEnvironmentName, Environment.EnvironmentVariableComparison))

src\roslyn\src\Compilers\Shared\NativeMethods.cs (2)

150if (s.StartsWith(@"\\?\UNC\", StringComparison.Ordinal)) 152if (s.StartsWith(@"\\?\", StringComparison.Ordinal))

Microsoft.Build.Tasks.Core (26)

AssemblyDependency\AssemblyFoldersFromConfig\AssemblyFoldersFromConfigResolver.cs (1)

111if (!_targetRuntimeVersion.StartsWith("v", StringComparison.OrdinalIgnoreCase))

AssignLinkMetadata.cs (1)

54&& fullPath.StartsWith(definingProjectDirectory, StringComparison.OrdinalIgnoreCase))

AssignTargetPath.cs (1)

134if (itemSpecFullFileNamePath.Value.StartsWith(fullRootPath.Value, FileUtilities.PathComparison))

BootstrapperUtil\BootstrapperBuilder.cs (1)

463if (folder.Length >= packagePath.Length && folder.StartsWith(packagePath, StringComparison.OrdinalIgnoreCase))

BootstrapperUtil\Util.cs (2)

64return path.StartsWith("http://", StringComparison.Ordinal) || path.StartsWith("https://", StringComparison.Ordinal);

GenerateManifestBase.cs (1)

564file.TargetPath = Path.IsPathRooted(file.SourcePath) || file.SourcePath.StartsWith("..", StringComparison.Ordinal) ? Path.GetFileName(file.SourcePath) : file.SourcePath;

GetSDKReferenceFiles.cs (1)

622if (FileUtilities.EnsureTrailingSlash(directoryToFileList.Key).StartsWith(FileUtilities.EnsureTrailingSlash(redistFilePath), StringComparison.OrdinalIgnoreCase))

ManifestUtil\mansign2.cs (1)

490if (!oldCsp.CspKeyContainerInfo.ProviderName.StartsWith("Microsoft", StringComparison.Ordinal))

ManifestUtil\Util.cs (2)

379if (value.StartsWith("v", StringComparison.OrdinalIgnoreCase)) 623if (version.StartsWith("v", StringComparison.OrdinalIgnoreCase))

ManifestUtil\XmlUtil.cs (1)

155if (!uri.LocalPath.StartsWith(Path.GetTempPath(), StringComparison.Ordinal))

parent\Shared\LanguageParser\CSharptokenEnumerator.cs (1)

204if (identifier.StartsWith("@", StringComparison.Ordinal))

RedistList.cs (2)

160return entry.RedistName.StartsWith("Microsoft-Windows-CLRCoreComp", StringComparison.OrdinalIgnoreCase); 450if (!entry.RedistName.StartsWith("Microsoft-Windows-CLRCoreComp", StringComparison.OrdinalIgnoreCase))

RequiresFramework35SP1Assembly.cs (1)

81if (version.StartsWith("v", StringComparison.OrdinalIgnoreCase))

ResolveManifestFiles.cs (1)

229if (version.StartsWith("v", StringComparison.OrdinalIgnoreCase))

ResourceHandling\MSBuildResXReader.cs (5)

162if (typename.StartsWith("System.Resources.ResXFileRef", StringComparison.Ordinal)) // TODO: is this too general? Should it be OrdinalIgnoreCase? 168if (typename.StartsWith("System.Resources.ResXNullRef", StringComparison.Ordinal)) 304return fileRefType.StartsWith(StringTypeNamePrefix, StringComparison.Ordinal); 309return fileRefType.StartsWith(MemoryStreamTypeNamePrefix, StringComparison.Ordinal); 340if (stringValue.StartsWith("\"", StringComparison.Ordinal))

Untar.cs (1)

288if (!fullDestinationPath.Value.StartsWith(fullDestinationDirectoryPath, FileUtilities.PathComparison))

Unzip.cs (2)

190ErrorUtilities.VerifyThrowInvalidOperation(fullDestinationPath.Value.StartsWith(fullDestinationDirectoryPath, FileUtilities.PathComparison), "Unzip.ZipSlipExploit", fullDestinationPath); 203if (!destinationPath.FullName.StartsWith(destinationDirectory.FullName, StringComparison.OrdinalIgnoreCase))

WriteCodeFragment.cs (1)

228if (name.StartsWith("_Parameter", StringComparison.OrdinalIgnoreCase))

Microsoft.Build.Tasks.Git (11)

GitDataReader\GitConfig.Reader.cs (2)

316if (key.SubsectionName.StartsWith(caseSensitiveGitDirPrefix, StringComparison.Ordinal)) 321else if (key.SubsectionName.StartsWith(caseInsensitiveGitDirPrefix, StringComparison.Ordinal))

GitDataReader\GitIgnore.Matcher.cs (3)

119if (!normalizedPosixPath.StartsWith(Ignore.WorkingDirectory, Ignore.PathComparison)) 141if (directory == null || !directory.StartsWith(Ignore.WorkingDirectory, Ignore.PathComparison)) 203if (!normalizedPosixPath.StartsWith(patternGroup.ContainingDirectory, Ignore.PathComparison))

GitDataReader\GitReferenceResolver.cs (2)

166if (!reference.StartsWith(RefsPrefix, StringComparison.Ordinal)) 250if (reference.StartsWith(refPrefix + RefsPrefix, StringComparison.Ordinal))

GitOperations.cs (1)

129if (prefix.Length > longestPrefixLength && url.StartsWith(prefix, StringComparison.Ordinal))

parent\Common\Utilities\PathUtilities.cs (2)

25if (fullPath.StartsWith(UncPrefix, StringComparison.Ordinal)) 32else if (fullPath.StartsWith(UnixRoot, StringComparison.Ordinal))

parent\Common\Utilities\UriUtilities.cs (1)

38return url.StartsWith(prefix, StringComparison.Ordinal);

Microsoft.Build.Utilities.Core (4)

ExtensionSDK.cs (1)

159if (words[0].Trim().StartsWith("Version", StringComparison.OrdinalIgnoreCase))

SDKManifest.cs (2)

375if (attribute.Name.StartsWith(Attributes.FrameworkIdentity, StringComparison.OrdinalIgnoreCase)) 386if (attribute.Name.StartsWith(Attributes.APPX, StringComparison.OrdinalIgnoreCase))

ToolLocationHelper.cs (1)

3849if (folder.Name.Length >= 4 && folder.Name.StartsWith("v", StringComparison.OrdinalIgnoreCase))

Microsoft.CodeAnalysis (20)

CommandLine\AnalyzerConfigSet.cs (1)

404if (key.StartsWith(diagnosticOptionPrefix, StringComparison.Ordinal) &&

CommandLine\CommandLineParser.cs (6)

556if (!optionsEnded && arg.StartsWith("@", StringComparison.Ordinal)) 792if (!arg.StartsWith(optionName, StringComparison.OrdinalIgnoreCase)) 1336if (value.StartsWith("0x", StringComparison.OrdinalIgnoreCase)) 1340else if (value.StartsWith("0", StringComparison.OrdinalIgnoreCase)) 1374if (value.StartsWith("0x", StringComparison.OrdinalIgnoreCase)) 1378else if (value.StartsWith("0", StringComparison.OrdinalIgnoreCase))

CommandLine\CommonCompiler.cs (1)

1754return diagnosticId.StartsWith(expectedPrefix, StringComparison.Ordinal) && uint.TryParse(diagnosticId.Substring(expectedPrefix.Length), out code);

DiagnosticAnalyzer\AnalyzerFileReference.cs (1)

616if (targetFrameworkAttribute is object && targetFrameworkAttribute.FrameworkName.StartsWith(".NETFramework", StringComparison.OrdinalIgnoreCase))

DiagnosticAnalyzer\ProgramFilesAnalyzerPathResolver.cs (1)

39=> analyzerPath.StartsWith(DotNetPath, StringComparison.OrdinalIgnoreCase);

DiagnosticAnalyzer\SuppressMessageAttributeState.TargetSymbolResolver.cs (1)

52if (id != null && prefix != null && id.StartsWith(prefix, StringComparison.Ordinal))

FileSystem\PathUtilities.cs (1)

745if (filePath.StartsWith(oldPrefix, StringComparison.Ordinal))

MetadataReader\MetadataHelpers.cs (2)

722if (delimiter == 6 && pstrName.StartsWith(SystemString, StringComparison.Ordinal)) 1070fullyQualified.StartsWith(namespaceName, StringComparison.Ordinal) &&

MetadataReader\MetadataReaderExtensions.cs (1)

25if (version.StartsWith(prefix, StringComparison.Ordinal))

MetadataReader\ModuleExtensions.cs (2)

87return !name.StartsWith(VTableGapMethodNamePrefix, StringComparison.Ordinal); 160if (emittedMethodName.StartsWith(prefix, StringComparison.Ordinal))

MetadataReference\AssemblyIdentityExtensions.cs (1)

18identity.Name.StartsWith("windows.", StringComparison.OrdinalIgnoreCase);

SourceGeneration\GeneratedCodeUtilities.cs (1)

66if (fileName.StartsWith("TemporaryGeneratedFile_", StringComparison.OrdinalIgnoreCase))

SourceGeneration\Nodes\SyntaxValueProvider_ForAttributeWithSimpleName.cs (1)

307matchAgainst.StartsWith(name, comparison);

Microsoft.CodeAnalysis.Analyzers (38)

ImmutableObjectMethodAnalyzer.cs (1)

90if (!s_immutableMethodNames.Any(n => methodName.StartsWith(n, StringComparison.Ordinal)))

MetaAnalyzers\DiagnosticDescriptorCreationAnalyzer_IdRangeAndCategoryValidation.cs (2)

86if (ruleId.StartsWith(allowedIds.prefix, StringComparison.Ordinal)) 246if (contents.Length == 0 || contents.StartsWith("#", StringComparison.Ordinal))

MetaAnalyzers\DiagnosticDescriptorCreationAnalyzer_ReleaseTracking.cs (1)

370if (ruleId.StartsWith("CA", StringComparison.OrdinalIgnoreCase) &&

MetaAnalyzers\DiagnosticDescriptorCreationAnalyzer_ResourceStringsFormat.cs (1)

89!valueElementStr.StartsWith(valueTagPrefix, StringComparison.OrdinalIgnoreCase) ||

MetaAnalyzers\DiagnosticDescriptorCreationAnalyzer.cs (3)

1296var isCARule = ruleId.StartsWith("CA", StringComparison.Ordinal); 1299!ruleId.StartsWith("CS", StringComparison.Ordinal) && 1300!ruleId.StartsWith("BC", StringComparison.Ordinal))

MetaAnalyzers\Fixers\AnalyzerReleaseTrackingFix.cs (5)

304if (lineText.StartsWith(";", StringComparison.Ordinal)) 310if (lineText.StartsWith("###", StringComparison.Ordinal)) 312if (lineText.StartsWith(ReleaseTrackingHelper.TableTitleNewRules, StringComparison.OrdinalIgnoreCase)) 327if (lineText.StartsWith(ReleaseTrackingHelper.TableTitleRemovedRules, StringComparison.OrdinalIgnoreCase)) 331else if (lineText.StartsWith(ReleaseTrackingHelper.TableTitleChangedRules, StringComparison.OrdinalIgnoreCase))

MetaAnalyzers\RegisterActionAnalyzer.cs (1)

314if (symbol == null || symbol.Kind != SymbolKind.Method || !symbol.Name.StartsWith("Register", StringComparison.Ordinal))

MetaAnalyzers\ReleaseTrackingHelper.cs (7)

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

745if (filePath.StartsWith(oldPrefix, StringComparison.Ordinal))

src\roslyn\src\Compilers\Core\Portable\SourceGeneration\GeneratedCodeUtilities.cs (1)

66if (fileName.StartsWith("TemporaryGeneratedFile_", StringComparison.OrdinalIgnoreCase))

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (2)

372!method.Name.StartsWith("Add", StringComparison.Ordinal)) 531method.Name.StartsWith("IsNull", StringComparison.Ordinal) &&

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Options\AnalyzerOptionsExtensions.cs (1)

403if (!genericInterfaceFullName.StartsWith("T:", StringComparison.Ordinal))

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (4)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\AbstractVirtualCharService.cs (1)

145if (startDelimiter.Length > 0 && !tokenText.StartsWith(startDelimiter, StringComparison.Ordinal))

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

97where kvp.Key.Trim().StartsWith("dotnet_naming_rule.", StringComparison.Ordinal)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\Option2.cs (3)

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

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\PathMetadataUtilities.cs (1)

66if (rootNamespace is not null && @namespace.StartsWith(rootNamespace + ".", StringComparison.OrdinalIgnoreCase))

Microsoft.CodeAnalysis.AnalyzerUtilities (21)

src\66dd3055a1c91c38\PointsToAnalysis.PointsToDataFlowOperationVisitor.cs (1)

983!method.Name.StartsWith("Create", StringComparison.Ordinal) ||

src\a172c07bebba4cd8\DisposeAnalysis.DisposeDataFlowOperationVisitor.cs (3)

195invocation.TargetMethod.Name.StartsWith("TryGet", StringComparison.Ordinal) && 254(targetMethod.Name.StartsWith("create", StringComparison.OrdinalIgnoreCase) || 255targetMethod.Name.StartsWith("open", StringComparison.OrdinalIgnoreCase));

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

745if (filePath.StartsWith(oldPrefix, StringComparison.Ordinal))

src\roslyn\src\Compilers\Core\Portable\SourceGeneration\GeneratedCodeUtilities.cs (1)

66if (fileName.StartsWith("TemporaryGeneratedFile_", StringComparison.OrdinalIgnoreCase))

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (2)

372!method.Name.StartsWith("Add", StringComparison.Ordinal)) 531method.Name.StartsWith("IsNull", StringComparison.Ordinal) &&

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Options\AnalyzerOptionsExtensions.cs (1)

403if (!genericInterfaceFullName.StartsWith("T:", StringComparison.Ordinal))

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (4)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\AbstractVirtualCharService.cs (1)

145if (startDelimiter.Length > 0 && !tokenText.StartsWith(startDelimiter, StringComparison.Ordinal))

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

97where kvp.Key.Trim().StartsWith("dotnet_naming_rule.", StringComparison.Ordinal)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\Option2.cs (3)

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

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\PathMetadataUtilities.cs (1)

66if (rootNamespace is not null && @namespace.StartsWith(rootNamespace + ".", StringComparison.OrdinalIgnoreCase))

Microsoft.CodeAnalysis.BuildClient.Package (3)

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

536if (dotNetRoot != null && key.StartsWith(RuntimeHostInfo.DotNetRootEnvironmentName, Environment.EnvironmentVariableComparison))

src\roslyn\src\Compilers\Shared\NativeMethods.cs (2)

150if (s.StartsWith(@"\\?\UNC\", StringComparison.Ordinal)) 152if (s.StartsWith(@"\\?\", StringComparison.Ordinal))

Microsoft.CodeAnalysis.CodeStyle (14)

src\roslyn\src\Analyzers\Core\Analyzers\Helpers\DiagnosticHelper.cs (2)

327if (id == "RE0001" || id.StartsWith("JSON", StringComparison.Ordinal)) 337Debug.Assert(id.StartsWith("IDE", StringComparison.Ordinal));

src\roslyn\src\Analyzers\Core\Analyzers\RemoveUnnecessarySuppressions\AbstractRemoveUnnecessaryPragmaSuppressionsDiagnosticAnalyzer.cs (1)

375if (trimmedPart.StartsWith(categoryPrefix, StringComparison.OrdinalIgnoreCase))

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

52if (id != null && prefix != null && id.StartsWith(prefix, StringComparison.Ordinal))

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

745if (filePath.StartsWith(oldPrefix, StringComparison.Ordinal))

src\roslyn\src\Compilers\Core\Portable\SourceGeneration\GeneratedCodeUtilities.cs (1)

66if (fileName.StartsWith("TemporaryGeneratedFile_", StringComparison.OrdinalIgnoreCase))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\AbstractVirtualCharService.cs (1)

145if (startDelimiter.Length > 0 && !tokenText.StartsWith(startDelimiter, StringComparison.Ordinal))

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

97where kvp.Key.Trim().StartsWith("dotnet_naming_rule.", StringComparison.Ordinal)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\Option2.cs (3)

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

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\PathMetadataUtilities.cs (1)

66if (rootNamespace is not null && @namespace.StartsWith(rootNamespace + ".", StringComparison.OrdinalIgnoreCase))

Microsoft.CodeAnalysis.CSharp (15)

Binder\Binder.WithQueryLambdaParametersBinder.cs (1)

56Debug.Assert(base.lambdaSymbol.Parameters[0].Name.StartsWith(transparentIdentifierPrefix, StringComparison.Ordinal));

CommandLine\CSharpCommandLineParser.cs (2)

169Debug.Assert(optionsEnded || !arg.StartsWith("@", StringComparison.Ordinal)); 213else if (value.StartsWith("0", StringComparison.Ordinal))

Compiler\DocumentationCommentCompiler.cs (1)

1104Debug.Assert(pattern.StartsWith(currentLinePattern, StringComparison.Ordinal));

Parser\DirectiveParser.cs (1)

349errorText.StartsWith(versionMarker, StringComparison.Ordinal) &&

Symbols\FunctionPointers\FunctionPointerTypeSymbol.cs (1)

213&& modifierType.Name.StartsWith("CallConv", StringComparison.Ordinal)

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

1221if (_name.StartsWith(".", StringComparison.Ordinal))

Symbols\Source\SourceNamedTypeSymbol_Extension.cs (1)

777Debug.Assert(callingConventionTypes[i].Name.StartsWith("CallConv", StringComparison.Ordinal));

Symbols\Synthesized\GeneratedNameParser.cs (5)

17=> name.StartsWith(GeneratedNameConstants.SynthesizedLocalNamePrefix, StringComparison.Ordinal); 35if (name.StartsWith("CS$<", StringComparison.Ordinal)) 39else if (name.StartsWith("<", StringComparison.Ordinal)) 166if (typeParameterName.StartsWith("<", StringComparison.Ordinal) && 181if (fieldName.StartsWith("<", StringComparison.Ordinal) &&

Symbols\Tuples\TupleTypeSymbol.cs (1)

471if (name.StartsWith("Item", StringComparison.Ordinal))

Syntax\SyntaxFactory.cs (1)

342if (text.StartsWith("@", StringComparison.Ordinal))

Microsoft.CodeAnalysis.CSharp.CodeStyle (4)

src\roslyn\src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForFluentDiagnosticAnalyzer.cs (1)

430if (!name.StartsWith(ToPrefix, StringComparison.Ordinal))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SyntaxTriviaExtensions.cs (3)

68if (commentText.StartsWith("//", StringComparison.Ordinal)) 84if (commentText.StartsWith("/*", StringComparison.Ordinal)) 99if (trimmedLine.StartsWith("*", StringComparison.Ordinal))

Microsoft.CodeAnalysis.CSharp.CodeStyle.Fixes (5)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\EnumMemberGenerator.cs (2)

143if (numericText.StartsWith("0x", StringComparison.OrdinalIgnoreCase)) 149else if (numericText.StartsWith("0b", StringComparison.OrdinalIgnoreCase))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\DocumentationCommentExtensions.cs (1)

20return documentationComment.ToFullString().StartsWith("/**", StringComparison.Ordinal);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\StringExtensions.cs (2)

42var unescaped = identifier.StartsWith("@", StringComparison.Ordinal) 49if (!identifier.StartsWith("@", StringComparison.Ordinal))

Microsoft.CodeAnalysis.CSharp.Features (3)

Completion\CompletionProviders\SnippetCompletionProvider.cs (1)

178snippets = snippets.Where(snippet => snippet.Shortcut != null && snippet.Shortcut.StartsWith("#", StringComparison.Ordinal));

LanguageServices\CSharpSymbolDisplayService.SymbolDescriptionBuilder.cs (1)

214if (!token.Text.StartsWith("'\\u", System.StringComparison.Ordinal))

src\roslyn\src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForFluentDiagnosticAnalyzer.cs (1)

430if (!name.StartsWith(ToPrefix, StringComparison.Ordinal))

Microsoft.CodeAnalysis.CSharp.NetAnalyzers (2)

Microsoft.NetCore.Analyzers\Runtime\CSharpForwardCancellationTokenToInvocationsFixer.TypeNameVisitor.cs (2)

202var unescaped = identifier.StartsWith("@", StringComparison.Ordinal) 209if (!identifier.StartsWith("@", StringComparison.Ordinal))

Microsoft.CodeAnalysis.CSharp.Workspaces (11)

Rename\CSharpRenameRewriterLanguageService.cs (2)

145_isVerbatim = _replacementText.StartsWith("@", StringComparison.Ordinal); 1168var escapedIdentifier = replacementText.StartsWith("@", StringComparison.Ordinal)

Simplification\CSharpSimplificationService.Expander.cs (1)

591Debug.Assert(name.StartsWith(originalSimpleName.Identifier.ValueText, StringComparison.Ordinal));

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SyntaxTriviaExtensions.cs (3)

68if (commentText.StartsWith("//", StringComparison.Ordinal)) 84if (commentText.StartsWith("/*", StringComparison.Ordinal)) 99if (trimmedLine.StartsWith("*", StringComparison.Ordinal))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\EnumMemberGenerator.cs (2)

143if (numericText.StartsWith("0x", StringComparison.OrdinalIgnoreCase)) 149else if (numericText.StartsWith("0b", StringComparison.OrdinalIgnoreCase))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\DocumentationCommentExtensions.cs (1)

20return documentationComment.ToFullString().StartsWith("/**", StringComparison.Ordinal);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\StringExtensions.cs (2)

42var unescaped = identifier.StartsWith("@", StringComparison.Ordinal) 49if (!identifier.StartsWith("@", StringComparison.Ordinal))

Microsoft.CodeAnalysis.Features (18)

CodeFixes\Configuration\ConfigurationUpdater.cs (2)

522if (key.StartsWith(DiagnosticOptionPrefix, StringComparison.Ordinal)) 542if (key.StartsWith(BulkConfigureAnalyzerDiagnosticsByCategoryOptionPrefix, StringComparison.Ordinal))

Completion\CompletionHelper.cs (2)

175if (item2.GetEntireDisplayText().StartsWith(item1.GetEntireDisplayText(), comparison)) 179else if (item1.GetEntireDisplayText().StartsWith(item2.GetEntireDisplayText(), comparison))

DocumentationComments\AbstractDocumentationCommentSnippetService.cs (2)

386if (!previousLineText.StartsWith(ExteriorTriviaText, StringComparison.Ordinal)) 392text.Lines[currentLine.LineNumber + 1].ToString().Trim().StartsWith(ExteriorTriviaText, StringComparison.Ordinal);

EditAndContinue\EditAndContinueDiagnosticDescriptors.cs (2)

270=> diagnosticId.Length > EncDiagnosticIdPrefix.Length && diagnosticId.StartsWith(EncDiagnosticIdPrefix, StringComparison.Ordinal) && diagnosticId[EncDiagnosticIdPrefix.Length] is >= '0' and <= '9'; 273=> diagnosticId.StartsWith(RudeEditDiagnosticIdPrefix, StringComparison.Ordinal);

GenerateType\AbstractGenerateTypeService.cs (1)

280if (namespaceSymbol != null && namespaceSymbol.ToDisplayString().StartsWith(includeUsingsOrImports, StringComparison.Ordinal))

GenerateType\AbstractGenerateTypeService.Editor.cs (2)

170namespaceToGenerateInto.StartsWith(rootNamespace + ".", StringComparison.Ordinal)) 242if (namespaceToGenerateInto.StartsWith(rootNamespace + ".", StringComparison.Ordinal))

MetadataAsSource\DocumentationCommentUtilities.cs (1)

23if (str.StartsWith(docCommentPrefix, StringComparison.Ordinal))

PdbSourceDocument\SourceLinkMap.cs (1)

192if (path.StartsWith(file.Path, StringComparison.OrdinalIgnoreCase))

ReplaceMethodWithProperty\ReplaceMethodWithPropertyCodeRefactoringProvider.cs (1)

94=> text.StartsWith(prefix, StringComparison.OrdinalIgnoreCase) && text.Length > prefix.Length && !char.IsLower(text[prefix.Length]);

src\roslyn\src\Analyzers\Core\Analyzers\Helpers\DiagnosticHelper.cs (2)

327if (id == "RE0001" || id.StartsWith("JSON", StringComparison.Ordinal)) 337Debug.Assert(id.StartsWith("IDE", StringComparison.Ordinal));

src\roslyn\src\Analyzers\Core\Analyzers\RemoveUnnecessarySuppressions\AbstractRemoveUnnecessaryPragmaSuppressionsDiagnosticAnalyzer.cs (1)

375if (trimmedPart.StartsWith(categoryPrefix, StringComparison.OrdinalIgnoreCase))

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

52if (id != null && prefix != null && id.StartsWith(prefix, StringComparison.Ordinal))

Microsoft.CodeAnalysis.NetAnalyzers (31)

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

86methodSymbol.Name.StartsWith("Try", StringComparison.Ordinal) &&

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

56var prefixedValues = enumValues.Where(m => m.Name.StartsWith(symbol.Name, StringComparison.OrdinalIgnoreCase));

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

49if (!eventName.StartsWith(BeforeKeyword, StringComparison.Ordinal) && 50!eventName.StartsWith(AfterKeyword, StringComparison.Ordinal))

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\MarkAttributesWithAttributeUsage.Fixer.cs (1)

82if (equivalenceKey is null || !equivalenceKey.StartsWith(Prefix, StringComparison.Ordinal))

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

86else if (symbol.Kind == SymbolKind.Method && symbol.Name.StartsWith(Get, StringComparison.Ordinal))

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

79return name.StartsWith("fire", StringComparison.OrdinalIgnoreCase) || 80name.StartsWith("raise", StringComparison.OrdinalIgnoreCase) || 81name.StartsWith("add", StringComparison.OrdinalIgnoreCase) || 82name.StartsWith("remove", StringComparison.OrdinalIgnoreCase);

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

120methodName.StartsWith("Get", StringComparison.OrdinalIgnoreCase) &&

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

335if (contents.Length == 0 || contents.StartsWith("#", StringComparison.Ordinal))

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

335return method.Name.StartsWith("TryParse", StringComparison.OrdinalIgnoreCase) &&

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

256static bool NameAndParametersValid(IMethodSymbol method) => method.Name.StartsWith(IsPrefix, StringComparison.Ordinal) && 267if (!methodName.StartsWith(IsPrefix, StringComparison.Ordinal))

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

150method.Name.StartsWith(IsPrefix, StringComparison.Ordinal) &&

Microsoft.NetCore.Analyzers\Performance\UseSearchValues.Fixer.cs (1)

282if (!name.StartsWith("s_", StringComparison.OrdinalIgnoreCase))

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

263stringArgumentValue.StartsWith(parameter.Name, StringComparison.Ordinal) &&

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

80if (methodName.StartsWith(MethodMetadataName, StringComparison.Ordinal) &&

src\afc74d572e54ec72\DisposeAnalysis.DisposeDataFlowOperationVisitor.cs (3)

192invocation.TargetMethod.Name.StartsWith("TryGet", StringComparison.Ordinal) && 251(targetMethod.Name.StartsWith("create", StringComparison.OrdinalIgnoreCase) || 252targetMethod.Name.StartsWith("open", StringComparison.OrdinalIgnoreCase));

src\ffd9070534249528\PointsToAnalysis.PointsToDataFlowOperationVisitor.cs (1)

980!method.Name.StartsWith("Create", StringComparison.Ordinal) ||

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

499!method.Name.StartsWith("Add", StringComparison.Ordinal)) 712method.Name.StartsWith("IsNull", StringComparison.Ordinal) &&

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

844=> symbol?.Name.StartsWith("_", StringComparison.Ordinal) == true &&

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

400if (!genericInterfaceFullName.StartsWith("T:", StringComparison.Ordinal))

src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (4)

190var nameWithPrefix = (string.IsNullOrEmpty(optionalPrefix) || parts.SymbolName.StartsWith(optionalPrefix, StringComparison.Ordinal)) 310names.FirstOrDefault(kvp => symbolDeclarationId.StartsWith(kvp.Key, StringComparison.Ordinal)) is var prefixedFirstMatchOrDefault && 321value.FirstOrDefault(kvp => symbolDeclarationId.StartsWith(kvp.Key, StringComparison.Ordinal)) is var unprefixedFirstMatchOrDefault && 331allKindsValue.FirstOrDefault(kvp => symbol.Name.StartsWith(kvp.Key, StringComparison.Ordinal)) is var partialFirstMatchOrDefault &&

Microsoft.CodeAnalysis.Razor.Compiler (45)

Language\BoundAttributeDescriptorBuilder.cs (2)

216if (Name.StartsWith(DataDashPrefix, StringComparison.OrdinalIgnoreCase)) 258if (IndexerAttributeNamePrefix.StartsWith(DataDashPrefix, StringComparison.OrdinalIgnoreCase))

Language\Components\ComponentBindLoweringPass.cs (1)

706if (!attributeName.StartsWith("bind-", StringComparison.Ordinal))

Language\Components\ComponentHelpers.cs (1)

25=> className?.StartsWith(MangledClassNamePrefix, StringComparison.Ordinal) == true;

Language\Components\ComponentLoweringPass.cs (2)

409originalAttributeName.StartsWith(bindPrefix, StringComparison.Ordinal) && 415originalName.StartsWith(bindPrefix, StringComparison.Ordinal) &&

Language\Components\ComponentNodeWriter.cs (2)

430typeName = typeName.StartsWith("global::", StringComparison.Ordinal) ? typeName : $"global::{typeName}"; 506return expression == "default" || expression.StartsWith("default(", StringComparison.Ordinal);

Language\Components\ComponentTildePathPass.cs (2)

175if (!content.StartsWith(TildePrefix, StringComparison.Ordinal)) 212&& token.Content.StartsWith(TildePrefix, StringComparison.Ordinal))

Language\Components\TypeNameHelper.cs (1)

43if (typeName.StartsWith(GlobalPrefix, StringComparison.Ordinal))

Language\DefaultRazorIntermediateNodeLoweringPhase.cs (3)

158usingReference.Namespace.StartsWith(globalPrefix, StringComparison.Ordinal)) 1247if (!_options.AllowConditionalDataDashAttributes && name.StartsWith("data-", StringComparison.OrdinalIgnoreCase)) 1426if (name.StartsWith("data-", StringComparison.OrdinalIgnoreCase))

Language\DefaultRazorProjectFileSystem.cs (2)

66if (!absolutePath.StartsWith(absoluteBasePath, StringComparison.OrdinalIgnoreCase)) 119normalizedPath.StartsWith(Root, StringComparison.OrdinalIgnoreCase))

Language\DefaultTagHelperResolutionPhase.cs (2)

250if (prefix != null && resolvedTagName.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)) 584if (prefix != null && childTagName != null && childTagName.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))

Language\DefaultTagHelperResolutionPhase.LegacyTagHelperResolver.cs (2)

734if (rawText.StartsWith("@(", StringComparison.Ordinal)) 994var isDataDash = attrName.StartsWith("data-", StringComparison.OrdinalIgnoreCase);

Language\Extensions\DefaultMetadataIdentifierFeature.cs (1)

35if (!identifier.StartsWith("/", StringComparison.Ordinal))

Language\Legacy\CSharpCodeParser.cs (1)

1377var startsWithQuote = rawValue.StartsWith("\"", StringComparison.Ordinal);

Language\Legacy\HtmlMarkupParser.cs (4)

367(At(SyntaxKind.Transition) && Lookahead(count: 1).Content.StartsWith(":", StringComparison.Ordinal)))) 1831if (trimmedStartContent.StartsWith("type", StringComparison.OrdinalIgnoreCase) && 2119if (!name.StartsWith("data-", StringComparison.OrdinalIgnoreCase)) 2348if (tagName!.StartsWith("!", StringComparison.Ordinal))

Language\Legacy\RoslynCSharpTokenizer.cs (1)

481if (trivia.IsKind(CSharpSyntaxKind.MultiLineCommentTrivia) && triviaString.StartsWith("@*", StringComparison.Ordinal))

Language\Legacy\TagHelperBlockRewriter.cs (2)

360if (attributeName.StartsWith("@", StringComparison.Ordinal)) 421if (attributeName.StartsWith("@", StringComparison.Ordinal))

Language\Legacy\TagHelperParseTreeRewriter.cs (2)

245if (string.IsNullOrEmpty(tagName) || tagName.StartsWith("!", StringComparison.Ordinal)) 316if (string.IsNullOrEmpty(tagName) || tagName.StartsWith("!", StringComparison.Ordinal))

Language\RazorCodeDocumentExtensions.cs (1)

150if (content is not null && content.StartsWith("using ", StringComparison.Ordinal))

Language\RazorProjectFileSystem.cs (1)

95if (!path.StartsWith(basePath, StringComparison.OrdinalIgnoreCase))

Language\SymbolCache.AssemblySymbolData.cs (2)

33return assembly.Name.StartsWith("Microsoft.AspNetCore.", StringComparison.Ordinal) || 35a => a.Name.StartsWith("Microsoft.AspNetCore.", StringComparison.Ordinal));

Language\TagHelperMatchingConventions.cs (2)

274attributeName.StartsWith(descriptor.Name, descriptor.GetComparison()); 291return attributeValue.StartsWith(descriptor.Value.AssumeNotNull(), StringComparison.Ordinal);

Language\VirtualRazorProjectFileSystem.cs (3)

47if (!filePath.StartsWith(Path, StringComparison.OrdinalIgnoreCase)) 62if (!path.StartsWith(Path, StringComparison.OrdinalIgnoreCase)) 89if (!path.StartsWith(Path, StringComparison.OrdinalIgnoreCase))

Mvc.Version2_X\AssemblyAttributeInjectionPass.cs (2)

93if (!relativePath.StartsWith("/", StringComparison.Ordinal) && !relativePath.StartsWith("\\", StringComparison.Ordinal))

Mvc.Version2_X\NamespaceDirective.cs (1)

101if (!source.StartsWith(directiveSource, StringComparison.OrdinalIgnoreCase) ||

Mvc\PageDirective.cs (1)

83Debug.Assert(content.StartsWith("\"", StringComparison.Ordinal));

SourceGenerators\RazorSourceGenerator.RazorProviders.cs (1)

121additionalText.Path.StartsWith(projectPath, StringComparison.OrdinalIgnoreCase))

Microsoft.CodeAnalysis.ResxSourceGenerator (18)

AbstractResxGenerator.cs (1)

95else if (options.TryGetValue("build_metadata.AdditionalFiles.RelativeDir", out var relativeDir) && !relativeDir.StartsWith("..", StringComparison.Ordinal) && !Path.IsPathRooted(relativeDir))

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

745if (filePath.StartsWith(oldPrefix, StringComparison.Ordinal))

src\roslyn\src\Compilers\Core\Portable\SourceGeneration\GeneratedCodeUtilities.cs (1)

66if (fileName.StartsWith("TemporaryGeneratedFile_", StringComparison.OrdinalIgnoreCase))

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (2)

372!method.Name.StartsWith("Add", StringComparison.Ordinal)) 531method.Name.StartsWith("IsNull", StringComparison.Ordinal) &&

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Options\AnalyzerOptionsExtensions.cs (1)

403if (!genericInterfaceFullName.StartsWith("T:", StringComparison.Ordinal))

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (4)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\AbstractVirtualCharService.cs (1)

145if (startDelimiter.Length > 0 && !tokenText.StartsWith(startDelimiter, StringComparison.Ordinal))

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

97where kvp.Key.Trim().StartsWith("dotnet_naming_rule.", StringComparison.Ordinal)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\Option2.cs (3)

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

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\PathMetadataUtilities.cs (1)

66if (rootNamespace is not null && @namespace.StartsWith(rootNamespace + ".", StringComparison.OrdinalIgnoreCase))

Microsoft.CodeAnalysis.Scripting (5)

Hosting\AssemblyLoader\MetadataShadowCopyProvider.cs (3)

148return normalizedPath.StartsWith(directory, StringComparison.OrdinalIgnoreCase); 389if (referencesDir != null && directory.StartsWith(referencesDir, StringComparison.Ordinal)) 394return !_noShadowCopyDirectories.Any(static (dir, directory) => directory.StartsWith(dir, StringComparison.Ordinal), directory);

Hosting\Resolvers\NuGetPackageResolver.cs (1)

22if (reference.StartsWith(ReferencePrefix, StringComparison.Ordinal))

src\roslyn\src\Compilers\Shared\GlobalAssemblyCacheHelpers\MonoGlobalAssemblyCache.cs (1)

78if (version != null && !assemblyDir.Name.StartsWith(version.ToString(), StringComparison.Ordinal))

Microsoft.CodeAnalysis.VisualBasic (37)

CommandLine\VisualBasicCommandLineParser.vb (1)

2227If value.StartsWith("0x", StringComparison.OrdinalIgnoreCase) Then

Emit\EditAndContinue\PEDeltaAssemblyBuilder.vb (1)

174If name.StartsWith(prefix, StringComparison.Ordinal) AndAlso

Emit\EditAndContinue\VisualBasicDefinitionMap.vb (3)

79Return name.StartsWith(GeneratedNameConstants.HoistedSpecialVariablePrefix & GeneratedNameConstants.ClosureVariablePrefix, StringComparison.Ordinal) 227isDisplayClass = name.StartsWith(GeneratedNameConstants.DisplayClassPrefix, StringComparison.Ordinal) 235If name.StartsWith(GeneratedNameConstants.LambdaMethodNamePrefix, StringComparison.Ordinal) Then

Lowering\StateMachineRewriter\StateMachineRewriter.vb (1)

209Dim isMeOfClosureType As Boolean = typeName.StartsWith(GeneratedNameConstants.DisplayClassPrefix, StringComparison.Ordinal)

Symbols\Source\SynthesizedMyGroupCollectionPropertyAccessorSymbol.vb (1)

60Debug.Assert(targetTypeName.StartsWith("Global.", StringComparison.Ordinal))

Symbols\SynthesizedSymbols\GeneratedNameParser.vb (18)

Syntax\SyntaxFactory.vb (12)

Microsoft.CodeAnalysis.VisualBasic.Workspaces (1)

Rename\VisualBasicRenameRewriterLanguageService.vb (1)

891If replacementText.StartsWith("[", StringComparison.Ordinal) AndAlso replacementText.EndsWith("]", StringComparison.Ordinal) Then

Microsoft.CodeAnalysis.Workspaces (13)

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

39=> analyzerPath.StartsWith(DotNetPath, StringComparison.OrdinalIgnoreCase);

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

745if (filePath.StartsWith(oldPrefix, StringComparison.Ordinal))

src\roslyn\src\Compilers\Core\Portable\SourceGeneration\GeneratedCodeUtilities.cs (1)

66if (fileName.StartsWith("TemporaryGeneratedFile_", StringComparison.OrdinalIgnoreCase))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\AbstractVirtualCharService.cs (1)

145if (startDelimiter.Length > 0 && !tokenText.StartsWith(startDelimiter, StringComparison.Ordinal))

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

97where kvp.Key.Trim().StartsWith("dotnet_naming_rule.", StringComparison.Ordinal)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\Option2.cs (3)

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

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\PathMetadataUtilities.cs (1)

66if (rootNamespace is not null && @namespace.StartsWith(rootNamespace + ".", StringComparison.OrdinalIgnoreCase))

Telemetry\TelemetryFeatureName.cs (1)

42=> new(type.Assembly.FullName?.StartsWith("Microsoft.", StringComparison.Ordinal) == true ? type.FullName! : "External",

Workspace\ProjectSystem\IFileChangeWatcher.cs (1)

59if (filePath.StartsWith(watchedDirectory.Path, stringComparison))

Microsoft.CodeAnalysis.Workspaces.MSBuild (1)

MSBuild\BuildHostProcessManager.cs (1)

260.Where(static key => key.StartsWith("DOTNET_ROOT", Environment.EnvironmentVariableComparison))

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

MSBuild\ProjectFile\ProjectFile.cs (1)

161var items = references.Where(it => it.EvaluatedInclude.StartsWith(partialName, StringComparison.OrdinalIgnoreCase)).ToList();

MSBuild\ProjectFile\ProjectInstanceReader.cs (2)

194=> !Path.GetFileName(item.ItemSpec).StartsWith("TemporaryGeneratedFile_", StringComparison.Ordinal); 276if (normalizedPath.StartsWith(projectDirectory, StringComparison.OrdinalIgnoreCase))

Microsoft.CSharp (6)

Microsoft\CSharp\RuntimeBinder\RuntimeBinder.cs (4)

300if (callOrInvoke.Name.StartsWith("set_", StringComparison.Ordinal) || 301callOrInvoke.Name.StartsWith("get_", StringComparison.Ordinal)) 834if ((payload.Name.StartsWith("set_", StringComparison.Ordinal) && ((MethodSymbol)swt.Sym).Params.Count > 1) || 835(payload.Name.StartsWith("get_", StringComparison.Ordinal) && ((MethodSymbol)swt.Sym).Params.Count > 0))

Microsoft\CSharp\RuntimeBinder\Semantics\MemberLookup.cs (2)

148(!symCur.name.Text.StartsWith("set_", StringComparison.Ordinal) || meth.Params.Count <= 1) && 149(!symCur.name.Text.StartsWith("get_", StringComparison.Ordinal) || meth.Params.Count <= 0))

Microsoft.Data.Analysis (2)

TextFieldParser.cs (2)

612if (trimmedLine.StartsWith(Token, StringComparison.Ordinal)) 616if (line.StartsWith(Token, StringComparison.Ordinal))

Microsoft.Data.Analysis.Tests (2)

parent\parent\src\Microsoft.Data.Analysis\TextFieldParser.cs (2)

612if (trimmedLine.StartsWith(Token, StringComparison.Ordinal)) 616if (line.StartsWith(Token, StringComparison.Ordinal))

Microsoft.Diagnostics.DataContractReader (4)

ContractDescriptorParser.cs (4)

389if (s.StartsWith("0x", StringComparison.OrdinalIgnoreCase) && 394if (s.StartsWith("-0x", StringComparison.OrdinalIgnoreCase) && 425if (s.StartsWith("0x", StringComparison.OrdinalIgnoreCase) && 430if (s.StartsWith("-0x", StringComparison.OrdinalIgnoreCase) &&

Microsoft.Diagnostics.DataContractReader.DataGenerator (2)

Emitter.cs (2)

563if (fqn.StartsWith(GlobalPrefix, System.StringComparison.Ordinal)) 567if (fqn.StartsWith(RootPrefix, System.StringComparison.Ordinal))

Microsoft.Diagnostics.NETCore.Client (9)

DiagnosticsClient\DiagnosticsClient.cs (1)

442if (PidIpcEndpoint.IpcRootPath.StartsWith(@"\\.\pipe", StringComparison.Ordinal))

DiagnosticsIpc\IpcEndpointConfig.cs (4)

187if (address.StartsWith(NamedPipeDefaultIPCRoot, StringComparison.OrdinalIgnoreCase)) 195if (address.StartsWith(NamedPipeDefaultIPCRoot, StringComparison.OrdinalIgnoreCase)) 199else if (address.StartsWith(NamedPipeSchemaDefaultIPCRootPath, StringComparison.OrdinalIgnoreCase)) 203else if (address.StartsWith("/", StringComparison.OrdinalIgnoreCase))

DiagnosticsIpc\IpcTransport.cs (4)

406if (line.StartsWith("NSpid:\t", StringComparison.Ordinal)) 477if (envVar.StartsWith("TMPDIR=", StringComparison.Ordinal)) 560if (address.StartsWith(IpcRootPath, StringComparison.OrdinalIgnoreCase)) 566return address.StartsWith(dsrouterAddress, StringComparison.OrdinalIgnoreCase);

Microsoft.DotNet.ApiCompatibility (1)

Logging\SuppressionEngine.cs (1)

68if (error.DiagnosticId.StartsWith("cp", StringComparison.InvariantCultureIgnoreCase))

Microsoft.DotNet.ApiSymbolExtensions (3)

Filtering\DocIdSymbolFilter.cs (1)

69if (symbol is IErrorTypeSymbol errorType && (docId is null || docId.StartsWith("!:", StringComparison.Ordinal)))

SymbolExtensions.cs (2)

129method.Name.StartsWith("add_", StringComparison.Ordinal) || 130method.Name.StartsWith("remove_", StringComparison.Ordinal);

Microsoft.DotNet.Arcade.Sdk (4)

src\DownloadFile.cs (2)

122if (uri.StartsWith(FileUriProtocol, StringComparison.Ordinal)) 205httpResponse.ReasonPhrase.StartsWith("The requested URI does not represent any resource on the server.", StringComparison.OrdinalIgnoreCase))

src\GenerateSourcePackageSourceLinkTargetsFile.cs (2)

52if (itemSpec.Length > projectDir.Length && itemSpec.StartsWith(projectDir, StringComparison.Ordinal)) 58if (!projectDir.StartsWith(itemSpec, StringComparison.Ordinal) ||

Microsoft.DotNet.Build.Manifest (1)

VersionIdentifier.cs (1)

168(prevDelimiterCharacter != '-' || !_knownTags.Any(tag => nextSegment.StartsWith(tag, StringComparison.OrdinalIgnoreCase))))

Microsoft.DotNet.Build.Tasks.Installers (3)

src\CreateWixBuildWixpack.cs (3)

917if (variableName.StartsWith("$(var.", StringComparison.OrdinalIgnoreCase) && variableName.EndsWith(")")) 1010if (varName.StartsWith("var.", StringComparison.OrdinalIgnoreCase)) 1015else if (varName.StartsWith("sys.", StringComparison.OrdinalIgnoreCase))

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

GenerateNuSpec.cs (1)

257where !f.GetMetadata(Metadata.FileTarget).StartsWith("$none$", StringComparison.OrdinalIgnoreCase)

HarvestPackage.cs (1)

610return path.StartsWith("ref", StringComparison.OrdinalIgnoreCase);

PackageItem.cs (1)

33IsRef = TargetPath.StartsWith("ref/", StringComparison.OrdinalIgnoreCase);

PromoteDependencies.cs (1)

106IsReference = item.GetMetadata("TargetPath").StartsWith("ref/", System.StringComparison.OrdinalIgnoreCase);

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

OptProf\GenerateTrainingPropsFile.cs (1)

48if (hasDropName && !ProductDropName.StartsWith(ProductDropNamePrefix, StringComparison.Ordinal))

OptProf\GetRunSettingsSessionConfiguration.cs (2)

82if (!dropUrl.StartsWith(prefix, StringComparison.Ordinal)) 101if (!vsDropName.StartsWith(prefix, StringComparison.Ordinal))

OptProf\IbcEntry.cs (1)

71=> path.StartsWith(prefix, StringComparison.OrdinalIgnoreCase) ? replacement + path.Substring(prefix.Length) : path;

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

StringExtensions.cs (1)

31return str.StartsWith(trimString, comparisonType) ? str.Remove(0, trimString.Length) : str;

Microsoft.DotNet.Cli.Definitions (7)

Commands\Test\TestCommandDefinition.MicrosoftTestingPlatform.cs (5)

332timeout = suffix.StartsWith("ms", StringComparison.OrdinalIgnoreCase) || 333suffix.StartsWith("mil", StringComparison.OrdinalIgnoreCase) 335: suffix.StartsWith("s", StringComparison.OrdinalIgnoreCase) 337: suffix.StartsWith("m", StringComparison.OrdinalIgnoreCase) 339: suffix.StartsWith("h", StringComparison.OrdinalIgnoreCase)

Utilities\MSBuildArgumentParser.cs (1)

11int prefixLength = unquoted.StartsWith("--", StringComparison.Ordinal) ? 2

Utilities\MSBuildPropertyParser.cs (1)

137if (input.StartsWith("\"", StringComparison.Ordinal)

Microsoft.DotNet.Cli.Utils (5)

ArgumentEscaper.cs (1)

187argument.StartsWith("\"", StringComparison.Ordinal) && argument.EndsWith("\"", StringComparison.Ordinal);

EnvironmentProvider.cs (1)

61if (path.StartsWith(tildeSlash, StringComparison.Ordinal) && !string.IsNullOrEmpty(_userHomeDirectory.Value))

PathUtility.cs (1)

35return candidate.StartsWith(dir, StringComparison.OrdinalIgnoreCase);

RuntimeEnvironment.cs (2)

134if (line.StartsWith("ID=", StringComparison.Ordinal)) 138else if (line.StartsWith("VERSION_ID=", StringComparison.Ordinal))

Microsoft.DotNet.HotReload.Watch (5)

FileWatcher\FileWatcher.cs (2)

108var alreadyWatched = _directoryTreeWatchers.Any(d => directory.StartsWith(d.Key, PathUtilities.OSSpecificPathComparison)); 130.Where(d => d.Key.StartsWith(directory, PathUtilities.OSSpecificPathComparison))

HotReload\HotReloadDotNetWatcher.cs (1)

1338if (path.StartsWith(workingDirectory, StringComparison.Ordinal) && path.Length > workingDirectory.Length)

src\sdk\src\Dotnet.Watch\HotReloadClient\Web\StaticWebAsset.cs (2)

67return assetFilePath.StartsWith(webRootDir, StringComparison.OrdinalIgnoreCase) 77=> url.StartsWith("_content/", StringComparison.OrdinalIgnoreCase);

Microsoft.DotNet.PackageValidation (2)

Filtering\TargetFrameworkFilter.cs (1)

45if (targetFramework.StartsWith(excludedTargetFrameworkWithoutWildcard, TargetFrameworkComparison))

PackageExtensions.cs (1)

11tfm.Framework != ".NETFramework" || rid.StartsWith("win", StringComparison.OrdinalIgnoreCase);

Microsoft.DotNet.SourceBuild.Tasks (4)

src\UsageReport\Usage.cs (2)

61.Where(rid => identity.Id.StartsWith($"runtime.{rid}.", StringComparison.Ordinal)) 72if (PackageIdentity.Id.StartsWith(prefix, StringComparison.Ordinal))

src\UsageReport\WritePackageUsageData.cs (2)

98.Where(dir => !EnsureTrailingSeparator(TaskEnvironment.GetAbsolutePath(dir)).StartsWith(AbsoluteRootDir, StringComparison.Ordinal)) 298if (absolutePath.StartsWith(root, StringComparison.Ordinal))

Microsoft.Extensions.AI (3)

ChatCompletion\ImageGeneratingChatClient.cs (2)

394if (content is DataContent imageContent && imageContent.MediaType.StartsWith("image/", StringComparison.OrdinalIgnoreCase)) 457if (content is DataContent imageContent && imageContent.MediaType.StartsWith("image/", StringComparison.OrdinalIgnoreCase))

Common\FunctionInvocationHelpers.cs (1)

31displayName?.StartsWith(operationName, StringComparison.Ordinal) is true &&

Microsoft.Extensions.AI.Abstractions (2)

Contents\DataContent.cs (1)

87if (!uri.StartsWith(DataUriParser.Scheme, StringComparison.OrdinalIgnoreCase))

Utilities\AIJsonUtilities.Schema.Create.cs (1)

296Debug.Assert(refUri is "#" || refUri.StartsWith("#/", StringComparison.Ordinal), $"Expected {nameof(refUri)} to be either # or start with #/, got {refUri}");

Microsoft.Extensions.AI.Evaluation.Reporting (1)

Utilities\PathValidation.cs (1)

78if (!fullResolved.StartsWith(normalizedRoot, _pathComparison) &&

Microsoft.Extensions.AI.Evaluation.Reporting.Azure (1)

src\Libraries\Microsoft.Extensions.AI.Evaluation.Reporting\CSharp\Utilities\PathValidation.cs (1)

78if (!fullResolved.StartsWith(normalizedRoot, _pathComparison) &&

Microsoft.Extensions.AI.OpenAI (8)

OpenAIChatClient.cs (1)

318case DataContent dataContent when dataContent.MediaType.StartsWith("application/pdf", StringComparison.OrdinalIgnoreCase):

OpenAIClientExtensions.cs (2)

281id?.StartsWith("conv_", StringComparison.OrdinalIgnoreCase) is true; 417if (name.StartsWith(ChatOperationName, StringComparison.Ordinal) &&

OpenAIRealtimeClientSession.cs (2)

674if (dataContent.MediaType?.StartsWith("audio/", StringComparison.Ordinal) == true) 679else if (dataContent.MediaType?.StartsWith("image/", StringComparison.Ordinal) == true && dataContent.Uri is not null)

OpenAIResponsesChatClient.cs (3)

1358case UriContent uriContent when uriContent.MediaType.StartsWith("application/pdf", StringComparison.OrdinalIgnoreCase): 1366case DataContent dataContent when dataContent.MediaType.StartsWith("application/pdf", StringComparison.OrdinalIgnoreCase): 1713if (inputImageUrl.StartsWith("data:", StringComparison.OrdinalIgnoreCase))

Microsoft.Extensions.AI.OpenAI.Tests (8)

OpenAIResponseClientIntegrationTests.cs (8)

Microsoft.Extensions.AI.Tests (1)

ChatCompletion\FunctionInvokingChatClientTests.cs (1)

1769var chatActivities = activities.Where(a => a.DisplayName.StartsWith("chat", StringComparison.Ordinal)).ToList();

Microsoft.Extensions.Configuration (1)

ConfigurationProvider.cs (1)

81kv.Key.StartsWith(parentPath, StringComparison.OrdinalIgnoreCase) &&

Microsoft.Extensions.Configuration.EnvironmentVariables (12)

EnvironmentVariablesConfigurationProvider.cs (12)

Microsoft.Extensions.Configuration.KeyPerFile (1)

KeyPerFileConfigurationSource.cs (1)

18=> IgnoreCondition = s => IgnorePrefix != null && s.StartsWith(IgnorePrefix, StringComparison.Ordinal);

Microsoft.Extensions.DataIngestion.Markdig (1)

MarkdownParser.cs (1)

127if (link.Url is not null && link.Url.StartsWith("data:image/", StringComparison.Ordinal))

Microsoft.Extensions.DataIngestion.MarkItDown (1)

src\Libraries\Microsoft.Extensions.DataIngestion.Markdig\MarkdownParser.cs (1)

127if (link.Url is not null && link.Url.StartsWith("data:image/", StringComparison.Ordinal))

Microsoft.Extensions.Diagnostics.ResourceMonitoring (1)

Linux\Disk\DiskStatsReader.cs (1)

43if (!Array.Exists(skipDevicePrefixes, prefix => stat.DeviceName.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)))

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

Linux\Resources\HardcodedValueFileSystem.cs (1)

39.Where(x => x.StartsWith(directory, StringComparison.OrdinalIgnoreCase))

Microsoft.Extensions.FileProviders.Embedded (2)

EmbeddedFileProvider.cs (2)

100if (subpath.StartsWith("/", StringComparison.Ordinal)) 165if (resourceName.StartsWith(_baseNamespace, StringComparison.Ordinal))

Microsoft.Extensions.FileProviders.Physical (7)

PhysicalFileProvider.cs (1)

249return fullPath.StartsWith(Root, StringComparison.OrdinalIgnoreCase);

PhysicalFilesWatcher.cs (6)

125if (!_root.StartsWith(watcherFullPath, StringComparison.OrdinalIgnoreCase) && 126!watcherFullPath.StartsWith(_root, StringComparison.OrdinalIgnoreCase)) 135_root.StartsWith(watcherFullPath, StringComparison.OrdinalIgnoreCase); 207pattern.StartsWith("./", StringComparison.Ordinal) ? pattern.Substring(2) : pattern; 480if (!fullPath.StartsWith(_root, StringComparison.OrdinalIgnoreCase)) 962Debug.Assert(target.StartsWith(existingAncestor, StringComparison.OrdinalIgnoreCase));

Microsoft.Extensions.FileSystemGlobbing (2)

InMemoryDirectoryInfo.cs (1)

138return filePath.StartsWith(rootDir, _comparisonType) &&

Internal\PathSegments\WildcardPathSegment.cs (1)

51if (!value.StartsWith(wildcard.BeginsWith, _comparisonType))

Microsoft.Extensions.Http.Diagnostics (2)

Logging\Internal\MediaTypeCollectionExtensions.cs (2)

29if (sample!.StartsWith(Text, StringComparison.OrdinalIgnoreCase)) 34if (sample.StartsWith(Application, StringComparison.OrdinalIgnoreCase)

Microsoft.Extensions.Localization (1)

ResourceManagerStringLocalizerFactory.cs (1)

239if (name.StartsWith(prefix, StringComparison.Ordinal))

Microsoft.Extensions.Logging.Generators (6)

LoggerMessageGenerator.Parser.cs (6)

335if (msg.StartsWith("INFORMATION:", StringComparison.OrdinalIgnoreCase) 336|| msg.StartsWith("INFO:", StringComparison.OrdinalIgnoreCase) 337|| msg.StartsWith("WARNING:", StringComparison.OrdinalIgnoreCase) 338|| msg.StartsWith("WARN:", StringComparison.OrdinalIgnoreCase) 339|| msg.StartsWith("ERROR:", StringComparison.OrdinalIgnoreCase) 340|| msg.StartsWith("ERR:", StringComparison.OrdinalIgnoreCase))

Microsoft.Extensions.Options.SourceGeneration (1)

Parser.cs (1)

394&& !baseType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat).StartsWith("global::System.", StringComparison.Ordinal))

Microsoft.Extensions.ServiceDiscovery.Dns (1)

DnsSrvServiceEndpointProviderFactory.cs (1)

107if (!line.StartsWith("search ", StringComparison.Ordinal))

Microsoft.Extensions.Validation.ValidationsGenerator (2)

src\aspnetcore\src\Shared\RoslynUtils\WellKnownTypes.cs (2)

136if (type.ContainingAssembly.Identity.Name.StartsWith("System.", StringComparison.Ordinal) 137|| type.ContainingAssembly.Identity.Name.StartsWith("Microsoft.", StringComparison.Ordinal))

Microsoft.Gen.ComplianceReports (1)

Parser.cs (1)

95if (result.StartsWith("global::", StringComparison.Ordinal))

Microsoft.Gen.Logging (7)

Emission\Emitter.cs (1)

118var fieldTypeName = classificationAttr.StartsWith(GlobalNamespacePrefix, StringComparison.Ordinal)

Parsing\Parser.cs (6)

460if (msg.StartsWith("INFORMATION:", StringComparison.OrdinalIgnoreCase) 461|| msg.StartsWith("INFO:", StringComparison.OrdinalIgnoreCase) 462|| msg.StartsWith("WARNING:", StringComparison.OrdinalIgnoreCase) 463|| msg.StartsWith("WARN:", StringComparison.OrdinalIgnoreCase) 464|| msg.StartsWith("ERROR:", StringComparison.OrdinalIgnoreCase) 465|| msg.StartsWith("ERR:", StringComparison.OrdinalIgnoreCase))

Microsoft.Gen.MetadataExtractor (1)

src\Generators\Microsoft.Gen.ComplianceReports\Parser.cs (1)

95if (result.StartsWith("global::", StringComparison.Ordinal))

Microsoft.Interop.ComInterfaceGenerator (3)

IncrementalMethodStubGenerationContext.cs (2)

69=> name.StartsWith(GetterPrefix, StringComparison.Ordinal) 70|| name.StartsWith(SetterPrefix, StringComparison.Ordinal);

VirtualMethodPointerStubGenerator.cs (1)

386if (callConvSymbol.Name.StartsWith("CallConv", StringComparison.Ordinal))

Microsoft.Interop.JavaScript.JSImportGenerator (5)

JSManagedTypeInfo.cs (5)

120case INamedTypeSymbol { TypeArguments.Length: 1 } taskType when fullTypeName.StartsWith(Constants.TaskGlobal, StringComparison.Ordinal): 128case INamedTypeSymbol { TypeArguments.Length: 1 } spanType when fullTypeName.StartsWith(Constants.SpanGlobal, StringComparison.Ordinal): 136case INamedTypeSymbol { TypeArguments.Length: 1 } arraySegmentType when fullTypeName.StartsWith(Constants.ArraySegmentGlobal, StringComparison.Ordinal): 146case INamedTypeSymbol actionType when fullTypeName.StartsWith(Constants.ActionGlobal, StringComparison.Ordinal): 157case INamedTypeSymbol funcType when fullTypeName.StartsWith(Constants.FuncGlobal, StringComparison.Ordinal):

Microsoft.Interop.LibraryImportGenerator (1)

Analyzers\LibraryImportDiagnosticsAnalyzer.cs (1)

147&& toolName.StartsWith("Microsoft.Interop.LibraryImportGenerator", StringComparison.Ordinal))

Microsoft.Interop.LibraryImportGenerator.Downlevel (1)

DownlevelLibraryImportDiagnosticsAnalyzer.cs (1)

149&& toolName.StartsWith("Microsoft.Interop.LibraryImportGenerator", StringComparison.Ordinal))

Microsoft.Maui.Controls (42)

Brush\BrushTypeConverter.cs (4)

66 if (strValue.StartsWith(Rgb, StringComparison.InvariantCulture) || strValue.StartsWith(Rgba, StringComparison.InvariantCulture) || strValue.StartsWith(Hsl, StringComparison.InvariantCulture) || strValue.StartsWith(Hsla)) 125 if (part.StartsWith("#", StringComparison.Ordinal))

Internals\ImageParser.cs (1)

265 return !string.IsNullOrEmpty(TypeIdentifier) && TypeIdentifier.StartsWith("GIF", StringComparison.OrdinalIgnoreCase);

Items\ItemsLayoutTypeConverter.cs (2)

30 else if (strValue.StartsWith("VerticalGrid", StringComparison.Ordinal)) 35 else if (strValue.StartsWith("HorizontalGrid", StringComparison.Ordinal))

Registrar.cs (2)

254 if (specificTypeRenderer.Name.StartsWith("_", StringComparison.Ordinal)) 273 if (specificTypeRenderer.Name.StartsWith("_", StringComparison.Ordinal))

ResourceDictionary.cs (1)

445 var resourceUri = uri.OriginalString.StartsWith("/", StringComparison.Ordinal)

ResourcesExtensions.cs (2)

25 else if (res.Key.StartsWith(Style.StyleClassPrefix, StringComparison.Ordinal)) 40 else if (res.Key.StartsWith(Style.StyleClassPrefix, StringComparison.Ordinal))

Routing.cs (2)

79 return source.StartsWith(ImplicitPrefix, StringComparison.Ordinal); 89 return source.StartsWith(DefaultPrefix, StringComparison.Ordinal);

Shell\RequestDefinition.cs (2)

39 if (segments[0].StartsWith("/", StringComparison.Ordinal) || segments[0].StartsWith("\\", StringComparison.Ordinal))

Shell\RouteRequestBuilder.cs (4)

169 if (matchMe.StartsWith("/", StringComparison.Ordinal) || 170 matchMe.StartsWith("\\", StringComparison.Ordinal)) 243 if (segments[0].StartsWith(_uriSeparator, StringComparison.Ordinal) || segments[0].StartsWith("\\", StringComparison.Ordinal))

Shell\ShellNavigationState.cs (1)

70 if (!uri.OriginalString.StartsWith("//", StringComparison.Ordinal))

Shell\ShellRouteParameters.cs (2)

47 if (!q.Key.StartsWith(prefix, StringComparison.Ordinal)) 103 if (query.StartsWith("?", StringComparison.Ordinal))

Shell\ShellUriHandler.cs (8)

VisualElement\VisualElement.cs (10)

Xaml\TypeConversionExtensions.cs (1)

205 if (toType == typeof(String) && str.StartsWith("{}", StringComparison.Ordinal))

Microsoft.Maui.Controls.Build.Tasks (24)

CompiledConverters\BrushTypeConverter.cs (1)

19 if (value.StartsWith("#", StringComparison.Ordinal))

CompiledConverters\ColorTypeConverter.cs (1)

23 if (value.StartsWith("#", StringComparison.Ordinal))

CompiledConverters\StrokeShapeTypeConverter.cs (7)

24 if (value.StartsWith(ShapeConverter.Ellipse, StringComparison.Ordinal)) 31 if (value.StartsWith(ShapeConverter.Line, StringComparison.Ordinal)) 80 if (value.StartsWith(ShapeConverter.Path, StringComparison.Ordinal)) 102 if (value.StartsWith(ShapeConverter.Polygon, StringComparison.Ordinal)) 130 if (value.StartsWith(ShapeConverter.Polyline, StringComparison.Ordinal)) 158 if (value.StartsWith(ShapeConverter.Rectangle, StringComparison.Ordinal)) 164 if (value.StartsWith(ShapeConverter.RoundRectangle, StringComparison.Ordinal))

ExpandMarkupsVisitor.cs (2)

86 if (expression.StartsWith("{}", StringComparison.Ordinal)) 142 if (remaining.StartsWith("}", StringComparison.Ordinal))

ModuleDefinitionExtensions.cs (1)

303 visibleTo.StartsWith(to.Assembly.Name.Name, StringComparison.InvariantCulture));

NodeILExtensions.cs (1)

277 else if (targetTypeRef.FullName == "System.String" && str.StartsWith("{}", StringComparison.Ordinal))

TypeReferenceExtensions.cs (11)

Microsoft.Maui.Controls.SourceGen (8)

CodeBehindGenerator.cs (2)

531 !namespaceuri.StartsWith("clr-namespace", StringComparison.InvariantCulture) && 532 !namespaceuri.StartsWith("using:", StringComparison.InvariantCulture))

src\Controls\src\Xaml\XmlnsHelper.cs (5)

26 if (xmlns.StartsWith("using:", StringComparison.Ordinal)) 40 if (decl.StartsWith("clr-namespace:", StringComparison.Ordinal)) 45 if (decl.StartsWith("assembly=", StringComparison.Ordinal)) 50 if (decl.StartsWith("targetPlatform=", StringComparison.Ordinal)) 72 if (decl.StartsWith("using:", StringComparison.Ordinal))

src\Controls\src\Xaml\XmlTypeXamlExtensions.cs (1)

89 (assemblyName == "mscorlib" || assemblyName.StartsWith("mscorlib,", StringComparison.Ordinal)))

Microsoft.Maui.Controls.Xaml (13)

ExpandMarkupsVisitor.cs (2)

80 if (expression.StartsWith("{}", StringComparison.Ordinal)) 140 if (remaining.StartsWith("}", StringComparison.Ordinal))

MarkupExpressionParser.cs (1)

55 if (expression.StartsWith("{}", StringComparison.Ordinal))

XamlParser.cs (4)

74 if (reader.Name.StartsWith(elementName + ".", StringComparison.Ordinal)) 320 if (valueString != null && valueString.Trim().StartsWith("{}", StringComparison.Ordinal)) 325 if (valueString != null && valueString.Trim().StartsWith("{", StringComparison.Ordinal)) 450 ca.AssemblyName.StartsWith(to.GetName().Name, StringComparison.InvariantCulture));

XmlnsHelper.cs (5)

XmlTypeXamlExtensions.cs (1)

89 (assemblyName == "mscorlib" || assemblyName.StartsWith("mscorlib,", StringComparison.Ordinal)))

Microsoft.Maui.Graphics (2)

Text\TextColors.cs (2)

159 if (!color.StartsWith("#", StringComparison.Ordinal)) 202 if (!color.StartsWith("#", StringComparison.Ordinal))

Microsoft.Maui.Graphics.Text.Markdig (1)

Renderer\HtmlInlineRenderer.cs (1)

15 if (tag.StartsWith("<span ", StringComparison.Ordinal)

Microsoft.Maui.Resizetizer (1)

GetMauiAssetPath.cs (1)

86 if (path.StartsWith(projectDirectory, StringComparison.OrdinalIgnoreCase))

Microsoft.ML.Core (4)

ComponentModel\AssemblyLoadingUtils.cs (1)

181if (name.StartsWith(s, StringComparison.OrdinalIgnoreCase))

ComponentModel\ComponentCatalog.cs (1)

1113if (assembly.FullName.StartsWith("Microsoft.ML.", StringComparison.Ordinal)

Utilities\Utils.cs (2)

25return str.StartsWith(startsWith, StringComparison.InvariantCultureIgnoreCase); 30return str.StartsWith(startsWith, StringComparison.InvariantCulture);

Microsoft.ML.CpuMath.UnitTests (1)

UnitTests.cs (1)

36public static bool IsNetCore => Environment.Version.Major >= 5 || RuntimeInformation.FrameworkDescription.StartsWith(".NET Core", StringComparison.OrdinalIgnoreCase);

Microsoft.ML.Data (1)

TrainCatalog.cs (1)

122while (!type!.FullName!.StartsWith("Microsoft.ML.Data.TransformerChain`1[", StringComparison.Ordinal))

Microsoft.ML.InternalCodeAnalyzer (2)

NameAnalyzer.cs (1)

141=> !string.IsNullOrEmpty(name) && name.StartsWith("_", StringComparison.OrdinalIgnoreCase) && Utils.NameIsGood(name, 1, false);

NameFixProvider.cs (1)

66&& context.Document.Name.StartsWith(originalName, StringComparison.OrdinalIgnoreCase))

Microsoft.ML.Samples (2)

Dynamic\DataOperations\FilterRowsByCustomPredicate.cs (1)

49data, input => input.Name.StartsWith("r", StringComparison.OrdinalIgnoreCase));

Dynamic\DataOperations\FilterRowsByStatefulCustomPredicate.cs (1)

53return (filter && input.Name.StartsWith("r", StringComparison.OrdinalIgnoreCase));

Microsoft.ML.Tokenizers (5)

Model\BpeOptions.cs (1)

77if (line.StartsWith("#version", StringComparison.Ordinal) || line.Length == 0)

Model\BPETokenizer.cs (1)

1159if (line.StartsWith("#version", StringComparison.Ordinal) || line.Length == 0)

Model\TiktokenTokenizer.cs (2)

172if (line is not null && line.StartsWith(capacity, StringComparison.Ordinal)) 1161if (modelName.StartsWith(Prefix, StringComparison.OrdinalIgnoreCase))

Model\WordPieceTokenizer.cs (1)

753if (token.StartsWith(ContinuingSubwordPrefix, StringComparison.Ordinal))

Microsoft.ML.Tokenizers.Tests (1)

BpeTests.cs (1)

1085if (content is not null && !content.StartsWith("<｜place▁holder", StringComparison.OrdinalIgnoreCase))

Microsoft.NET.Build.Containers (3)

Registry\Registry.cs (1)

158public bool IsGithubPackageRegistry => RegistryName.StartsWith(RegistryConstants.GitHubPackageRegistryDomain, StringComparison.Ordinal);

Registry\RegistrySettings.cs (1)

74if (registryName.StartsWith("localhost:", StringComparison.OrdinalIgnoreCase) ||

Tasks\ComputeDotnetBaseImageAndTag.cs (1)

125var muslRidsCount = TargetRuntimeIdentifiers.Count(rid => rid.StartsWith("linux-musl", StringComparison.Ordinal));

Microsoft.NET.Build.Tasks (3)

ExecutableExtension.cs (1)

12if (runtimeIdentifier.StartsWith("win", StringComparison.OrdinalIgnoreCase))

GetDefaultPlatformTargetForNetFramework.cs (1)

58if (pathInPackage.StartsWith("runtimes/win7-x86/", StringComparison.OrdinalIgnoreCase))

src\sdk\src\Common\NuGetUtils.NuGet.cs (1)

50return file.StartsWith("analyzers", StringComparison.Ordinal)

Microsoft.NET.ProjectData (25)

CacheFileReader.cs (10)

333 if (line is null || !line.StartsWith(VersionLinePrefix, StringComparison.Ordinal)) 348 if (versionHeader is null || !versionHeader.StartsWith(VersionLinePrefix, StringComparison.Ordinal)) 387 if (firstLine is not null && firstLine.StartsWith(CacheFormat.HashHeaderPrefix, StringComparison.Ordinal)) 453 if (currentSection is null && line.StartsWith(CacheFormat.ProjectHeaderPrefix, StringComparison.Ordinal)) 580 if (line.StartsWith(CacheFormat.ProjectHeaderPrefix, StringComparison.Ordinal)) 584 else if (line.StartsWith(CacheFormat.LanguagePrefix, StringComparison.Ordinal)) 620 return value.StartsWith(PathSentinels.Path, StringComparison.Ordinal) 704 if (portablePath.Length == 0 || portablePath[0] == '<' || portablePath.StartsWith("../", StringComparison.Ordinal)) 1026 if (trimmed.StartsWith(PathSentinels.NetSdk, StringComparison.Ordinal)) 1052 if (path.StartsWith(PathSentinels.NetSdk, StringComparison.Ordinal))

CachePathResolver.cs (10)

Donor\ProjectDataDonorIndex.cs (3)

145 if (!normalizedFullPath.StartsWith(normalizedRoot, PathComparison)) 151 return relativePath.Length > 0 && !relativePath.StartsWith(".." + Path.DirectorySeparatorChar, StringComparison.Ordinal); 226 if (!content.StartsWith(Prefix, StringComparison.OrdinalIgnoreCase))

Donor\ProjectDataDonorIndex.Git.cs (1)

74 if (head.StartsWith(RefPrefix, StringComparison.Ordinal))

ProjectDataBuildDiagnosticProtocol.cs (1)

52 !line.StartsWith(Prefix, StringComparison.Ordinal))

Microsoft.NET.ProjectData.Generators (2)

DataModelSchemaGenerator.cs (2)

332 if (entry.Name.StartsWith("$", StringComparison.Ordinal)) 500 if (!value.StartsWith(Prefix, StringComparison.Ordinal))

Microsoft.NET.ProjectData.Tasks (56)

AnalyzerConfigFileFilter.cs (6)

48 if (!portablePath.StartsWith(netSdkPrefix, StringComparison.OrdinalIgnoreCase)) return false; 52 if (sdkRelative.StartsWith(analyzerConfigPrefix, StringComparison.OrdinalIgnoreCase)) 57 return fileName.StartsWith("analysislevel_", StringComparison.OrdinalIgnoreCase) 62 if (sdkRelative.StartsWith(codeStylePrefix, StringComparison.OrdinalIgnoreCase)) 75 return fileName.StartsWith(stylePrefix, StringComparison.OrdinalIgnoreCase) 192 && normalizedDescendant.StartsWith(normalizedCandidate, StringComparisons.Paths);

CachePathResolver.cs (4)

58 if (absolutePath.StartsWith(this.nugetFolders[i], this.pathsComparison)) 63 if (absolutePath.StartsWith(this.dotnetRoots[i], this.pathsComparison)) 69 if (this.netFxRefRoot != null && absolutePath.StartsWith(this.netFxRefRoot, this.pathsComparison)) 132 if (!portable.StartsWith(SdkPrefix, StringComparison.Ordinal)) return portable;

ForwardCompat.cs (1)

679 if (raw.StartsWith(VersionLinePrefix, StringComparison.Ordinal))

ProjectDataMerger.cs (5)

310 foreach (string line in lines.Where(static l => l.StartsWith(CacheFormat.ProjectHeaderPrefix, StringComparison.Ordinal))) 315 foreach (string line in lines.Where(static l => !l.StartsWith(CacheFormat.ProjectHeaderPrefix, StringComparison.Ordinal))) 382 if (!normalized.StartsWith("net", StringComparison.OrdinalIgnoreCase)) 402 if (line.StartsWith("version=", StringComparison.Ordinal)) continue; 422 else if (!line.StartsWith(CacheFormat.LanguagePrefix, StringComparison.Ordinal))

ProjectDataWriter.cs (36)

src\roslyn\src\ProjectData\Microsoft.NET.ProjectData\Donor\ProjectDataDonorIndex.cs (3)

src\roslyn\src\ProjectData\Microsoft.NET.ProjectData\ProjectDataBuildDiagnosticProtocol.cs (1)

52 !line.StartsWith(Prefix, StringComparison.Ordinal))

Microsoft.NET.Sdk.Publish.Tasks (6)

Tasks\MsDeploy\ImportParameterFile.cs (1)

76|| attribute.Name.StartsWith("xmlns:", StringComparison.Ordinal)

Tasks\MsDeploy\NormalizeServiceUrl.cs (5)

88if (tempUrl.StartsWith("localhost:", StringComparison.OrdinalIgnoreCase)) 92else if (tempUrl.StartsWith("http://localhost:", StringComparison.OrdinalIgnoreCase)) 119if (!(serviceUrl.StartsWith(http, StringComparison.OrdinalIgnoreCase) || serviceUrl.StartsWith(https, StringComparison.OrdinalIgnoreCase))) 173if (serviceUrl.StartsWith("http://", StringComparison.OrdinalIgnoreCase))

Microsoft.NET.Sdk.StaticWebAssets.Tasks (2)

CollectStaticWebAssetsToCopy.cs (1)

52if (asset.Identity.StartsWith(normalizedOutputPath, StringComparison.Ordinal))

GenerateStaticWebAssetsDevelopmentManifest.cs (1)

318if (asset.Identity.StartsWith(asset.ContentRoot, OSPath.PathComparison))

Microsoft.SourceLink.AzureDevOpsServer.Git (3)

src\sourcelink\src\Common\Utilities\PathUtilities.cs (2)

25if (fullPath.StartsWith(UncPrefix, StringComparison.Ordinal)) 32else if (fullPath.StartsWith(UnixRoot, StringComparison.Ordinal))

src\sourcelink\src\Common\Utilities\UriUtilities.cs (1)

38return url.StartsWith(prefix, StringComparison.Ordinal);

Microsoft.SourceLink.AzureRepos.Git (3)

src\sourcelink\src\Common\Utilities\PathUtilities.cs (2)

25if (fullPath.StartsWith(UncPrefix, StringComparison.Ordinal)) 32else if (fullPath.StartsWith(UnixRoot, StringComparison.Ordinal))

src\sourcelink\src\Common\Utilities\UriUtilities.cs (1)

38return url.StartsWith(prefix, StringComparison.Ordinal);

Microsoft.SourceLink.Bitbucket.Git (3)

src\sourcelink\src\Common\Utilities\PathUtilities.cs (2)

25if (fullPath.StartsWith(UncPrefix, StringComparison.Ordinal)) 32else if (fullPath.StartsWith(UnixRoot, StringComparison.Ordinal))

src\sourcelink\src\Common\Utilities\UriUtilities.cs (1)

38return url.StartsWith(prefix, StringComparison.Ordinal);

Microsoft.SourceLink.Common (3)

parent\Common\Utilities\PathUtilities.cs (2)

25if (fullPath.StartsWith(UncPrefix, StringComparison.Ordinal)) 32else if (fullPath.StartsWith(UnixRoot, StringComparison.Ordinal))

parent\Common\Utilities\UriUtilities.cs (1)

38return url.StartsWith(prefix, StringComparison.Ordinal);

Microsoft.SourceLink.Gitea (3)

src\sourcelink\src\Common\Utilities\PathUtilities.cs (2)

25if (fullPath.StartsWith(UncPrefix, StringComparison.Ordinal)) 32else if (fullPath.StartsWith(UnixRoot, StringComparison.Ordinal))

src\sourcelink\src\Common\Utilities\UriUtilities.cs (1)

38return url.StartsWith(prefix, StringComparison.Ordinal);

Microsoft.SourceLink.Gitee (3)

src\sourcelink\src\Common\Utilities\PathUtilities.cs (2)

25if (fullPath.StartsWith(UncPrefix, StringComparison.Ordinal)) 32else if (fullPath.StartsWith(UnixRoot, StringComparison.Ordinal))

src\sourcelink\src\Common\Utilities\UriUtilities.cs (1)

38return url.StartsWith(prefix, StringComparison.Ordinal);

Microsoft.SourceLink.GitHub (3)

src\sourcelink\src\Common\Utilities\PathUtilities.cs (2)

25if (fullPath.StartsWith(UncPrefix, StringComparison.Ordinal)) 32else if (fullPath.StartsWith(UnixRoot, StringComparison.Ordinal))

src\sourcelink\src\Common\Utilities\UriUtilities.cs (1)

38return url.StartsWith(prefix, StringComparison.Ordinal);

Microsoft.SourceLink.GitLab (3)

src\sourcelink\src\Common\Utilities\PathUtilities.cs (2)

25if (fullPath.StartsWith(UncPrefix, StringComparison.Ordinal)) 32else if (fullPath.StartsWith(UnixRoot, StringComparison.Ordinal))

src\sourcelink\src\Common\Utilities\UriUtilities.cs (1)

38return url.StartsWith(prefix, StringComparison.Ordinal);

Microsoft.SourceLink.GitWeb (3)

src\sourcelink\src\Common\Utilities\PathUtilities.cs (2)

25if (fullPath.StartsWith(UncPrefix, StringComparison.Ordinal)) 32else if (fullPath.StartsWith(UnixRoot, StringComparison.Ordinal))

src\sourcelink\src\Common\Utilities\UriUtilities.cs (1)

38return url.StartsWith(prefix, StringComparison.Ordinal);

Microsoft.SourceLink.Tools.Package (1)

SourceLinkMap.cs (1)

212if (path.StartsWith(file.Path, StringComparison.OrdinalIgnoreCase))

Microsoft.TemplateEngine.Cli (3)

Commands\create\InstantiateCommand.TabCompletion.cs (2)

30templateGroups.Where(t => t.ShortNames.Any(sn => sn.StartsWith(templateName, StringComparison.OrdinalIgnoreCase))); 33.Select(g => new CompletionItem(g.ShortNames.First(sn => sn.StartsWith(templateName, StringComparison.OrdinalIgnoreCase)), documentation: g.Description))

TemplateSearch\CliTemplateSearchCoordinator.cs (1)

157.Where(hit => hit.PackageInfo.Name.StartsWith("Microsoft", StringComparison.OrdinalIgnoreCase)

Microsoft.TemplateEngine.Core (3)

Expressions\Cpp\CppStyleEvaluatorDefinition.cs (1)

569if (literal.StartsWith("0x", StringComparison.OrdinalIgnoreCase)

Expressions\Shared\CoreConverters.cs (2)

18if (ls!.StartsWith(prefix, StringComparison.OrdinalIgnoreCase) && long.TryParse(ls.Substring(2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out result)) 35if (ls!.StartsWith(prefix, StringComparison.OrdinalIgnoreCase) && int.TryParse(ls.Substring(2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out result))

Microsoft.TemplateEngine.Edge (1)

Mount\Archive\ZipFileDirectory.cs (1)

26return _mountPoint.Universe.Values.Where(x => x.FullPath.StartsWith(FullPath, StringComparison.Ordinal) && x.FullPath.Length != FullPath.Length && r.IsMatch(x.Name)).Where(x => searchOption == SearchOption.AllDirectories || x.FullPath.TrimEnd('/').Count(y => y == '/') == FullPath.Count(y => y == '/'));

Microsoft.TemplateEngine.Orchestrator.RunnableProjects (2)

ParameterConverter.cs (2)

201else if (choiceValue.StartsWith(literal, StringComparison.OrdinalIgnoreCase)) 254if (literal.StartsWith("0x", StringComparison.OrdinalIgnoreCase)

Microsoft.TemplateEngine.Utils (1)

PhysicalFileSystem.cs (1)

139if (target.StartsWith(relativeTo, StringComparison.CurrentCulture))

Microsoft.TestPlatform.Build (3)

Tasks\TestTaskUtils.cs (1)

83if (arg != null && arg.StartsWith(loggerToUse, StringComparison.OrdinalIgnoreCase))

Tasks\VSTestTask2.cs (2)

77while (singleLine.StartsWith(_ansiReset, StringComparison.Ordinal)) 264if (singleLine.StartsWith(_messageSplitter, StringComparison.Ordinal))

Microsoft.TestPlatform.CoreUtilities (8)

Helpers\CommandLineArgumentsHelper.cs (2)

29if (args[i].StartsWith("-", StringComparison.Ordinal)) 31if (i < args.Length - 1 && !args[i + 1].StartsWith("-", StringComparison.Ordinal))

Utilities\TimeSpanParser.cs (6)

44if (suffix.StartsWith("ms", c) || suffix.StartsWith("mil", c) || suffix == string.Empty) 50if (suffix.StartsWith("s", c)) 56if (suffix.StartsWith("m", c)) 62if (suffix.StartsWith("h", c)) 68if (suffix.StartsWith("d", c))

Microsoft.TestPlatform.CrossPlatEngine (2)

Execution\BaseRunTests.cs (1)

501foreach (var adapterMetrics in TestRunCache.AdapterTelemetry.Keys.Where(k => k.StartsWith(executorUri, StringComparison.Ordinal)))

Execution\MSTestV1TelemetryHelper.cs (1)

55if (hasExtension && testExtension!.StartsWith("urn:", StringComparison.Ordinal))

Microsoft.TestPlatform.Extensions.BlameDataCollector (2)

BlameCollector.cs (1)

598if (dumpFileName.StartsWith(_testHostProcessName, StringComparison.OrdinalIgnoreCase))

ProcDumpDumper.cs (1)

264.Where(dump => Path.GetFileNameWithoutExtension(dump).StartsWith(_outputFilePrefix ?? string.Empty, StringComparison.Ordinal))

Microsoft.TestPlatform.TestHostRuntimeProvider (5)

Hosting\DefaultTestHostManager.cs (1)

264if (targetFramework.Name.StartsWith(".NETFramework,Version=v", StringComparison.Ordinal))

Hosting\DotnetTestHostManager.cs (4)

165internal bool MakeRunsettingsCompatible => _hostPackageVersion.StartsWith("15.0.0-preview", StringComparison.Ordinal); 539if (_targetFramework.Name.StartsWith(".NETCoreApp,", StringComparison.OrdinalIgnoreCase) 946.Where(kvp => kvp.Key.StartsWith("DOTNET_", StringComparison.OrdinalIgnoreCase)) 1026IsVersionCheckRequired = !_hostPackageVersion.StartsWith("15.0.0", StringComparison.Ordinal);

Microsoft.VisualStudio.TestPlatform.Common (2)

DataCollection\DataCollectionTelemetryManager.cs (2)

76dataCollectorInformation.TestExecutionEnvironmentVariables.Any(pair => pair.Key.StartsWith(ClrIeInstrumentationMethodConfigurationPrefix32Variable, StringComparison.Ordinal)) && 77dataCollectorInformation.TestExecutionEnvironmentVariables.Any(pair => pair.Key.StartsWith(ClrIeInstrumentationMethodConfigurationPrefix64Variable, StringComparison.Ordinal)))

Microsoft.VisualStudio.TestPlatform.Extensions.Trx.TestLogger (8)

Utility\Converter.cs (4)

183if (attachmentSet.Uri.AbsoluteUri.StartsWith(Constants.DataCollectorUriPrefix, StringComparison.OrdinalIgnoreCase)) 204if (!attachmentSet.Uri.AbsoluteUri.StartsWith(Constants.DataCollectorUriPrefix, StringComparison.OrdinalIgnoreCase)) 393if (attachmentSet.Uri.AbsoluteUri.StartsWith(Constants.DataCollectorUriPrefix, StringComparison.OrdinalIgnoreCase)) 656var testMethodName = fullyQualifiedName.StartsWith($"{className}.", StringComparison.Ordinal) ? fullyQualifiedName.Remove(0, $"{className}.".Length) : fullyQualifiedName;

XML\XmlPersistence.cs (4)

589string defaultFieldLocation = fieldName.StartsWith("m_", StringComparison.Ordinal) ? fieldName.Substring(2, fieldName.Length - 2) : fieldName; 747if (location.StartsWith("@", StringComparison.Ordinal)) 861if (query.Length > 0 || queryIn.StartsWith("/", StringComparison.Ordinal)) 866if (part != "." && part != ".." && !part.Contains(":") && (part.Length > 0) && (!part.StartsWith("@", StringComparison.Ordinal)))

Microsoft.VisualStudio.TestPlatform.ObjectModel (7)

Nuget.Frameworks\FrameworkNameProvider.cs (1)

527if (profile.StartsWith("Profile", StringComparison.OrdinalIgnoreCase))

TestProperty\TestProperty.cs (6)

196if (type == null && typeName.StartsWith("System.Uri", StringComparison.Ordinal)) 200else if (type == null && typeName.StartsWith("System.TimeSpan", StringComparison.Ordinal)) 204else if (type == null && typeName.StartsWith("System.DateTimeOffset", StringComparison.Ordinal)) 208else if (type == null && typeName.StartsWith("System.Int16", StringComparison.Ordinal)) 213else if (type == null && typeName.StartsWith("System.Int32", StringComparison.Ordinal)) 217else if (type == null && typeName.StartsWith("System.Int64", StringComparison.Ordinal))

Microsoft.Web.Xdt.Extensions (1)

InsertOrAppendAttribute.cs (1)

58if (trimmedArg.StartsWith(name, StringComparison.OrdinalIgnoreCase))

Microsoft.Web.XmlTransform (4)

XmlAttributePreservationDict.cs (1)

36Debug.Assert(elementStartTag.StartsWith("<", StringComparison.Ordinal) && elementStartTag.EndsWith(">", StringComparison.Ordinal), "Expected string containing exactly a single tag");

XmlFormatter.cs (1)

423if (currentIndentNode.Value.StartsWith(previousIndentNode.Value, StringComparison.Ordinal)) {

XmlLocator.cs (1)

249if (!predicate.StartsWith("[", StringComparison.Ordinal)) {

XmlLocators.cs (1)

77if (!xpath.StartsWith("/", StringComparison.Ordinal)) {

Microsoft.Win32.Registry (1)

Microsoft\Win32\Registry.cs (1)

55if (baseKey != null && keyName.StartsWith(baseKey.Name, StringComparison.OrdinalIgnoreCase))

MSBuild (10)

CommandLine\CommandLineParser.cs (8)

parent\Shared\TypeLoader.cs (1)

669_runtime = targetFramework.StartsWith(DotNetCoreIdentifier, StringComparison.Ordinal) ? MSBuildRuntimeValues.net : MSBuildRuntimeValues.clr4;

XMake.cs (1)

4230bool found = nameValue.StartsWith($"{name}=", StringComparison.OrdinalIgnoreCase) || // Parameters with value, such as "logfile=foo.txt"

MyFrontend (1)

Components\NavigationManagerExtensions.cs (1)

9if (uri.StartsWith(navigationManager.BaseUri, StringComparison.Ordinal))

NuGet.Build.Tasks.Pack (1)

PackTaskLogic.cs (1)

763sourcePath.StartsWith(packArgs.CurrentDirectory, StringComparison.CurrentCultureIgnoreCase) &&

NuGet.CommandLine.XPlat (1)

Commands\DeleteCommand.cs (1)

114return result != null && result.StartsWith(Strings.ConsoleConfirmMessageAccept, StringComparison.OrdinalIgnoreCase);

NuGet.Commands (16)

CommandRunners\PackCommandRunner.cs (1)

709|| (fileName.StartsWith(".", StringComparison.Ordinal) && fileName.IndexOf(".", startIndex: 1, StringComparison.Ordinal) == -1);

MSBuildProjectFactory.cs (1)

291return contentFileTargetPath != null && contentFileTargetPath.StartsWith("contentFiles", StringComparison.Ordinal);

RestoreCommand\CompatibilityChecker.cs (2)

327p.StartsWith("ref/", StringComparison.OrdinalIgnoreCase) 328|| p.StartsWith("lib/", StringComparison.OrdinalIgnoreCase)); // No assemblies at all (for any TxM)

RestoreCommand\ContentFiles\ContentFileUtils.cs (1)

115Debug.Assert(file.StartsWith(ContentFilesFolderName, StringComparison.OrdinalIgnoreCase),

RestoreCommand\LockFileBuilder.cs (1)

693return file.StartsWith("tools/", StringComparison.OrdinalIgnoreCase);

RestoreCommand\RestoreCommand.cs (1)

586return path.StartsWith("analyzers/", StringComparison.Ordinal)

RestoreCommand\Utility\BuildAssetsUtils.cs (2)

119&& path.StartsWith(macroValue, StringComparison.OrdinalIgnoreCase)) 371if (absolutePath.StartsWith(repositoryRoot, StringComparison.Ordinal))

RestoreCommand\Utility\LockFileUtils.cs (4)

450lockFileLib.RuntimeAssemblies = lockFileLib.RuntimeAssemblies.Where(p => !p.Path.StartsWith("lib/", StringComparison.Ordinal) || referenceFilter.Contains(Path.GetFileName(p.Path))).ToList(); 451lockFileLib.CompileTimeAssemblies = lockFileLib.CompileTimeAssemblies.Where(p => !p.Path.StartsWith("lib/", StringComparison.Ordinal) || referenceFilter.Contains(Path.GetFileName(p.Path))).ToList(); 1212if (!lockFileLib.Build.Any(item => item.Path.StartsWith("buildTransitive/", StringComparison.OrdinalIgnoreCase))) 1227if (!currentBuildItem.Path.StartsWith("build/", StringComparison.OrdinalIgnoreCase))

RestoreCommand\Utility\MSBuildRestoreUtility.cs (2)

1206&& s.StartsWith($"{prefixWithoutSlashes}/", StringComparison.OrdinalIgnoreCase) 1207&& !s.StartsWith($"{prefixWithoutSlashes}{DoubleSlash}", StringComparison.OrdinalIgnoreCase))

RestoreCommand\Utility\NoOpRestoreUtilities.cs (1)

149if (!package.StartsWith(request.PackagesDirectory, StringComparison.OrdinalIgnoreCase)) { continue; }

NuGet.Common (11)

Migrations\Migration1.cs (1)

87if (!path.StartsWith(homePath + Path.DirectorySeparatorChar, StringComparison.Ordinal))

MsBuildStringUtility.cs (1)

109if (split[i].StartsWith("NU", StringComparison.OrdinalIgnoreCase) &&

PathUtil\PathResolver.cs (2)

64if (wildcard.StartsWith("**", StringComparison.OrdinalIgnoreCase)) 218while (searchPath.StartsWith(parentDirectoryPath, StringComparison.OrdinalIgnoreCase))

PathUtil\PathUtility.cs (4)

143return candidate.StartsWith(dir, StringComparison.OrdinalIgnoreCase); 327if (path.StartsWith("/", StringComparison.Ordinal)) 418return path.StartsWith(basePath, StringComparison.OrdinalIgnoreCase); 513if (filename.StartsWith(currentDirectoryPath, PathUtility.GetStringComparisonBasedOnOS()))

PathUtil\PathValidator.cs (2)

51return Path.IsPathRooted(path) && !path.StartsWith(@"\\", StringComparison.Ordinal); 75return path.StartsWith(@"\\", StringComparison.Ordinal);

UriUtility.cs (1)

75&& localOrUriPath.StartsWith(FilePrefix, StringComparison.OrdinalIgnoreCase))

NuGet.Configuration (3)

PackageSource\PackageSource.cs (2)

51if (value.StartsWith("https://", StringComparison.OrdinalIgnoreCase)) 57else if (value.StartsWith("http://", StringComparison.OrdinalIgnoreCase))

PackageSource\PackageSourceProvider.cs (1)

424if (packageSource.Name.StartsWith(namePrefix, StringComparison.OrdinalIgnoreCase))

NuGet.Frameworks (1)

FrameworkNameProvider.cs (1)

539if (profile.StartsWith("Profile", StringComparison.OrdinalIgnoreCase))

NuGet.PackageManagement (6)

Projects\MSBuildNuGetProject.cs (3)

384p.StartsWith(PowerShellScripts.InitPS1RelativePath, StringComparison.OrdinalIgnoreCase)); 610if (!filePath.StartsWith(PackagingConstants.Folders.Lib + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase) 611&& !filePath.StartsWith(PackagingConstants.Folders.Lib + Path.AltDirectorySeparatorChar, StringComparison.OrdinalIgnoreCase))

Utility\MSBuildNuGetProjectSystemUtility.cs (3)

587if (effectivePathForContentFile.StartsWith(PackagingConstants.Folders.Content + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase)) 647if (x.StartsWith(y, StringComparison.OrdinalIgnoreCase)) 652if (y.StartsWith(x, StringComparison.OrdinalIgnoreCase))

NuGet.Packaging (30)

ContentModel\ContentItemCollection.cs (1)

51if (path.StartsWith("lib/contract", StringComparison.Ordinal))

PackageArchiveReader.cs (2)

155return GetFiles().Where(f => f.StartsWith(folder + "/", StringComparison.OrdinalIgnoreCase)); 301if (packageFileName.StartsWith("/", StringComparison.Ordinal))

PackageCreation\Authoring\PackageBuilder.cs (7)

429(f.Path.StartsWith(PackagingConstants.Folders.Content + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase) || 430f.Path.StartsWith(PackagingConstants.Folders.Tools + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase))); 440f.Path.StartsWith(PackagingConstants.Folders.Lib + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase) && 450file.Path.StartsWith(PackagingConstants.Folders.ContentFiles + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase)); 464file.Path.StartsWith(PackagingConstants.Folders.Content + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase) && 505where !string.IsNullOrEmpty(file.Path) && file.Path.StartsWith("lib", StringComparison.OrdinalIgnoreCase) 1045if ((isRecursiveWildcardSearch || isDirectorySearch) && fullPath.StartsWith(searchDirectory, StringComparison.OrdinalIgnoreCase))

PackageCreation\Utility\FrameworkNameUtility.cs (2)

21filePath.StartsWith(folderPrefix, StringComparison.OrdinalIgnoreCase)) 91filePath.StartsWith(folderPrefix, StringComparison.OrdinalIgnoreCase))

PackageExtraction\PackageHelper.cs (1)

69packageFileName.StartsWith(p, StringComparison.OrdinalIgnoreCase)) &&

PackageFileExtractor.cs (2)

34f => f.StartsWith("lib/", StringComparison.OrdinalIgnoreCase) || 35f.StartsWith("ref/", StringComparison.OrdinalIgnoreCase))

PackageFolderReader.cs (1)

98if (!file.FullName.StartsWith(_root.FullName, StringComparison.OrdinalIgnoreCase))

PackageReaderBase.cs (1)

558if (!fullPath.StartsWith(normalizedDestination, PathUtility.GetStringComparisonBasedOnOS()) || fullPath.Length == normalizedDestination.Length)

Rules\ContentFolderInPackageReferenceProjectRule.cs (2)

26.Any(t => t.StartsWith 32.Any(t => t.StartsWith

Rules\InstallScriptInPackageReferenceProjectRule.cs (1)

24t.StartsWith(PackagingConstants.Folders.Tools + Path.DirectorySeparatorChar,

Rules\InvalidPlaceholderFileRule.cs (1)

29if (builder.GetFiles().Count(f => PathUtility.EnsureTrailingSlash(Path.GetDirectoryName(f)!).StartsWith(directory, StringComparison.OrdinalIgnoreCase)) > 1)

Rules\MisplaceAssemblyOutsideLibRule.cs (1)

39if (!ValidFolders.Any(folder => file.StartsWith(folder, StringComparison.OrdinalIgnoreCase)))

Rules\MisplacedScriptFileRule.cs (1)

34if (!file.StartsWith(ToolsDirectory + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase))

Rules\MisplacedTransformFileRule.cs (2)

39if (!file.StartsWith(ContentDirectory + Path.DirectorySeparatorChar, 41&& !file.StartsWith(ContentFilesDirectory + Path.DirectorySeparatorChar,

Rules\ReferencesInNuspecMatchRefAssetsRule.cs (1)

25var refFiles = builder.GetFiles().Where(t => t.StartsWith(PackagingConstants.Folders.Ref, StringComparison.OrdinalIgnoreCase));

Rules\UpholdBuildConventionRule.cs (1)

138if (file.StartsWith(buildFolder, StringComparison.Ordinal) && file[buildFolder.Length] == '/')

Rules\WinRTNameIsObsoleteRule.cs (1)

29if (file.StartsWith(PathUtility.GetPathWithDirectorySeparator(prefix), StringComparison.OrdinalIgnoreCase))

Rules\XdtTransformsInPackageReferenceProjectRule.cs (2)

30.Where(f => f.StartsWith(ContentDirectory, StringComparison.OrdinalIgnoreCase) || f.StartsWith(ContentFilesDirectory, StringComparison.OrdinalIgnoreCase))

NuGet.ProjectModel (2)

MacroStringsUtility.cs (2)

56if (!string.IsNullOrEmpty(originalString) && !string.IsNullOrEmpty(macroValue) && originalString.StartsWith(macroValue, stringComparison)) 65if (!string.IsNullOrEmpty(originalString) && !string.IsNullOrEmpty(macroName) && originalString.StartsWith(macroName, StringComparison.Ordinal))

NuGet.Protocol (12)

HttpSource\HttpSource.cs (1)

523if (uri.StartsWith("http://", StringComparison.OrdinalIgnoreCase))

LegacyFeed\AutoCompleteResourceV2Feed.cs (1)

77.Where(item => item.StartsWith(versionPrefix, StringComparison.OrdinalIgnoreCase))

LocalRepositories\LocalAutoCompleteResource.cs (3)

74p.Identity.Id.StartsWith(searchFilter, StringComparison.OrdinalIgnoreCase)); 110.StartsWith(versionPrefix, StringComparison.OrdinalIgnoreCase) 111|| p.Identity.Version.ToFullString().StartsWith(versionPrefix, StringComparison.OrdinalIgnoreCase))

Plugins\PluginDiscoverer.cs (1)

300if (!fileInfo.Name.StartsWith("nuget-plugin-", StringComparison.Ordinal))

Plugins\PluginPackageReader.cs (1)

201return files.Where(f => f.StartsWith(folder + "/", StringComparison.OrdinalIgnoreCase));

Resources\AutoCompleteResourceV3.cs (4)

88return results?.Data?.Where(item => item != null && item.StartsWith(packageIdPrefix, StringComparison.OrdinalIgnoreCase)) 126return outputs.Where(item => item.StartsWith(packageIdPrefix, StringComparison.OrdinalIgnoreCase)); 186&& version.ToString().StartsWith(versionPrefix, StringComparison.OrdinalIgnoreCase)) 207if (version != null && version.StartsWith(versionPrefix, StringComparison.OrdinalIgnoreCase))

Utility\LocalFolderUtility.cs (1)

598if (idVersionString.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))

NuGet.Versioning (5)

FloatRange.cs (5)

139&& ((version.IsPrerelease && version.Release.StartsWith(_releasePrefix, StringComparison.OrdinalIgnoreCase)) 147&& ((version.IsPrerelease && version.Release.StartsWith(_releasePrefix, StringComparison.OrdinalIgnoreCase)) 154&& ((version.IsPrerelease && version.Release.StartsWith(_releasePrefix, StringComparison.OrdinalIgnoreCase)) 160return (version.IsPrerelease && version.Release.StartsWith(_releasePrefix, StringComparison.OrdinalIgnoreCase)) 167&& ((version.IsPrerelease && version.Release.StartsWith(_releasePrefix, StringComparison.OrdinalIgnoreCase))

PresentationBuildTasks (13)

MS\Internal\MarkupCompiler\MarkupCompiler.cs (1)

1601if (TargetPath.StartsWith(SourceFileInfo.SourcePath, StringComparison.OrdinalIgnoreCase))

MS\Internal\Tasks\CompilerWrapper.cs (1)

402if (fullFilePath.StartsWith(_sourceDir,StringComparison.OrdinalIgnoreCase))

MS\Internal\Tasks\TaskHelper.cs (1)

102if (fullpath2.StartsWith(fullpath1, StringComparison.OrdinalIgnoreCase))

src\wpf\src\Microsoft.DotNet.Wpf\src\PresentationFramework\MS\Internal\Globalization\LocalizationComments.cs (1)

354if (enumName.StartsWith(_enumPrefix, StringComparison.Ordinal))

src\wpf\src\Microsoft.DotNet.Wpf\src\PresentationFramework\System\Windows\Markup\BamlRecordWriter.cs (1)

682if (!xamlXmlnsPropertyNode.XmlNamespace.StartsWith(XamlReaderHelper.MappingProtocol, StringComparison.Ordinal))

src\wpf\src\Microsoft.DotNet.Wpf\src\PresentationFramework\System\Windows\Markup\XamlParser.cs (1)

1157if (xmlNamespace.StartsWith(XamlReaderHelper.MappingProtocol, StringComparison.Ordinal))

src\wpf\src\Microsoft.DotNet.Wpf\src\PresentationFramework\System\Windows\Markup\XamlReaderHelper.cs (6)

2210if (attribName.StartsWith(NamespacePrefix, StringComparison.Ordinal)) 2337attribName.StartsWith("xmlns:", StringComparison.Ordinal)) 2346if (attribValue.StartsWith(MappingProtocol, StringComparison.Ordinal)) 3341isDefaultAsm = objectType.Assembly.FullName.StartsWith("PresentationFramework", StringComparison.OrdinalIgnoreCase); 3370isDefaultAsm = objectType.Assembly.FullName.StartsWith("PresentationCore", StringComparison.OrdinalIgnoreCase); 6784return attribName.StartsWith("xmlns:", StringComparison.Ordinal) ||

src\wpf\src\Microsoft.DotNet.Wpf\src\Shared\MS\Internal\ResourceIDHelper.cs (1)

70if (sourcePath.StartsWith(basePath, StringComparison.OrdinalIgnoreCase))

PresentationCore (11)

MS\Internal\IO\Packaging\ByteRangeDownloader.cs (1)

778|| !contentRange.StartsWith(ByteRangeUnit, StringComparison.Ordinal))

MS\Internal\XpsLoadingContext.cs (4)

184if (authority.StartsWith("application:", StringComparison.OrdinalIgnoreCase) 185|| authority.StartsWith("siteoforigin:", StringComparison.OrdinalIgnoreCase)) 219if (authority.StartsWith("application:", StringComparison.OrdinalIgnoreCase) 220|| authority.StartsWith("siteoforigin:", StringComparison.OrdinalIgnoreCase))

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

624if(!longTag.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))

System\Windows\Media\Knowncolors.cs (2)

240if ((trimmedString.StartsWith("sc#", StringComparison.Ordinal))) 252if ((trimmedString.StartsWith(Parsers.s_ContextColor, StringComparison.OrdinalIgnoreCase)))

System\Windows\Media\Parsers.cs (2)

85if (!trimmedColor.StartsWith(s_ContextColor, StringComparison.OrdinalIgnoreCase)) 141if (!trimmedColor.StartsWith("sc#", StringComparison.Ordinal))

System\Windows\Navigation\BaseUriHelper.cs (1)

287if (assemblyInfo[i].StartsWith(VERSION, StringComparison.OrdinalIgnoreCase))

PresentationFramework (21)

MS\Internal\Globalization\LocalizationComments.cs (1)

354if (enumName.StartsWith(_enumPrefix, StringComparison.Ordinal))

MS\Internal\Interop\InternalDispatchObject.cs (1)

116if (name.StartsWith("[DISPID=", StringComparison.OrdinalIgnoreCase))

MS\Internal\Utility\BindUriHelper.cs (1)

140return uri.OriginalString.StartsWith(FRAGMENTMARKER, StringComparison.Ordinal);

System\Windows\DeferrableContent.cs (1)

38assemblyTargetsFramework2 = schemaContext.LocalAssembly.ImageRuntimeVersion.StartsWith("v2", StringComparison.Ordinal);

System\Windows\Documents\FixedSchema.cs (1)

421if (attrValue.StartsWith(_colorConvertedBitmap, StringComparison.Ordinal))

System\Windows\Documents\WpfPayload.cs (1)

700Invariant.Assert(imageSourceString.StartsWith("./", StringComparison.OrdinalIgnoreCase));

System\Windows\Documents\XamlToRtfWriter.cs (2)

2733else if (name.StartsWith("&#x", StringComparison.OrdinalIgnoreCase)) 2747else if (name.StartsWith("&#", StringComparison.OrdinalIgnoreCase))

System\Windows\FrameworkElementFactory.cs (1)

1139return !childName.StartsWith(AutoGenChildNamePrefix, StringComparison.Ordinal);

System\Windows\Markup\Baml2006\Baml2006Reader.cs (1)

2132if (xamlNs.StartsWith(XamlReaderHelper.MappingProtocol, StringComparison.Ordinal))

System\Windows\Markup\BamlMapTable.cs (3)

1569if (!ownerAsm.FullName.StartsWith("PresentationFramework", StringComparison.OrdinalIgnoreCase) && 1570!ownerAsm.FullName.StartsWith("PresentationCore", StringComparison.OrdinalIgnoreCase) && 1571!ownerAsm.FullName.StartsWith("WindowsBase", StringComparison.OrdinalIgnoreCase))

System\Windows\Markup\BamlReader.cs (2)

2648(assemblyFullName.StartsWith("PresentationFramework", StringComparison.Ordinal) 2649|| assemblyFullName.StartsWith("System.Xaml", StringComparison.Ordinal)))

System\Windows\Markup\Primitives\MarkupWriter.cs (1)

1636if (uri.StartsWith(clrUriPrefix, StringComparison.Ordinal))

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

195bool isValidNamespace = type.Namespace != null && (type.Namespace.Equals("System.Windows", StringComparison.Ordinal) || type.Namespace.StartsWith("System.Windows.", StringComparison.Ordinal));

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

3178if (xmlNamespace.StartsWith(XamlReaderHelper.MappingProtocol, StringComparison.Ordinal))

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

363if (xamlNamespace.StartsWith(XamlReaderHelper.MappingProtocol, StringComparison.Ordinal))

System\Windows\ThemeManager.cs (2)

423if (rd.MergedDictionaries[i].Source.ToString().StartsWith(FluentThemeResourceDictionaryUri, 443if (rd.MergedDictionaries[i].Source.ToString().StartsWith(FluentThemeResourceDictionaryUri,

ReachFramework (3)

PrintConfig\PrtTicket_Editor.cs (1)

153if (attr.Name.StartsWith("xmlns:", StringComparison.Ordinal) ||

Serialization\ColorTypeConverter.cs (1)

157if (colorString.StartsWith("sc#", StringComparison.Ordinal) && colorString.Contains('E'))

Serialization\Manager\ReachSerializationUtils.cs (1)

941return uri.OriginalString.StartsWith(FRAGMENTMARKER,StringComparison.Ordinal);

RepoTasks (1)

src\aspnetcore\src\Shared\CertificateGeneration\UnixCertificateManager.cs (1)

360var prettyCertDir = certDir.StartsWith(homeDirectoryWithSlash, StringComparison.Ordinal)

Roslyn.Diagnostics.Analyzers (18)

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

745if (filePath.StartsWith(oldPrefix, StringComparison.Ordinal))

src\roslyn\src\Compilers\Core\Portable\SourceGeneration\GeneratedCodeUtilities.cs (1)

66if (fileName.StartsWith("TemporaryGeneratedFile_", StringComparison.OrdinalIgnoreCase))

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (2)

372!method.Name.StartsWith("Add", StringComparison.Ordinal)) 531method.Name.StartsWith("IsNull", StringComparison.Ordinal) &&

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Options\AnalyzerOptionsExtensions.cs (1)

403if (!genericInterfaceFullName.StartsWith("T:", StringComparison.Ordinal))

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (4)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\EmbeddedLanguages\VirtualChars\AbstractVirtualCharService.cs (1)

145if (startDelimiter.Length > 0 && !tokenText.StartsWith(startDelimiter, StringComparison.Ordinal))

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

97where kvp.Key.Trim().StartsWith("dotnet_naming_rule.", StringComparison.Ordinal)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Options\Option2.cs (3)

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

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\PathMetadataUtilities.cs (1)

66if (rootNamespace is not null && @namespace.StartsWith(rootNamespace + ".", StringComparison.OrdinalIgnoreCase))

SymbolDeclaredEventMustBeGeneratedForSourceSymbols.cs (1)

156namedType.Name.StartsWith("Source", StringComparison.Ordinal) &&

Roslyn.Diagnostics.CSharp.Analyzers (10)

NumberCommentsRefactoring.cs (2)

67if (text.StartsWith(""" 76if (text.StartsWith("""

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SyntaxTriviaExtensions.cs (3)

68if (commentText.StartsWith("//", StringComparison.Ordinal)) 84if (commentText.StartsWith("/*", StringComparison.Ordinal)) 99if (trimmedLine.StartsWith("*", StringComparison.Ordinal))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\EnumMemberGenerator.cs (2)

143if (numericText.StartsWith("0x", StringComparison.OrdinalIgnoreCase)) 149else if (numericText.StartsWith("0b", StringComparison.OrdinalIgnoreCase))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\DocumentationCommentExtensions.cs (1)

20return documentationComment.ToFullString().StartsWith("/**", StringComparison.Ordinal);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\StringExtensions.cs (2)

42var unescaped = identifier.StartsWith("@", StringComparison.Ordinal) 49if (!identifier.StartsWith("@", StringComparison.Ordinal))

rzc (7)

Application.cs (1)

98if (!arg.StartsWith("@", StringComparison.Ordinal))

CommandLine\CommandLineApplication.cs (2)

152if (arg.StartsWith("--", StringComparison.Ordinal)) 156else if (arg.StartsWith("-", StringComparison.Ordinal))

CommandLine\CommandOption.cs (3)

18if (part.StartsWith("--", StringComparison.Ordinal)) 22else if (part.StartsWith("-", StringComparison.Ordinal)) 36else if (part.StartsWith("<", StringComparison.Ordinal) && part.EndsWith(">", StringComparison.Ordinal))

DefaultExtensionDependencyChecker.cs (1)

75if (_ignoredAssemblies.Any(n => reference.Name.StartsWith(n, StringComparison.Ordinal)))

sdk-tasks (1)

ExtractArchiveToDirectory.cs (1)

194if (!destinationFileName.StartsWith(fullDestDirPath, StringComparison.Ordinal))

SelectTests (16)

GraphAffectedProjects.cs (2)

574return path.StartsWith(prefix, StringComparison.OrdinalIgnoreCase); 594if (fullPath.StartsWith("/tmp/", StringComparison.Ordinal))

Program.cs (7)

306if (!relPath.StartsWith("tests/", StringComparison.Ordinal)) 942=> token.StartsWith("job:", StringComparison.Ordinal) ? token["job:".Length..] : token; 1013=> path.StartsWith("src/", StringComparison.Ordinal) ? "changed source" 1014: path.StartsWith("tests/", StringComparison.Ordinal) ? "changed test" 1018=> path.StartsWith("src/", StringComparison.Ordinal) ? "🔧" 1019: path.StartsWith("tests/", StringComparison.Ordinal) ? "🧪" 1196t => t.StartsWith("job:", StringComparison.Ordinal) ? t["job:".Length..] : t,

TestSelector.cs (5)

190target.StartsWith("test:", StringComparison.Ordinal)) 362if (file.StartsWith(prefix, StringComparison.Ordinal)) 463else if (target.StartsWith("test:", StringComparison.Ordinal)) 467else if (target.StartsWith("job:", StringComparison.Ordinal)) 474target.StartsWith("test:", StringComparison.Ordinal) ? target["test:".Length..] : target;

TriggerMap.cs (2)

86if (target.StartsWith("job:", StringComparison.Ordinal)) 101if (token.StartsWith("job:", StringComparison.Ordinal))

Stress.AppHost (1)

InteractionCommands.cs (1)

726if (tenantId.StartsWith("1", StringComparison.Ordinal))

System.ComponentModel.Annotations (3)

System\ComponentModel\DataAnnotations\UrlAttribute.cs (3)

30return valueAsString.StartsWith("http://", StringComparison.OrdinalIgnoreCase) 31|| valueAsString.StartsWith("https://", StringComparison.OrdinalIgnoreCase) 32|| valueAsString.StartsWith("ftp://", StringComparison.OrdinalIgnoreCase);

System.ComponentModel.TypeConverter (5)

System\ComponentModel\BaseNumberConverter.cs (2)

65else if (AllowHex && (text.StartsWith("0x", StringComparison.OrdinalIgnoreCase) 66|| text.StartsWith("&h", StringComparison.OrdinalIgnoreCase)))

System\ComponentModel\ComponentResourceManager.cs (1)

144if (!key.StartsWith(objectName, IgnoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal))

System\ComponentModel\CultureInfoConverter.cs (1)

116if (info != null && GetCultureName(info).StartsWith(text, StringComparison.CurrentCulture))

System\ComponentModel\SyntaxCheck.cs (1)

44return value.StartsWith("\\\\", StringComparison.Ordinal);

System.Configuration.ConfigurationManager (4)

System\Configuration\ClientConfigurationSystem.cs (2)

71(_isAppConfigHttp && configKey.StartsWith(SystemNetGroupKey, StringComparison.Ordinal)); 79return _isAppConfigHttp && configKey.StartsWith(SystemNetGroupKey, StringComparison.Ordinal);

System\Configuration\StringUtil.cs (2)

21return s1.StartsWith(s2, StringComparison.Ordinal); 27return s1.StartsWith(s2, StringComparison.OrdinalIgnoreCase);

System.Console (2)

System\TerminalFormatStrings.cs (2)

196if (term.StartsWith("xterm", StringComparison.Ordinal)) // normalize all xterms to enable easier matching 200else if (term.StartsWith("screen", StringComparison.Ordinal)) // normalize all tmux configs

System.Data.Common (24)

src\runtime\src\libraries\Common\src\System\Data\Common\AdapterUtil.cs (1)

161if (!quotedString.StartsWith(quotePrefix!, StringComparison.Ordinal))

System\Data\Common\DBCommandBuilder.cs (2)

70if (columnName.StartsWith(_originalPrefix, StringComparison.OrdinalIgnoreCase)) 77if (columnName.StartsWith(_isNullPrefix, StringComparison.OrdinalIgnoreCase))

System\Data\DataSet.cs (6)

1710if (reader.LocalName == Keywords.XSD_SCHEMA && reader.NamespaceURI.StartsWith(Keywords.XSD_NS_START, StringComparison.Ordinal)) 1754if (reader.LocalName == Keywords.XSD_SCHEMA && reader.NamespaceURI.StartsWith(Keywords.XSD_NS_START, StringComparison.Ordinal)) 2140if (reader.LocalName == Keywords.XSD_SCHEMA && reader.NamespaceURI.StartsWith(Keywords.XSD_NS_START, StringComparison.Ordinal)) 2199if (reader.LocalName == Keywords.XSD_SCHEMA && reader.NamespaceURI.StartsWith(Keywords.XSD_NS_START, StringComparison.Ordinal)) 2687if (reader.LocalName == Keywords.XSD_SCHEMA && reader.NamespaceURI.StartsWith(Keywords.XSD_NS_START, StringComparison.Ordinal)) 2763if (reader.LocalName == Keywords.XSD_SCHEMA && reader.NamespaceURI.StartsWith(Keywords.XSD_NS_START, StringComparison.Ordinal))

System\Data\DataTable.cs (4)

5830if (reader.LocalName == Keywords.XSD_SCHEMA && reader.NamespaceURI.StartsWith(Keywords.XSD_NS_START, StringComparison.Ordinal)) 5899if (reader.LocalName == Keywords.XSD_SCHEMA && reader.NamespaceURI.StartsWith(Keywords.XSD_NS_START, StringComparison.Ordinal)) 6100if (reader.LocalName == Keywords.XSD_SCHEMA && reader.NamespaceURI.StartsWith(Keywords.XSD_NS_START, StringComparison.Ordinal)) 6194if (reader.LocalName == Keywords.XSD_SCHEMA && reader.NamespaceURI.StartsWith(Keywords.XSD_NS_START, StringComparison.Ordinal))

System\Data\XmlDataLoader.cs (3)

247if (ownerNode.NamespaceURI.StartsWith("x-schema:#", StringComparison.Ordinal)) 255if (_fIsXdr && node.NamespaceURI.StartsWith("x-schema:#", StringComparison.Ordinal)) 941else if (_dataReader.LocalName.StartsWith("hidden", StringComparison.Ordinal))

System\Data\xmlsaver.cs (2)

1666if (!rel.RelationName.StartsWith(rName, StringComparison.Ordinal)) 1675if (!unique.ConstraintName.StartsWith("Constraint", StringComparison.Ordinal))

System\Data\XMLSchema.cs (3)

336if (propName.StartsWith(Keywords.MSD_FK_PREFIX, StringComparison.Ordinal)) 341if ((instance is DataRelation) && (propName.StartsWith(Keywords.MSD_REL_PREFIX, StringComparison.Ordinal))) 345else if ((instance is DataRelation) && (propName.StartsWith(Keywords.MSD_FK_PREFIX, StringComparison.Ordinal)))

System\Data\XmlToDatasetMap.cs (3)

219if (col.ColumnName.StartsWith("xml", StringComparison.OrdinalIgnoreCase)) 253if (col.ColumnName.StartsWith("xml", StringComparison.OrdinalIgnoreCase)) 506Debug.Assert(col.ColumnName.StartsWith("xml", StringComparison.OrdinalIgnoreCase), "column name should start with xml");

System.Data.Odbc (4)

Common\System\Data\Common\DbConnectionOptions.cs (2)

264if ((null != value) && value.StartsWith(DataDirectory, StringComparison.OrdinalIgnoreCase)) 311if (!ADP.GetFullPath(fullPath).StartsWith(rootFolderPath, StringComparison.Ordinal))

src\runtime\src\libraries\Common\src\System\Data\Common\AdapterUtil.cs (1)

161if (!quotedString.StartsWith(quotePrefix!, StringComparison.Ordinal))

System\Data\Odbc\OdbcParameterCollectionHelper.cs (1)

324if (lastParameter.ParameterName.StartsWith(ADP.Parameter, StringComparison.Ordinal)

System.Data.OleDb (6)

DbConnectionOptions.cs (2)

338if ((null != value) && value.StartsWith(DataDirectory, StringComparison.OrdinalIgnoreCase)) 385if (!ADP.GetFullPath(fullPath).StartsWith(rootFolderPath, StringComparison.Ordinal))

OleDbConnection.cs (2)

102if ((null != value) && !((string)value).StartsWith(DbConnectionOptions.DataDirectory, StringComparison.OrdinalIgnoreCase)) 135if ((null != value) && !((string)value).StartsWith(DbConnectionOptions.DataDirectory, StringComparison.OrdinalIgnoreCase))

OleDbConnectionString.cs (1)

431return (("msdasql" == progid) || progid.StartsWith("msdasql.", StringComparison.Ordinal) || ("microsoft ole db provider for odbc drivers" == progid));

System\Data\Common\AdapterUtil.cs (1)

1231if (!quotedString.StartsWith(quotePrefix!, StringComparison.Ordinal))

System.Diagnostics.DiagnosticSource (1)

System\Diagnostics\Metrics\AggregationManager.cs (1)

107Include(i => i.Meter.Name.StartsWith(meterNamePrefix, StringComparison.OrdinalIgnoreCase));

System.Diagnostics.Process (3)

src\runtime\src\libraries\Common\src\Interop\Linux\cgroups\Interop.cgroups.cs (2)

162if (!path.StartsWith(mount, StringComparison.Ordinal)) 310if ((commonPathPrefixLength == 1) || !cgroupPathRelativeToMount.StartsWith(hierarchyRoot, StringComparison.Ordinal))

System\Diagnostics\Process.Linux.cs (1)

298if (argString.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))

System.DirectoryServices (3)

System\DirectoryServices\DirectoryEntry.cs (2)

876if (AdsObject.ADsPath.StartsWith("WinNT:", StringComparison.Ordinal)) 989if (!results[count].StartsWith("range=", StringComparison.Ordinal))

System\DirectoryServices\PropertyValueCollection.cs (1)

43if (tempPath.StartsWith("LDAP:", StringComparison.Ordinal))

System.DirectoryServices.AccountManagement (18)

System\DirectoryServices\AccountManagement\AD\ADDNLinkedAttrSet.cs (2)

822Debug.Assert(((DirectoryEntry)foreignGroup.UnderlyingObject).Path.StartsWith("LDAP:", StringComparison.Ordinal)); 852Debug.Assert(((DirectoryEntry)foreignGroup.UnderlyingObject).Path.StartsWith("LDAP:", StringComparison.Ordinal));

System\DirectoryServices\AccountManagement\AD\SDSUtils.cs (5)

137Debug.Assert(sr.Path.StartsWith("LDAP:", StringComparison.Ordinal) || sr.Path.StartsWith("GC:", StringComparison.Ordinal)); 143if (de.Path.StartsWith("WinNT:", StringComparison.Ordinal)) 149Debug.Assert(de.Path.StartsWith("LDAP:", StringComparison.Ordinal)); 777return path.StartsWith("GC:", StringComparison.OrdinalIgnoreCase);

System\DirectoryServices\AccountManagement\AuthenticablePrincipal.cs (6)

397if (propertyName.StartsWith(PropertyNames.AcctInfoPrefix, StringComparison.Ordinal)) 405else if (propertyName.StartsWith(PropertyNames.PwdInfoPrefix, StringComparison.Ordinal)) 448if (propertyName.StartsWith(PropertyNames.AcctInfoPrefix, StringComparison.Ordinal)) 455else if (propertyName.StartsWith(PropertyNames.PwdInfoPrefix, StringComparison.Ordinal)) 489if (propertyName.StartsWith(PropertyNames.AcctInfoPrefix, StringComparison.Ordinal)) 500else if (propertyName.StartsWith(PropertyNames.PwdInfoPrefix, StringComparison.Ordinal))

System\DirectoryServices\AccountManagement\constants.cs (2)

109if (propertyName.StartsWith(PropertyNames.AcctInfoPrefix, StringComparison.Ordinal)) 113else if (propertyName.StartsWith(PropertyNames.PwdInfoPrefix, StringComparison.Ordinal))

System\DirectoryServices\AccountManagement\Context.cs (2)

1174if (entry.Path.StartsWith("LDAP:", StringComparison.Ordinal)) 1187Debug.Assert(entry.Path.StartsWith("WinNT:", StringComparison.Ordinal));

System\DirectoryServices\AccountManagement\Group.cs (1)

379if (propName.StartsWith("member;range=", StringComparison.OrdinalIgnoreCase))

System.Formats.Tar (4)

System\Formats\Tar\TarEntry.cs (3)

447if (!normalizedFile.StartsWith(logicalPrefix, pathComparison) && 468if (!normalizedCurrent.StartsWith(destPrefix, pathComparison) && 528return fullPath.StartsWith(destinationDirectoryFullPath, PathInternal.StringComparison) ? fullPath : null;

System\Formats\Tar\TarHelpers.cs (1)

429return childFullPath.StartsWith(parentFullPath, PathInternal.StringComparison);

System.IO.Compression.ZipFile (1)

System\IO\Compression\ZipFileExtensions.ZipArchiveEntry.Extract.cs (1)

205if (!fileDestinationPath.StartsWith(destinationPrefix, StringComparison.Ordinal))

System.IO.FileSystem.AccessControl (1)

src\runtime\src\libraries\Common\src\System\IO\PathInternal.Windows.cs (1)

125if (path.StartsWith(UncPathPrefix, StringComparison.OrdinalIgnoreCase))

System.IO.Packaging (6)

System\IO\Packaging\Package.cs (3)

444&& normalizedPartName.StartsWith(precedingPartName, StringComparison.Ordinal) 998&& normalizedPartName.StartsWith(precedingPartName, StringComparison.Ordinal) 1002&& followingPartName.StartsWith(normalizedPartName, StringComparison.Ordinal)

System\IO\Packaging\ZipPackage.cs (3)

508if (zipItemName.StartsWith(ContentTypeHelper.ContentTypeFileName, StringComparison.OrdinalIgnoreCase)) 517if (zipItemName.StartsWith(ForwardSlashString, StringComparison.Ordinal)) 1054if (zipFileInfo.FullName.StartsWith(ContentTypesFileUpperInvariant, StringComparison.OrdinalIgnoreCase))

System.IO.Ports (9)

System\IO\Ports\SerialPort.Unix.cs (9)

System.Management (41)

System\Management\ManagementBaseObject.cs (2)

504if (propertyName.StartsWith("__", StringComparison.Ordinal)) 825if (propertyName.StartsWith("__", StringComparison.Ordinal))

System\Management\ManagementQuery.cs (37)

System\Management\WMIGenerator.cs (2)

5042if (bitMap.StartsWith(strTemp, StringComparison.Ordinal) || bitMap.StartsWith(strTemp.ToUpperInvariant(), StringComparison.Ordinal))

System.Net.Http (7)

System\Net\Http\SocketsHttpHandler\AuthenticationHelper.Digest.cs (1)

219if (algorithm.StartsWith(Sha256, StringComparison.OrdinalIgnoreCase))

System\Net\Http\SocketsHttpHandler\HttpEnvironmentProxy.cs (6)

148if (value.StartsWith("http://", StringComparison.OrdinalIgnoreCase)) 152else if (value.StartsWith("https://", StringComparison.OrdinalIgnoreCase)) 158else if (value.StartsWith("socks4://", StringComparison.OrdinalIgnoreCase)) 163else if (value.StartsWith("socks5://", StringComparison.OrdinalIgnoreCase)) 168else if (value.StartsWith("socks5h://", StringComparison.OrdinalIgnoreCase)) 173else if (value.StartsWith("socks4a://", StringComparison.OrdinalIgnoreCase))

System.Net.HttpListener (9)

System\Net\HttpListener.cs (2)

116if (uriPrefix.StartsWith("http://", StringComparison.OrdinalIgnoreCase)) 120else if (uriPrefix.StartsWith("https://", StringComparison.OrdinalIgnoreCase))

System\Net\HttpListenerRequestUriBuilder.cs (2)

379if (uriString.StartsWith("http://", StringComparison.OrdinalIgnoreCase)) 383else if (uriString.StartsWith("https://", StringComparison.OrdinalIgnoreCase))

System\Net\Managed\HttpEndPointListener.cs (3)

201if (path.StartsWith(ppath, StringComparison.Ordinal) || pathSlash.StartsWith(ppath, StringComparison.Ordinal)) 248if (path.StartsWith(ppath, StringComparison.Ordinal))

System\Net\Managed\HttpListenerContext.Managed.cs (1)

54header.StartsWith("Basic ", StringComparison.OrdinalIgnoreCase);

System\Net\Managed\ListenerPrefix.cs (1)

101if (uri.StartsWith("https://", StringComparison.Ordinal))

System.Net.Mail (4)

System\Net\Mail\SmtpConnection.Auth.cs (4)

53if (extension.StartsWith(AuthExtension, StringComparison.OrdinalIgnoreCase)) 74else if (extension.StartsWith("dsn", StringComparison.OrdinalIgnoreCase)) 78else if (extension.StartsWith("STARTTLS", StringComparison.OrdinalIgnoreCase)) 82else if (extension.StartsWith("SMTPUTF8", StringComparison.OrdinalIgnoreCase))

System.Net.NetworkInformation (2)

System\Net\NetworkInformation\StringParsingHelpers.Addresses.cs (2)

19if (line.StartsWith(interfaceName, StringComparison.Ordinal)) 58if (line.StartsWith("00000000000000000000000000000000", StringComparison.Ordinal))

System.Net.Primitives (1)

System\Net\CookieContainer.cs (1)

756if (!requestPath.StartsWith(cookiePath, StringComparison.Ordinal))

System.Net.Requests (2)

System\Net\FtpControlStream.cs (2)

441if (entry.Command.StartsWith("SIZE ", StringComparison.Ordinal)) 445else if (entry.Command.StartsWith("MDTM ", StringComparison.Ordinal))

System.Net.Security (3)

src\runtime\src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.OpenSsl.cs (2)

629if (alg.StartsWith("rsa_pss_", StringComparison.Ordinal) && !enablePss) 634if (alg.StartsWith("rsa_pkcs1_", StringComparison.Ordinal) && !enablePkcs1)

System\Net\Security\LocalAppContextSwitches.cs (1)

55(OperatingSystem.IsLinux() && RuntimeInformation.RuntimeIdentifier.StartsWith("linux-bionic-", StringComparison.OrdinalIgnoreCase)));

System.Private.CoreLib (23)

src\runtime\src\libraries\System.Private.CoreLib\src\System\AppContextConfigHelper.cs (3)

36if (str != null && str.StartsWith("0x", StringComparison.Ordinal)) 139if (str != null && str.StartsWith("0x", StringComparison.Ordinal)) 249if (str != null && str.StartsWith("0x", StringComparison.Ordinal))

src\runtime\src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\ManifestBuilder.cs (2)

111if (value >= 0x0000100000000000UL && !name.StartsWith("Session", StringComparison.Ordinal)) 599if (etwFormat && key.StartsWith("event_", StringComparison.Ordinal))

src\runtime\src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\TraceLogging\TraceLoggingEventSource.cs (1)

748if (m_traits[i].StartsWith("ETW_", StringComparison.Ordinal))

src\runtime\src\libraries\System.Private.CoreLib\src\System\Globalization\CultureData.cs (2)

2166if (digits.StartsWith("0\uFFFF1\uFFFF2\uFFFF3\uFFFF4\uFFFF5\uFFFF6\uFFFF7\uFFFF8\uFFFF9\uFFFF", StringComparison.Ordinal) || // ICU common cases 2167digits.StartsWith("0123456789", StringComparison.Ordinal)) // NLS common cases

src\runtime\src\libraries\System.Private.CoreLib\src\System\Globalization\CultureData.Icu.cs (1)

44if (name.Length > 1 && (name[0] == '-' || name[0] == '_') && originalName.StartsWith("und", StringComparison.OrdinalIgnoreCase))

src\runtime\src\libraries\System.Private.CoreLib\src\System\Globalization\DateTimeParse.cs (1)

3809if (pmDesignator.StartsWith(amDesignator, StringComparison.Ordinal) && str.MatchSpecifiedWord(pmDesignator))

src\runtime\src\libraries\System.Private.CoreLib\src\System\Globalization\TextInfo.cs (1)

631bool isDutchCulture = cultureName.StartsWith("nl", StringComparison.OrdinalIgnoreCase) &&

src\runtime\src\libraries\System.Private.CoreLib\src\System\IO\SharedMemoryManager.Unix.cs (2)

28if (name.StartsWith("Global\\", StringComparison.Ordinal)) 36if (name.StartsWith("Local\\", StringComparison.Ordinal))

src\runtime\src\libraries\System.Private.CoreLib\src\System\Reflection\ModifiedFunctionPointerType.cs (1)

72if (type.FullName!.StartsWith(Type.CallingConventionTypePrefix, StringComparison.Ordinal))

src\runtime\src\libraries\System.Private.CoreLib\src\System\String.Comparison.cs (1)

1041return StartsWith(value, StringComparison.CurrentCulture);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Threading\NamedWaitHandleOptions.cs (2)

127incompatible = !name.StartsWith(CurrentSessionPrefix, StringComparison.Ordinal); 134incompatible = !name.StartsWith(AllSessionsPrefix, StringComparison.Ordinal);

src\runtime\src\libraries\System.Private.CoreLib\src\System\TimeZoneInfo.Unix.NonAndroid.cs (2)

254if (symlinkPath.StartsWith(timeZoneDirectory, StringComparison.Ordinal)) 332if (id.StartsWith(timeZoneDirectory, StringComparison.Ordinal))

src\runtime\src\libraries\System.Private.CoreLib\src\System\Type.cs (2)

691!fullName.StartsWith(CallingConventionTypePrefix, StringComparison.Ordinal)) 716if (typeName is not null && typeName.StartsWith(CallingConventionTypePrefix, StringComparison.Ordinal))

System\Reflection\Assembly.NativeAot.cs (1)

52&& dmi.DeclaringAssemblyName?.StartsWith(CoreLib.Name, StringComparison.Ordinal) == true)

System\Reflection\Runtime\TypeInfos\RuntimeTypeInfo.GetMember.cs (1)

41predicate = (member => member.Name.StartsWith(prefix, comparisonType));

System.Private.CoreLib.Generators (1)

NativeRuntimeEventSourceGenerator.cs (1)

382if (eventName.StartsWith(handledEvent, StringComparison.Ordinal))

System.Private.DataContractSerialization (5)

System\Runtime\Serialization\DataContract.cs (2)

631if (!typeName.StartsWith("System.", StringComparison.Ordinal)) 1723return uriString.StartsWith(Globals.DataContractXsdBaseNamespace, StringComparison.Ordinal) ? uriString.Substring(Globals.DataContractXsdBaseNamespace.Length) : uriString;

System\Runtime\Serialization\Json\JsonReaderDelegator.cs (1)

150!dateTimeValue.StartsWith(JsonGlobals.DateTimeStartGuardReader, StringComparison.Ordinal) ||

System\Runtime\Serialization\Json\XmlObjectSerializerWriteContextComplexJson.cs (1)

87else if (dataContractNamespace.StartsWith(Globals.DataContractXsdBaseNamespace, StringComparison.Ordinal))

System\Runtime\Serialization\XmlObjectSerializerReadContext.cs (1)

728if (xmlReader.NamespaceURI.StartsWith(Globals.DataContractXsdBaseNamespace, StringComparison.Ordinal))

System.Private.Uri (2)

System\Uri.cs (2)

1924if (uriString.StartsWith("https:", StringComparison.OrdinalIgnoreCase)) 1929else if (uriString.StartsWith("http:", StringComparison.OrdinalIgnoreCase))

System.Private.Xml (29)

System\Xml\BinaryXml\XmlBinaryReader.cs (1)

1932if (!prefixStr.StartsWith("xmlns", StringComparison.Ordinal))

System\Xml\Resolvers\XmlPreloadedResolver.cs (2)

System\Xml\Schema\XdrBuilder.cs (2)

551return uri.StartsWith(x_schema, StringComparison.Ordinal) && 552!uri.StartsWith("x-schema:#", StringComparison.Ordinal);

System\Xml\Schema\XmlSchemaDataType.cs (2)

246if (uri.Length > 5 && uri.StartsWith("uuid:", StringComparison.Ordinal)) 250else if (uri.Length > 9 && uri.StartsWith("urn:uuid:", StringComparison.Ordinal))

System\Xml\Serialization\Mappings.cs (1)

255if (!Name.StartsWith("xml:", StringComparison.Ordinal))

System\Xml\Serialization\SourceInfo.cs (2)

145if (Arg.StartsWith("o.@", StringComparison.Ordinal) || MemberInfo != null) 147var = ILG.GetVariable(Arg.StartsWith("o.@", StringComparison.Ordinal) ? "o" : Arg);

System\Xml\Serialization\XmlSerializationILGen.cs (1)

579if (source.StartsWith("o.@", StringComparison.Ordinal))

System\Xml\Serialization\XmlSerializationReader.cs (1)

798if (!name.StartsWith("xmlns", StringComparison.Ordinal)) return false;

System\Xml\Serialization\XmlSerializationReaderILGen.cs (4)

2818if (source.StartsWith("o.@", StringComparison.Ordinal)) 2905if (source.StartsWith("o.@", StringComparison.Ordinal)) 3069if (source.StartsWith("o.@", StringComparison.Ordinal)) 3821if (elementElseString.StartsWith("UnknownNode(", StringComparison.Ordinal))

System\Xml\Serialization\XmlSerializationWriter.cs (3)

621if (name.Length > prefixLength && name.Length <= prefixLength + MaxInt32.Length && name.StartsWith(prefix, StringComparison.Ordinal)) 1000if (localName != "xmlns" && !localName.StartsWith("xmlns:", StringComparison.Ordinal)) 1033if (localName != "xmlns" && !localName.StartsWith("xmlns:", StringComparison.Ordinal))

System\Xml\Serialization\XmlSerializationWriterILGen.cs (2)

1042System.Diagnostics.Debug.Assert(xmlnsSource.StartsWith("o.@", StringComparison.Ordinal)); 2542if (initValue.Arg.StartsWith("o.@", StringComparison.Ordinal))

System\Xml\ValidateNames.cs (1)

414s.StartsWith("xml", StringComparison.OrdinalIgnoreCase);

System\Xml\XmlException.cs (1)

92Debug.Assert(message == null || !message.StartsWith("Xml_", StringComparison.Ordinal), "Do not pass a resource here!");

System\Xml\XPath\Internal\BooleanFunctions.cs (1)

82lang.StartsWith(str, StringComparison.OrdinalIgnoreCase) &&

System\Xml\XPath\Internal\StringFunctions.cs (1)

134return s1.StartsWith(s2, StringComparison.Ordinal);

System\Xml\Xsl\Runtime\XsltFunctions.cs (2)

31return s1.StartsWith(s2, StringComparison.Ordinal); 198if (!lang.StartsWith(value, StringComparison.OrdinalIgnoreCase))

System\Xml\Xsl\XsltOld\AttributeAction.cs (1)

39if (qname.Prefix.StartsWith("xml", StringComparison.Ordinal))

System\Xml\Xsl\XsltOld\ProcessingInstructionAction.cs (1)

152if (nameLength == 3 && name.StartsWith("xml", StringComparison.OrdinalIgnoreCase))

System.Reflection.Context (2)

System\Reflection\Context\Custom\CustomType.cs (2)

205getPropertyGetter = (types == null || types.Length == 0) && name.StartsWith("get_", comparison); 208getPropertySetter = (types == null || types.Length == 1) && name.StartsWith("set_", comparison);

System.Reflection.Metadata (2)

System\Reflection\Internal\Utilities\MemoryBlock.cs (1)

379return decoded.StartsWith(text, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);

System\Reflection\Metadata\Internal\StringHeap.cs (1)

273return GetString(handle, utf8Decoder).StartsWith(value, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);

System.Reflection.MetadataLoadContext (2)

System\Reflection\TypeLoading\RuntimeTypeInfo.GetMember.cs (1)

38predicate = (member => member.Name.StartsWith(prefix, comparisonType));

System\Reflection\TypeLoading\Types\RoModifiedFunctionPointerType.cs (1)

74if (type.FullName!.StartsWith(CallingConventionTypePrefix, StringComparison.Ordinal))

System.Resources.Extensions (1)

src\runtime\src\libraries\Common\src\System\Resources\ResourceWriter.cs (1)

470if (typeName.StartsWith("ResourceTypeCode.", StringComparison.Ordinal))

System.Resources.Writer (1)

src\runtime\src\libraries\Common\src\System\Resources\ResourceWriter.cs (1)

470if (typeName.StartsWith("ResourceTypeCode.", StringComparison.Ordinal))

System.Runtime.Serialization.Schema (2)

System\Runtime\Serialization\Schema\CodeExporter.cs (1)

1547if (uriString.StartsWith(ImportGlobals.DataContractXsdBaseNamespace, StringComparison.Ordinal))

System\Runtime\Serialization\Schema\SchemaImportHelper.cs (1)

105return uriString.StartsWith(ImportGlobals.DataContractXsdBaseNamespace, StringComparison.Ordinal) ? uriString.Substring(ImportGlobals.DataContractXsdBaseNamespace.Length) : uriString;

System.Security.Cryptography.Xml (2)

System\Security\Cryptography\Xml\Utils.cs (2)

316if (idref.StartsWith("xpointer(id(", StringComparison.Ordinal)) 338if (idref.StartsWith("xpointer(id(", StringComparison.Ordinal))

System.ServiceModel.Http (3)

System\ServiceModel\Channels\HttpChannelFactory.cs (1)

727if (requestProperty.QueryString.StartsWith("?", StringComparison.Ordinal))

System\ServiceModel\Channels\HttpTransportSecurityHelpers.cs (2)

48if (!(value.StartsWith("host/", StringComparison.OrdinalIgnoreCase) || value.StartsWith("http/", StringComparison.OrdinalIgnoreCase)))

System.ServiceModel.Primitives (13)

Internals\System\Runtime\Diagnostics\DiagnosticTraceBase.cs (1)

152if (methodName.StartsWith("ThrowHelper", StringComparison.Ordinal))

Internals\System\Xml\XmlMtomReader.cs (3)

317if (startUri.StartsWith("<", StringComparison.Ordinal)) 409if (uri.StartsWith(MimeGlobals.ContentIDScheme, StringComparison.Ordinal)) 411else if (uri.StartsWith("<", StringComparison.Ordinal))

System\ServiceModel\Channels\BinaryMessageEncoder.cs (1)

814return contentType == supportedContentType || contentType.StartsWith(supportedContentType, StringComparison.OrdinalIgnoreCase);

System\ServiceModel\Channels\MessageEncoder.cs (2)

156contentType.StartsWith(supportedContentType, StringComparison.Ordinal) && 163if (contentType.StartsWith(supportedContentType, StringComparison.OrdinalIgnoreCase))

System\ServiceModel\Channels\ReliableMessagingHelpers.cs (1)

2008return (action.StartsWith(WsrmIndex.GetNamespaceString(reliableMessagingVersion), StringComparison.Ordinal));

System\ServiceModel\Description\ServiceReflector.cs (4)

41return baseUri + (path.StartsWith("/", StringComparison.Ordinal) ? path.Substring(1) : path); 45return baseUri + (path.StartsWith("/", StringComparison.Ordinal) ? path : "/" + path); 861if (!method.Name.StartsWith(BeginMethodNamePrefix, StringComparison.Ordinal) || 921if (!method.Name.StartsWith(EndMethodNamePrefix, StringComparison.Ordinal) ||

System\ServiceModel\Description\XmlSerializerOperationBehavior.cs (1)

674string key = mappingKey.StartsWith(":", StringComparison.Ordinal) ? _keyBase + mappingKey : mappingKey;

System.Speech (5)

Internal\ObjectToken\ObjectTokenCategory.cs (1)

40if (!string.IsNullOrEmpty(tokenName) && !tokenName.StartsWith("HKEY_", StringComparison.Ordinal))

Internal\SrgsCompiler\BackEnd.cs (2)

579if (arc.RuleRef.Name.StartsWith("URL:DYNAMIC#", StringComparison.Ordinal)) 592else if (arc.RuleRef.Name.StartsWith("URL:STATIC#", StringComparison.Ordinal))

Internal\SrgsParser\XmlParser.cs (1)

1845if (uri.StartsWith(_shortFilename!, StringComparison.Ordinal) && (uri.Length > _shortFilename!.Length && uri[_shortFilename.Length] == '#' || uri.Length == _shortFilename.Length))

Recognition\SrgsGrammar\SrgsRuleRef.cs (1)

191if (sUri.StartsWith("#grammar:dictation", StringComparison.Ordinal))

System.Text.Encoding.CodePages (1)

System\Text\EncodingNLS.cs (1)

362if (_encodingName.StartsWith("Globalization_cp_", StringComparison.OrdinalIgnoreCase))

System.Text.Json (2)

parent\Common\ReflectionExtensions.cs (2)

119if (!type.IsGenericType || !type.Assembly.FullName!.StartsWith("System.Collections.Immutable", StringComparison.Ordinal)) 137if (!type.IsGenericType || !type.Assembly.FullName!.StartsWith("System.Collections.Immutable", StringComparison.Ordinal))

System.Windows.Forms (3)

System\Resources\AssemblyNamesTypeResolutionService.cs (1)

164if (location.StartsWith(s_dotNetPath, StringComparison.OrdinalIgnoreCase))

System\Resources\ResXResourceWriter.cs (1)

446if ((type is null && mimeType is null) || (type is not null && type.StartsWith("System.Char", StringComparison.Ordinal)))

System\Windows\Forms\Controls\UpDown\DomainUpDown.cs (1)

303.StartsWith(text, StringComparison.Ordinal);

System.Windows.Forms.Design (20)

System\ComponentModel\Design\CollectionEditor.CollectionEditorCollectionForm.cs (1)

85&& collectionItemType.GetGenericTypeDefinition().Name.StartsWith("ControlProxy", StringComparison.Ordinal))

System\ComponentModel\Design\Serialization\CodeDomSerializerBase.cs (1)

908if (methodName.StartsWith("add_", StringComparison.Ordinal))

System\ComponentModel\Design\Serialization\ResourceCodeDomSerializer.SerializationResourceManager.cs (1)

750if (expressionName.StartsWith("Set", StringComparison.InvariantCulture))

System\Windows\Forms\Design\Behavior\DragAssistanceManager.cs (5)

224if (snapLine.Filter is not null && snapLine.Filter.StartsWith(SnapLine.Padding, StringComparison.Ordinal)) 243if ((snapLine.Filter is not null) && snapLine.Filter.StartsWith(SnapLine.Padding, StringComparison.Ordinal)) 652&& (snapLine.Filter.StartsWith(SnapLine.Margin, StringComparison.Ordinal) 653|| snapLine.Filter.StartsWith(SnapLine.Padding, StringComparison.Ordinal)); 932type = snapLine.Filter!.StartsWith(SnapLine.Margin, StringComparison.Ordinal) ? LineType.Margin : LineType.Padding;

System\Windows\Forms\Design\DesignBindingPicker.cs (1)

893&& _selectedItem.DataMember.StartsWith(dataMemberNode.DataMember, StringComparison.Ordinal))

System\Windows\Forms\Design\FormDocumentDesigner.cs (1)

204if (snapLines[i] is SnapLine snapLine && snapLine.Filter is not null && snapLine.Filter.StartsWith(SnapLine.Padding, StringComparison.Ordinal))

System\Windows\Forms\Design\StandardMenuStripVerb.cs (9)

System\Windows\Forms\Design\ToolStripDesignerUtils.cs (1)

180if (currentName.StartsWith("ToolStrip", StringComparison.Ordinal))

System.Xaml (3)

System\Xaml\MS\Impl\KnownStrings.cs (1)

94return src.StartsWith(target, StringComparison.Ordinal);

System\Xaml\Parser\MeScanner.cs (1)

244if (value.StartsWith("{}", StringComparison.OrdinalIgnoreCase))

System\Xaml\XamlObjectReader.cs (1)

1750if (name.StartsWith(KnownStrings.ReferenceName, StringComparison.Ordinal))

TestingAppHost1.AppHost (2)

TestingAppHostEntryPointProbe.cs (2)

29var argument = args.FirstOrDefault(arg => arg.StartsWith(ArgumentPrefix, StringComparison.Ordinal)); 62var argument = args.FirstOrDefault(arg => arg.StartsWith(BreakpointArgumentPrefix, StringComparison.Ordinal));

TestProject.AppHost (1)

TestProgram.cs (1)

31if (args[i].StartsWith("--skip-resources", StringComparison.InvariantCultureIgnoreCase))

TypeScriptApiCompat (8)

ApiCompatSuppression.cs (1)

62if (line.Length == 0 || line.StartsWith("#", StringComparison.Ordinal))

AtsSurfaceParser.cs (6)

29if (trimmed.StartsWith("#", StringComparison.Ordinal)) 56if (rawLine.StartsWith(" ", StringComparison.Ordinal)) 258var normalizedSymbolId = symbolId.StartsWith("enum:", StringComparison.Ordinal) 262if (normalizedSymbolId.StartsWith($"{packageName}/", StringComparison.Ordinal)) 267if (!normalizedSymbolId.StartsWith($"{packageName}.", StringComparison.Ordinal)) 284!symbolId.StartsWith(knownPackageName, StringComparison.Ordinal))

ExcludedPackageLoader.cs (1)

24if (line.Length == 0 || line.StartsWith("#", StringComparison.Ordinal))

UIAutomationClient (1)

MS\Internal\Automation\ProxyManager.cs (1)

283if (parentClassName.StartsWith("WMP9ActiveXHost", StringComparison.OrdinalIgnoreCase))

UIAutomationClientSideProviders (2)

MS\Internal\AutomationProxies\WindowsScroll.cs (2)

161if (className.StartsWith("RichEdit", StringComparison.OrdinalIgnoreCase) || 162className.StartsWith("WindowForms10.RichEdit", StringComparison.OrdinalIgnoreCase) ||

vbc (3)

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

536if (dotNetRoot != null && key.StartsWith(RuntimeHostInfo.DotNetRootEnvironmentName, Environment.EnvironmentVariableComparison))

src\roslyn\src\Compilers\Shared\NativeMethods.cs (2)

150if (s.StartsWith(@"\\?\UNC\", StringComparison.Ordinal)) 152if (s.StartsWith(@"\\?\", StringComparison.Ordinal))

VBCSCompiler (3)

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

536if (dotNetRoot != null && key.StartsWith(RuntimeHostInfo.DotNetRootEnvironmentName, Environment.EnvironmentVariableComparison))

src\roslyn\src\Compilers\Shared\NativeMethods.cs (2)

150if (s.StartsWith(@"\\?\UNC\", StringComparison.Ordinal)) 152if (s.StartsWith(@"\\?\", StringComparison.Ordinal))

vstest.console (5)

CommandLine\CommandLineOptions.cs (2)

277catch (TestSourceException ex) when (source.StartsWith("-", StringComparison.Ordinal) || source.StartsWith("/", StringComparison.Ordinal))

CommandLine\Executor.cs (2)

149var isDiag = args != null && args.Any(arg => arg.StartsWith("--diag", StringComparison.OrdinalIgnoreCase)); 523if (arg.StartsWith("@", StringComparison.Ordinal))

Processors\CLIRunSettingsArgumentProcessor.cs (1)

137if (arg.StartsWith("TestRunParameters", StringComparison.OrdinalIgnoreCase))

vstest.console.arm64 (5)

parent\vstest.console\CommandLine\CommandLineOptions.cs (2)

277catch (TestSourceException ex) when (source.StartsWith("-", StringComparison.Ordinal) || source.StartsWith("/", StringComparison.Ordinal))

parent\vstest.console\CommandLine\Executor.cs (2)

149var isDiag = args != null && args.Any(arg => arg.StartsWith("--diag", StringComparison.OrdinalIgnoreCase)); 523if (arg.StartsWith("@", StringComparison.Ordinal))

parent\vstest.console\Processors\CLIRunSettingsArgumentProcessor.cs (1)

137if (arg.StartsWith("TestRunParameters", StringComparison.OrdinalIgnoreCase))