IsNullOrWhiteSpace

2742 references to IsNullOrWhiteSpace

aspire (339)

Acquisition\PeerInstallProbe.cs (1)

147if (string.IsNullOrWhiteSpace(stdout))

Agents\AspireSkills\AspireSkillsBundleProvider.cs (13)

Agents\AspireSkills\AspireSkillsInstaller.cs (10)

70if (string.IsNullOrWhiteSpace(effectiveVersion)) 369if (string.IsNullOrWhiteSpace(metadata.Version)) 383if (string.IsNullOrWhiteSpace(metadata.Tag)) 388if (string.IsNullOrWhiteSpace(metadata.AssetName)) 393if (string.IsNullOrWhiteSpace(metadata.Sha512)) 403if (string.IsNullOrWhiteSpace(digest)) 416if (string.IsNullOrWhiteSpace(digest)) 477if (!string.IsNullOrWhiteSpace(name) && !string.IsNullOrWhiteSpace(downloadUrl)) 1139return string.IsNullOrWhiteSpace(safeName) ? $"aspire-skills-{Guid.NewGuid():N}.archive" : safeName;

Agents\AspireSkills\EmbeddedAspireSkillsBundleProvider.cs (1)

58if (metadata is null || string.IsNullOrWhiteSpace(metadata.Sha512))

Backchannel\ResourceSnapshotMapper.cs (2)

123DisplayName = string.IsNullOrWhiteSpace(c.command.DisplayName) ? null : c.command.DisplayName.Trim(), 178!string.IsNullOrWhiteSpace(waitingForPropertyString))

Caching\AppHostInfoDiskCache.cs (1)

155if (entry.ExitCode == 0 && entry.IsAspireHost && string.IsNullOrWhiteSpace(entry.RunCommand))

Certificates\CertificateGeneration\UnixCertificateManager.cs (1)

397if (string.IsNullOrWhiteSpace(dir))

Commands\AgentInitCommand.cs (4)

179if (string.IsNullOrWhiteSpace(path)) 567if (string.IsNullOrWhiteSpace(requestedSkills) || 610if (string.IsNullOrWhiteSpace(value) || 640if (string.IsNullOrWhiteSpace(description))

Commands\AgentTelemetryCommand.cs (1)

147if (!string.IsNullOrWhiteSpace(value) && isValid(value))

Commands\AppHostLauncher.cs (3)

1080if (string.IsNullOrWhiteSpace(entry.Message)) 1114if (string.IsNullOrWhiteSpace(entry.Message)) 1150if (string.IsNullOrWhiteSpace(entry.Message))

Commands\AppHostStartupTimeout.cs (1)

19if (string.IsNullOrWhiteSpace(configuredTimeout))

Commands\DcpWorkloadCleanupService.cs (2)

47if (!string.IsNullOrWhiteSpace(output)) 52if (!string.IsNullOrWhiteSpace(error))

Commands\InitCommand.cs (3)

542if (string.IsNullOrWhiteSpace(existingContent)) 679if (string.IsNullOrWhiteSpace(identityChannel)) 764if (string.IsNullOrWhiteSpace(value))

Commands\NewCommand.cs (21)

Commands\PipelineCommandBase.cs (5)

491if (string.IsNullOrWhiteSpace(aspireHostingVersion) || 1207if (!string.IsNullOrWhiteSpace(value) && !double.TryParse(value, out _)) 1233if (string.IsNullOrWhiteSpace(value)) 1294if (string.IsNullOrWhiteSpace(value)) 1312if (string.IsNullOrWhiteSpace(singleValue))

Commands\PsCommand.cs (2)

353appHostPath = string.IsNullOrWhiteSpace(v2Info.AppHostPath) ? appHostPath : v2Info.AppHostPath; 398if (string.IsNullOrWhiteSpace(sdkVersion) ||

Commands\RestoreCommand.cs (2)

211if (!string.IsNullOrWhiteSpace(config.AppHost?.Path)) 216if (!string.IsNullOrWhiteSpace(config.AppHost?.Language))

Commands\Sdk\IntegrationAssemblyNameResolver.cs (2)

28.FirstOrDefault(element => element.Name.LocalName == "AssemblyName" && !string.IsNullOrWhiteSpace(element.Value))? 32return string.IsNullOrWhiteSpace(assemblyName) ? fallbackName : assemblyName;

Commands\Sdk\SdkDumpCommand.cs (2)

119if (string.IsNullOrWhiteSpace(packageName) || string.IsNullOrWhiteSpace(packageVersion) || packageName.Contains('@'))

Commands\StopCommand.cs (4)

405var appHostVersion = string.IsNullOrWhiteSpace(appHostInfo.AspireHostingVersion) 417if (string.IsNullOrWhiteSpace(aspireHostingVersion) || 567var details = !string.IsNullOrWhiteSpace(cleanupResult.Error) 571return string.IsNullOrWhiteSpace(details)

Commands\TemplateCommand.cs (1)

31if (!string.IsNullOrWhiteSpace(parseResult.GetValue(NewCommand.s_sourceOption)))

Commands\TerminalAttachCommand.cs (1)

84if (string.IsNullOrWhiteSpace(resourceName))

Commands\UpdateCommand.cs (5)

239if (string.IsNullOrWhiteSpace(channelName)) 243channelFromConfig = !string.IsNullOrWhiteSpace(channelName); 252if (!string.IsNullOrWhiteSpace(channelName)) 309if (!string.IsNullOrWhiteSpace(identityChannel) 684if (!string.IsNullOrWhiteSpace(identityChannel)

Configuration\AspireConfigFile.cs (1)

311return string.IsNullOrWhiteSpace(Sdk?.Version) ? defaultSdkVersion : Sdk.Version;

Configuration\AspireJsonConfiguration.cs (2)

108if (string.IsNullOrWhiteSpace(json)) 172return string.IsNullOrWhiteSpace(SdkVersion) ? defaultSdkVersion : SdkVersion;

Configuration\ConfigurationService.cs (6)

37settings = string.IsNullOrWhiteSpace(existingContent) 66if (string.IsNullOrWhiteSpace(existingContent)) 192if (string.IsNullOrWhiteSpace(content)) 415if (!string.IsNullOrWhiteSpace(globalValue)) 435if (string.IsNullOrWhiteSpace(candidateValue)) 466if (string.IsNullOrWhiteSpace(content))

Documentation\ApiDocs\ApiDocsIndexService.cs (3)

424if (_indexedItems is null || string.IsNullOrWhiteSpace(scope)) 466if (_indexedItems is null || string.IsNullOrWhiteSpace(query)) 1011if (string.IsNullOrWhiteSpace(language))

Documentation\ApiDocs\ApiDocsSourceConfiguration.cs (2)

125if (string.IsNullOrWhiteSpace(markdown) || 159if (string.IsNullOrWhiteSpace(href) || !Uri.TryCreate(sitemapUrl, UriKind.Absolute, out var sitemapUri))

Documentation\ApiDocs\ApiMemberMarkdownParser.cs (3)

29if (string.IsNullOrWhiteSpace(markdown) || memberGroupsByPageUrl.Count is 0) 53if (string.IsNullOrWhiteSpace(anchor)) 132if (string.IsNullOrWhiteSpace(tail))

Documentation\ApiDocs\ApiSitemapParser.cs (1)

47if (string.IsNullOrWhiteSpace(sitemapContent))

Documentation\CachedHttpDocumentFetcher.cs (1)

33var storageKey = string.IsNullOrWhiteSpace(cacheKey) ? url : cacheKey;

Documentation\Docs\DocsIndexService.cs (2)

313if (_indexedDocuments is null or { Count: 0 } || string.IsNullOrWhiteSpace(query)) 953if (string.IsNullOrWhiteSpace(content))

Documentation\Docs\DocsSourceConfiguration.cs (1)

74if (string.IsNullOrWhiteSpace(markdown))

Documentation\Docs\LlmsTxtParser.cs (1)

128if (string.IsNullOrWhiteSpace(content))

Documentation\DocumentationCacheKey.cs (2)

28return string.IsNullOrWhiteSpace(fallback) ? fallbackStem : fallback; 39if (!string.IsNullOrWhiteSpace(segment))

Documentation\LexicalScoring.cs (1)

38if (string.IsNullOrWhiteSpace(text))

DotNet\DotNetCliRunner.cs (8)

Git\GitWorktree.cs (1)

44if (string.IsNullOrWhiteSpace(startPath))

Mcp\Tools\GetDocTool.cs (1)

61if (string.IsNullOrWhiteSpace(slug))

Mcp\Tools\SearchDocsTool.cs (1)

64if (string.IsNullOrWhiteSpace(query))

Mcp\Tools\SelectAppHostTool.cs (1)

49if (string.IsNullOrWhiteSpace(appHostPath))

Npm\NpmRunner.cs (1)

113if (string.IsNullOrWhiteSpace(filename))

NuGet\BundleNuGetPackageCache.cs (1)

205if (!string.IsNullOrWhiteSpace(error))

NuGet\BundleNuGetService.cs (2)

198if (!string.IsNullOrWhiteSpace(error)) 247if (!string.IsNullOrWhiteSpace(error))

Packaging\PackageChannel.cs (5)

317if (string.IsNullOrWhiteSpace(configuredVersion)) 322return string.IsNullOrWhiteSpace(configuredVersion) ? PinnedVersion : configuredVersion; 659.Where(packageId => !string.IsNullOrWhiteSpace(packageId)) 766.Where(id => !string.IsNullOrWhiteSpace(id)) 791if (string.IsNullOrWhiteSpace(packageFileName))

Packaging\PackageSourceOverrideMappings.cs (1)

110if (string.IsNullOrWhiteSpace(source))

Processes\ProcessTreeGracefulShutdownService.cs (2)

311if (!string.IsNullOrWhiteSpace(output)) 316if (!string.IsNullOrWhiteSpace(error))

Profiling\ProfileCaptureOptions.cs (1)

69if (string.IsNullOrWhiteSpace(outputPath))

Program.cs (1)

735var identityPackagesDirectory = string.IsNullOrWhiteSpace(packagesOverride.Value)

Projects\AppHostEnvironmentDefaults.cs (4)

117if (!string.IsNullOrWhiteSpace(value)) 132if (environmentVariables.TryGetValue(variableName, out var value) && !string.IsNullOrWhiteSpace(value)) 149if (inheritedEnvironmentVariables.TryGetValue(variableName, out var value) && !string.IsNullOrWhiteSpace(value)) 158if (!string.IsNullOrWhiteSpace(value))

Projects\AppHostInfoResolver.cs (7)

197var userSecretsId = string.IsNullOrWhiteSpace(properties.UserSecretsId) ? null : properties.UserSecretsId; 198var runCommand = string.IsNullOrWhiteSpace(properties.RunCommand) ? null : properties.RunCommand; 199var targetPath = string.IsNullOrWhiteSpace(properties.TargetPath) ? null : properties.TargetPath; 200var runWorkingDirectory = string.IsNullOrWhiteSpace(properties.RunWorkingDirectory) ? null : properties.RunWorkingDirectory; 201var runArguments = string.IsNullOrWhiteSpace(properties.RunArguments) ? null : properties.RunArguments; 202var targetFramework = string.IsNullOrWhiteSpace(properties.TargetFramework) ? null : properties.TargetFramework; 203var targetFrameworks = string.IsNullOrWhiteSpace(properties.TargetFrameworks) ? null : properties.TargetFrameworks;

Projects\AppHostServerClosureSnapshots.cs (11)

Projects\DotNetAppHostProject.cs (9)

Projects\DotNetBasedAppHostServerProject.cs (1)

359if (!string.IsNullOrWhiteSpace(packageSourceOverride) &&

Projects\GuestAppHostProject.cs (9)

Projects\GuestRuntime.cs (1)

638if (!string.IsNullOrWhiteSpace(replaced))

Projects\LanguageService.cs (2)

42if (string.IsNullOrWhiteSpace(languageId)) 123if (!string.IsNullOrWhiteSpace(explicitLanguageId))

Projects\PrebuiltAppHostServer.cs (16)

Projects\ProjectUpdater.cs (2)

771if (previousSibling is XmlCharacterData charData && string.IsNullOrWhiteSpace(charData.Data)) 806if (!string.IsNullOrWhiteSpace(charData.Data))

Projects\TypeScriptAppHostToolchainResolver.cs (2)

313string.IsNullOrWhiteSpace(packageManager)) 434return string.IsNullOrWhiteSpace(homeDirectory) ||

Scaffolding\PackageJsonMerger.cs (2)

52if (string.IsNullOrWhiteSpace(existingContent)) 186var normalizedToolchainCommand = string.IsNullOrWhiteSpace(toolchainCommand) ? "npm" : toolchainCommand;

Scaffolding\ScaffoldingService.cs (4)

89var sdkVersion = string.IsNullOrWhiteSpace(context.SdkVersion) 93if (!string.IsNullOrWhiteSpace(context.SdkVersion)) 118if (!string.IsNullOrWhiteSpace(context.SdkVersion) || 705if (!string.IsNullOrWhiteSpace(line))

src\Shared\BundleVersionLease.cs (1)

148if (string.IsNullOrWhiteSpace(versionDirectory))

src\Shared\ConsoleLogs\AnsiParser.cs (1)

76if (string.IsNullOrWhiteSpace(text))

src\Shared\ContainerRuntimeDetector.cs (1)

383if (string.IsNullOrWhiteSpace(output))

src\Shared\IConfigurationExtensions.cs (2)

124if (string.IsNullOrWhiteSpace(uri)) 154if (string.IsNullOrWhiteSpace(uris))

src\Shared\IntegrationPackageProbeManifest.cs (4)

104if (string.IsNullOrWhiteSpace(manifestPath)) 251if (!string.IsNullOrWhiteSpace(key) && seenKeys.Add(key)) 358return string.IsNullOrWhiteSpace(culture) || string.Equals(culture, "neutral", StringComparison.OrdinalIgnoreCase) 365if (string.IsNullOrWhiteSpace(value))

src\Shared\PathLookupHelper.cs (3)

22Debug.Assert(!string.IsNullOrWhiteSpace(executablePath)); 112Debug.Assert(!string.IsNullOrWhiteSpace(command)); 134Debug.Assert(!string.IsNullOrWhiteSpace(command));

src\Shared\SearchTextParser.cs (2)

137if (string.IsNullOrWhiteSpace(search)) 334if (string.IsNullOrWhiteSpace(search))

src\Shared\UserSecrets\IsolatedUserSecretsHelper.cs (2)

18if (string.IsNullOrWhiteSpace(originalUserSecretsId)) 54if (string.IsNullOrWhiteSpace(isolatedUserSecretsId))

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

122if (string.IsNullOrWhiteSpace(json))

Telemetry\InternalMicrosoftDetector.cs (24)

Telemetry\LinuxMachineInformationProvider.cs (2)

27if (string.IsNullOrWhiteSpace(userDir)) 33if (string.IsNullOrWhiteSpace(rootPath))

Telemetry\MacOSXMachineInformationProvider.cs (2)

33if (string.IsNullOrWhiteSpace(userDir)) 38if (string.IsNullOrWhiteSpace(userDir))

Telemetry\ProfilingTelemetry.cs (4)

276if (string.IsNullOrWhiteSpace(sessionId)) 286if (!string.IsNullOrWhiteSpace(activity.Id)) 292if (!string.IsNullOrWhiteSpace(activity.TraceStateString)) 725if (!string.IsNullOrWhiteSpace(traceParent) &&

Telemetry\UnixMachineInformationProvider.cs (1)

65if (string.IsNullOrWhiteSpace(value))

Templating\CliTemplateFactory.cs (1)

243if (string.IsNullOrWhiteSpace(template.LanguageId))

Templating\CliTemplateFactory.EmptyTemplate.cs (4)

17if (string.IsNullOrWhiteSpace(languageId)) 31if (string.IsNullOrWhiteSpace(projectName)) 76var aspireVersion = string.IsNullOrWhiteSpace(inputs.Version) 169var aspireVersion = string.IsNullOrWhiteSpace(templateVersion)

Templating\CliTemplateFactory.GoStarterTemplate.cs (2)

17if (string.IsNullOrWhiteSpace(projectName)) 23if (string.IsNullOrWhiteSpace(inputs.Version))

Templating\CliTemplateFactory.JavaStarterTemplate.cs (2)

17if (string.IsNullOrWhiteSpace(projectName)) 23if (string.IsNullOrWhiteSpace(inputs.Version))

Templating\CliTemplateFactory.PythonStarterTemplate.cs (2)

18if (string.IsNullOrWhiteSpace(projectName)) 24if (string.IsNullOrWhiteSpace(inputs.Version))

Templating\CliTemplateFactory.TypeScriptStarterTemplate.cs (2)

18if (string.IsNullOrWhiteSpace(projectName)) 24if (string.IsNullOrWhiteSpace(inputs.Version))

Templating\OutputPathHelper.cs (1)

23if (string.IsNullOrWhiteSpace(outputPath))

Templating\TemplateNuGetConfigService.cs (14)

Utils\CliDownloader.cs (2)

112if (string.IsNullOrWhiteSpace(fileName)) 117if (string.IsNullOrWhiteSpace(source))

Utils\CliPathHelper.cs (2)

58return string.IsNullOrWhiteSpace(configuredAspireHome) 98if (string.IsNullOrWhiteSpace(feedUrl) || length <= 0)

Utils\ConfigurationHelper.cs (2)

185if (string.IsNullOrWhiteSpace(content)) 294if (string.IsNullOrWhiteSpace(content))

Utils\DotNetToolDetection.cs (2)

29if (string.IsNullOrWhiteSpace(processPath)) 135&& !string.IsNullOrWhiteSpace(toolPackageVersion)

Utils\EnvironmentChecker\AspireVersionCheck.cs (11)

Utils\EnvironmentChecker\DcpConnectionChecker.cs (2)

58if (!string.IsNullOrWhiteSpace(kubeconfig.Token)) 424if (string.IsNullOrWhiteSpace(certificate.Thumbprint))

Utils\EnvironmentChecker\DcpConnectionHealthCheck.cs (1)

33if (string.IsNullOrWhiteSpace(dcpDirectory))

Utils\EnvironmentChecker\DcpDeveloperCertificateCache.cs (1)

16if (!certificate.IsAspNetCoreDevelopmentCertificate() || string.IsNullOrWhiteSpace(certificate.Thumbprint))

Utils\EnvironmentChecker\DcpKubeconfig.cs (1)

73if (string.IsNullOrWhiteSpace(server) || !Uri.TryCreate(server, UriKind.Absolute, out var serverUri))

Utils\EnvironmentChecker\DeprecatedWorkloadCheck.cs (2)

111if (string.IsNullOrWhiteSpace(output)) 129string.IsNullOrWhiteSpace(trimmedLine))

Utils\EnvironmentChecker\OperatingSystemCheck.cs (8)

Utils\EnvironmentChecker\VsCodeExtensionCheck.cs (1)

153if (!string.IsNullOrWhiteSpace(overrideDirectory))

Utils\EnvironmentChecker\WslEnvironmentCheck.cs (3)

128return !string.IsNullOrWhiteSpace(_environment.GetEnvironmentVariable(WslDistroNameVariable)) 129|| !string.IsNullOrWhiteSpace(_environment.GetEnvironmentVariable(WslInteropVariable)); 201if (string.IsNullOrWhiteSpace(procVersion))

Utils\Markdown\MarkdownToSpectreConverter.Markup.cs (2)

26if (string.IsNullOrWhiteSpace(markdown)) 544if (string.IsNullOrWhiteSpace(link.Url))

Utils\Markdown\MarkdownToSpectreConverter.PlainText.cs (1)

17if (string.IsNullOrWhiteSpace(markdown))

Utils\Markdown\MarkdownToSpectreConverter.Renderable.cs (1)

26if (string.IsNullOrWhiteSpace(markdown))

Utils\NpmInstallDetection.cs (3)

40if (string.IsNullOrWhiteSpace(packageName)) 61return string.IsNullOrWhiteSpace(version) ? null : version; 69return string.IsNullOrWhiteSpace(rid) ? null : rid;

Utils\StringUtils.cs (5)

50if (string.IsNullOrWhiteSpace(searchTerm) || string.IsNullOrWhiteSpace(target)) 92if (string.IsNullOrWhiteSpace(source)) 94return string.IsNullOrWhiteSpace(target) ? 0 : target.Length; 97if (string.IsNullOrWhiteSpace(target))

Utils\VersionHelper.cs (1)

47if (!hasPrHives && string.IsNullOrWhiteSpace(channelName))

aspire-managed (10)

NuGet\Commands\NuGetPackageAssetResolver.cs (2)

60var effectiveRuntimeIdentifier = string.IsNullOrWhiteSpace(runtimeIdentifier) 286if (string.IsNullOrWhiteSpace(runtimeIdentifierGraphPath))

NuGet\Commands\RestoreCommand.cs (3)

155if (!string.IsNullOrWhiteSpace(runtimeIdentifier)) 275var runtimeIdentifierGraphPath = !string.IsNullOrWhiteSpace(runtimeIdentifier) 324if (!string.IsNullOrWhiteSpace(runtimeIdentifier))

src\Shared\BundleVersionLease.cs (1)

148if (string.IsNullOrWhiteSpace(versionDirectory))

src\Shared\IntegrationPackageProbeManifest.cs (4)

Aspire.Acquisition.Tests (2)

Scripts\Common\RealGitHubPRFixture.cs (1)

46if (string.IsNullOrWhiteSpace(ghToken))

tests\Shared\TemplatesTesting\ToolCommand.cs (1)

256if (!string.IsNullOrWhiteSpace(WorkingDirectory))

Aspire.Azure.AI.Inference (1)

ChatCompletionsClientSettings.cs (1)

147if (connectionBuilder.TryGetValue("Key", out var key) && !string.IsNullOrWhiteSpace(key.ToString()))

Aspire.Azure.Messaging.EventHubs (8)

EventHubsComponent.cs (6)

93ns = string.IsNullOrWhiteSpace(settings.FullyQualifiedNamespace) 132if (!string.IsNullOrWhiteSpace(settings.ConnectionString)) 135if (string.IsNullOrWhiteSpace(settings.EventHubName)) 141if (string.IsNullOrWhiteSpace(props.EventHubName)) 152else if (!string.IsNullOrWhiteSpace(settings.FullyQualifiedNamespace) && string.IsNullOrWhiteSpace(settings.EventHubName))

EventProcessorClientComponent.cs (2)

91var consumerGroup = (string.IsNullOrWhiteSpace(settings.ConsumerGroup)) ? "default" : settings.ConsumerGroup; 101if (string.IsNullOrWhiteSpace(settings.BlobContainerName))

Aspire.Azure.Search.Documents (1)

AspireAzureSearchExtensions.cs (1)

84if (!string.IsNullOrWhiteSpace(settings.Key))

Aspire.Cli.EndToEnd.Tests (19)

DotnetToolSmokeTests.cs (1)

142if (string.IsNullOrWhiteSpace(requestedVersion))

Helpers\CliE2EAutomatorHelpers.cs (2)

257var output = string.IsNullOrWhiteSpace(outputPath) ? projectName : outputPath; 258var channelArgument = string.IsNullOrWhiteSpace(channel)

Helpers\CliE2ETestHelpers.cs (6)

322return string.IsNullOrWhiteSpace(imageName) ? null : imageName.Trim(); 468if (!string.IsNullOrWhiteSpace(standardOutput)) 518if (!string.IsNullOrWhiteSpace(standardOutput)) 721if (!string.IsNullOrWhiteSpace(pinnedVersion) && !string.IsNullOrWhiteSpace(pinnedCommit)) 825if (!string.IsNullOrWhiteSpace(token))

JavaCodegenValidationTests.cs (1)

103if (string.IsNullOrWhiteSpace(content))

SingleFileAppHostInitDotnetRunTests.cs (3)

88Assert.False(string.IsNullOrWhiteSpace(httpsProfile["applicationUrl"]?.GetValue<string>())); 91Assert.False(string.IsNullOrWhiteSpace(httpsEnv["ASPIRE_DASHBOARD_OTLP_ENDPOINT_URL"]?.GetValue<string>())); 92Assert.False(string.IsNullOrWhiteSpace(httpsEnv["ASPIRE_RESOURCE_SERVICE_ENDPOINT_URL"]?.GetValue<string>()));

StartStopTests.cs (1)

494Assert.False(string.IsNullOrWhiteSpace(appHostPath));

tests\Shared\CliInstallStrategy.cs (1)

582if (!string.IsNullOrWhiteSpace(ubuntuAptMirror))

tests\Shared\Hex1bAutomatorTestHelpers.cs (1)

185if (!string.IsNullOrWhiteSpace(line))

TypeScriptCodegenValidationTests.cs (2)

109if (string.IsNullOrWhiteSpace(content)) 213if (string.IsNullOrWhiteSpace(content))

TypeScriptLegacyAppHostTests.cs (1)

198if (string.IsNullOrWhiteSpace(content))

Aspire.Cli.Tests (14)

Agents\AspireSkillsInstallerTests.cs (1)

2277if (ArchiveBytes is null || string.IsNullOrWhiteSpace(Metadata?.Sha512))

Agents\CommonAgentApplicatorsTests.cs (1)

129Assert.False(string.IsNullOrWhiteSpace(description), $"Skill '{skill.Name}' should define a frontmatter description.");

Commands\AppHostLauncherTests.cs (1)

923Assert.False(string.IsNullOrWhiteSpace(sessionId));

Commands\DoctorCommandTests.cs (1)

1082if (osRelease.TryGetValue(key, out var rawValue) && !string.IsNullOrWhiteSpace(rawValue))

Commands\NewCommandTemplateConfigPersistenceTests.cs (1)

234Assert.All(s_prDogfoodNewTemplateExclusions, static exclusion => Assert.False(string.IsNullOrWhiteSpace(exclusion.Reason)));

Commands\RunCommandTests.cs (2)

3828var nonEmptyLines = lines.Where(l => !string.IsNullOrWhiteSpace(l)).ToArray(); 3865var nonEmptyLines = lines.Where(l => !string.IsNullOrWhiteSpace(l)).ToArray();

DotNet\DotNetCliRunnerTests.cs (5)

33if (!string.IsNullOrWhiteSpace(dotnetRoot)) 1742Assert.False(string.IsNullOrWhiteSpace(arg), $"Found empty or whitespace argument in args: [{string.Join(", ", args)}]"); 1785Assert.False(string.IsNullOrWhiteSpace(arg), $"Found empty or whitespace argument in args: [{string.Join(", ", args)}]"); 2186Assert.False(string.IsNullOrWhiteSpace(properties.GetProperty("RunCommand").GetString())); 2189Assert.True(string.IsNullOrWhiteSpace(stderr));

DotNet\ProcessExecutionTests.cs (2)

87Assert.True(string.IsNullOrWhiteSpace(stderrBuilder.ToString())); 145Assert.True(string.IsNullOrWhiteSpace(stderrBuilder.ToString()));

Aspire.Confluent.Kafka (1)

src\Vendoring\OpenTelemetry.Instrumentation.ConfluentKafka\Shared\Guard.cs (1)

97if (string.IsNullOrWhiteSpace(value))

Aspire.Dashboard (32)

Api\TelemetryApiService.cs (1)

591if (string.IsNullOrWhiteSpace(resourceName) || string.Equals(resourceName, "null", StringComparison.OrdinalIgnoreCase))

Authentication\OpenIdConnect\AuthorizationPolicyBuilderExtensions.cs (2)

27if (!string.IsNullOrWhiteSpace(claimType)) 29if (!string.IsNullOrWhiteSpace(claimValue))

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

121if (filterChanged || (searchableFieldsChanged && !string.IsNullOrWhiteSpace(FilterText))) 159if (string.IsNullOrWhiteSpace(filterText))

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

52if (_htmlChanged && !string.IsNullOrWhiteSpace(_html.Value))

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

385if (string.IsNullOrWhiteSpace(stateDescription) || string.Equals(stateDescription, stateViewModel.Text, StringComparison.Ordinal))

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

52if (string.IsNullOrWhiteSpace(_name))

Components\Dialogs\InteractionsInputDialog.razor.cs (1)

194string.IsNullOrWhiteSpace(inputModel.Value);

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

740var hasContextFilters = !string.IsNullOrWhiteSpace(filter) || typeFilter is not null || contextFilters is { Count: > 0 };

Configuration\DashboardOptions.cs (2)

359if (string.IsNullOrWhiteSpace(NameClaimType)) 369if (string.IsNullOrWhiteSpace(UsernameClaimType))

Configuration\ValidateDashboardOptions.cs (1)

133if (string.IsNullOrWhiteSpace(options.ResourceServiceClient.ApiKey))

Model\ConnectionStringParser.cs (2)

93if (string.IsNullOrWhiteSpace(connectionString)) 139if (string.IsNullOrWhiteSpace(connectionString))

Model\DashboardCommandExecutor.cs (1)

90if (!string.IsNullOrWhiteSpace(command.ConfirmationMessage))

Model\Otlp\FilterDialogFormModel.cs (1)

55else if (string.IsNullOrWhiteSpace(Value))

Model\Otlp\SpanWaterfallViewModel.cs (1)

76if (string.IsNullOrWhiteSpace(filter))

Model\ResourceIconHelpers.cs (1)

18if (!string.IsNullOrWhiteSpace(resource.IconName))

Model\ResourceViewModel.cs (2)

513if (!string.IsNullOrWhiteSpace(Description)) 518if (!string.IsNullOrWhiteSpace(ExceptionText))

Model\StructuredLogsViewModel.cs (1)

139if (!string.IsNullOrWhiteSpace(filterText))

Model\TelemetryImportService.cs (1)

110if (string.IsNullOrWhiteSpace(jsonContent))

Model\TextVisualizerViewModel.cs (1)

273if (string.IsNullOrWhiteSpace(input))

Otlp\Storage\TelemetryRepository.cs (1)

649var hasFilterText = !string.IsNullOrWhiteSpace(context.TraceNameFilterText);

src\Shared\ConsoleLogs\AnsiParser.cs (1)

76if (string.IsNullOrWhiteSpace(text))

src\Shared\IConfigurationExtensions.cs (2)

124if (string.IsNullOrWhiteSpace(uri)) 154if (string.IsNullOrWhiteSpace(uris))

src\Shared\SearchTextParser.cs (2)

137if (string.IsNullOrWhiteSpace(search)) 334if (string.IsNullOrWhiteSpace(search))

Terminal\TerminalWebSocketProxy.cs (2)

133if (string.IsNullOrWhiteSpace(resourceName)) 142if (!string.IsNullOrWhiteSpace(replicaText) &&

Aspire.Dashboard.Components.Tests (1)

Controls\LogViewerTests.cs (1)

443Assert.False(string.IsNullOrWhiteSpace(color), $"Expected resource prefix style to set --resource-text-color so LogViewer.razor.css can resolve color: var(--resource-text-color). Style: {style}");

Aspire.Dashboard.Tests (1)

VersionHelpersTests.cs (1)

20Assert.False(string.IsNullOrWhiteSpace(version), "Version should not be null or empty");

Aspire.Deployment.EndToEnd.Tests (4)

AppServiceReactDeploymentTests.cs (1)

450var error = string.IsNullOrWhiteSpace(standardError) ? standardOutput : standardError;

AppServiceStoragePrivateEndpointDeploymentTests.cs (1)

423var error = string.IsNullOrWhiteSpace(standardError) ? standardOutput : standardError;

tests\Shared\CliInstallStrategy.cs (1)

582if (!string.IsNullOrWhiteSpace(ubuntuAptMirror))

tests\Shared\Hex1bAutomatorTestHelpers.cs (1)

185if (!string.IsNullOrWhiteSpace(line))

Aspire.EndToEnd.Tests (1)

tests\Shared\TemplatesTesting\ToolCommand.cs (1)

256if (!string.IsNullOrWhiteSpace(WorkingDirectory))

Aspire.Hosting (71)

ApplicationModel\CommandsConfigurationExtensions.cs (1)

388if (result.Data is not null || string.IsNullOrWhiteSpace(output))

ApplicationModel\ExecutableLaunchRecipe.cs (2)

209public string Command { get; } = !string.IsNullOrWhiteSpace(command) 914launchProfile is not null && !string.IsNullOrWhiteSpace(launchProfile.CommandLineArgs)

ApplicationModel\ProcessCommandSpec.cs (1)

25public string ExecutablePath { get; } = !string.IsNullOrWhiteSpace(executablePath)

ApplicationModel\ProjectResource.cs (2)

234if (!string.IsNullOrWhiteSpace(output)) 260if (string.IsNullOrWhiteSpace(workingDir))

ApplicationModel\RequiredCommandValidator.cs (1)

56if (string.IsNullOrWhiteSpace(command))

ApplicationModel\ResourceNotificationService.cs (6)

600.Where(static dependencyName => !string.IsNullOrWhiteSpace(dependencyName)) 890if (_logger.IsEnabled(LogLevel.Debug) && newState.State?.Text is { Length: > 0 } newStateText && !string.IsNullOrWhiteSpace(newStateText)) 893if (!string.IsNullOrWhiteSpace(previousStateText) && !string.Equals(previousStateText, newStateText, StringComparison.OrdinalIgnoreCase)) 898else if (string.IsNullOrWhiteSpace(previousStateText)) 991if (!string.IsNullOrWhiteSpace(newState) && !string.Equals(previousState, newState, StringComparison.Ordinal)) 1364.Where(static dependencyName => !string.IsNullOrWhiteSpace(dependencyName))

Ats\AspireValueAttribute.cs (1)

31public string CatalogName { get; } = !string.IsNullOrWhiteSpace(catalogName)

Dashboard\DashboardEventHandlers.cs (2)

373if (string.IsNullOrWhiteSpace(dashboardUrls)) 733if (string.IsNullOrWhiteSpace(endpointUrl))

Dashboard\DashboardOptions.cs (1)

59return string.IsNullOrWhiteSpace(value) ? null : value;

Dashboard\ResourceServiceOptions.cs (1)

50if (string.IsNullOrWhiteSpace(options.ApiKey))

Dcp\DcpHost.cs (6)

220if (string.IsNullOrWhiteSpace(thumbprint)) 280if (!string.IsNullOrWhiteSpace(_dcpOptions.LogFileNameSuffix)) 309if (!string.IsNullOrWhiteSpace(_dcpTlsCertThumbprint)) 314if (!string.IsNullOrWhiteSpace(_dcpTlsCertFile) && !string.IsNullOrWhiteSpace(_dcpTlsKeyFile)) 406if (!string.IsNullOrWhiteSpace(value))

Dcp\DcpLogParser.cs (2)

186if (!string.IsNullOrWhiteSpace(textPart)) 204if (!string.IsNullOrWhiteSpace(value))

Dcp\DcpNameGenerator.cs (2)

166=> (string.IsNullOrWhiteSpace(localSuffix), string.IsNullOrWhiteSpace(globalSuffix)) switch

Dcp\DcpOptions.cs (6)

151if (executionContext.IsRunMode && string.IsNullOrWhiteSpace(options.CliPath)) 156if (executionContext.IsRunMode && string.IsNullOrWhiteSpace(options.DashboardPath)) 202if (!string.IsNullOrWhiteSpace(dcpPublisherConfiguration[nameof(options.CliPath)])) 211else if (!string.IsNullOrWhiteSpace(configDcpPath)) 224if (!string.IsNullOrWhiteSpace(dcpPublisherConfiguration[nameof(options.DashboardPath)])) 229else if (!string.IsNullOrWhiteSpace(configDashboardPath))

Dcp\Model\ModelCommon.cs (3)

93if (!found || string.IsNullOrWhiteSpace(annotationValue)) 113if (annotations.TryGetValue(annotationName, out var annotationVal) && !string.IsNullOrWhiteSpace(annotationVal)) 233if (string.IsNullOrWhiteSpace(candidate))

DeveloperCertificateService.cs (1)

211if (!certificate.IsAspNetCoreDevelopmentCertificate() || string.IsNullOrWhiteSpace(certificate.Thumbprint))

DistributedApplicationBuilder.cs (4)

405if (string.IsNullOrWhiteSpace(aspireDir)) 876return string.IsNullOrWhiteSpace(configuredUserSecretsId) ? assemblyUserSecretsId : configuredUserSecretsId; 886if (!string.IsNullOrWhiteSpace(configuredUserSecretsId) && isDevelopment) 899if (string.IsNullOrWhiteSpace(userSecretsId))

IInteractionService.cs (1)

290internal string EffectiveLabel => string.IsNullOrWhiteSpace(Label) ? Name : Label;

Lifecycle\TerminalHostEventingSubscriber.cs (1)

133if (string.IsNullOrWhiteSpace(raw))

Pipelines\DistributedApplicationPipeline.cs (2)

687if (string.IsNullOrWhiteSpace(stepName)) 1208if (!string.IsNullOrWhiteSpace(step.Description))

Pipelines\Internal\FileDeploymentStateManager.cs (1)

71if (string.IsNullOrWhiteSpace(aspireHome))

Pipelines\PipelineOutputService.cs (1)

53if (!string.IsNullOrWhiteSpace(appHostDirectory))

Publishing\ContainerRuntimeBase.cs (3)

421if (!string.IsNullOrWhiteSpace(error)) 465if (!string.IsNullOrWhiteSpace(output)) 472if (!string.IsNullOrWhiteSpace(error))

Publishing\PodmanContainerRuntime.cs (3)

45if (!string.IsNullOrWhiteSpace(output)) 52if (!string.IsNullOrWhiteSpace(error)) 89if (string.IsNullOrWhiteSpace(allText))

ResourceBuilderExtensions.cs (7)

3369if (string.IsNullOrWhiteSpace(executablePath)) 3404if (string.IsNullOrWhiteSpace(name)) 3434if (string.IsNullOrWhiteSpace(name)) 3813commandOptions.Method = !string.IsNullOrWhiteSpace(exportOptions.MethodName) ? new HttpMethod(exportOptions.MethodName) : null; 3841if (!string.IsNullOrWhiteSpace(requestData.MethodName)) 3848request.Content = !string.IsNullOrWhiteSpace(requestData.ContentType) 3852else if (!string.IsNullOrWhiteSpace(requestData.ContentType))

src\Shared\ConsoleLogs\AnsiParser.cs (1)

76if (string.IsNullOrWhiteSpace(text))

src\Shared\ContainerRuntimeDetector.cs (1)

383if (string.IsNullOrWhiteSpace(output))

src\Shared\IConfigurationExtensions.cs (2)

124if (string.IsNullOrWhiteSpace(uri)) 154if (string.IsNullOrWhiteSpace(uris))

src\Shared\PathLookupHelper.cs (3)

22Debug.Assert(!string.IsNullOrWhiteSpace(executablePath)); 112Debug.Assert(!string.IsNullOrWhiteSpace(command)); 134Debug.Assert(!string.IsNullOrWhiteSpace(command));

TerminalResourceBuilderExtensions.cs (1)

252if (!string.IsNullOrWhiteSpace(hostLogLevel))

UserSecrets\UserSecretsManagerFactory.cs (1)

61if (string.IsNullOrWhiteSpace(userSecretsId))

Utils\DotnetSdkUtils.cs (1)

33if (!string.IsNullOrWhiteSpace(data))

Aspire.Hosting.Azure (44)

AzureProvisioningController.cs (26)

AzureProvisioningFailureDetails.cs (2)

193.Where(static location => !string.IsNullOrWhiteSpace(location)) 556if (string.IsNullOrWhiteSpace(content))

Provisioning\Internal\BaseProvisioningContextProvider.cs (1)

64if (string.IsNullOrWhiteSpace(name) || name.Length > 90)

Provisioning\Internal\DefaultArmClientProvider.cs (3)

194.Where(static location => !string.IsNullOrWhiteSpace(location)) 246if (string.IsNullOrWhiteSpace(vaultResourceId.SubscriptionId)) 486if (!string.IsNullOrWhiteSpace(providerValue))

Provisioning\Internal\PublishModeProvisioningContextProvider.cs (1)

45if (!string.IsNullOrWhiteSpace(_options.ResourceGroupPrefix))

Provisioning\Internal\RunModeProvisioningContextProvider.cs (7)

50if (!string.IsNullOrWhiteSpace(_options.ResourceGroupPrefix)) 160if (!string.IsNullOrWhiteSpace(options.SubscriptionId)) 165if (!string.IsNullOrWhiteSpace(options.ResourceGroup)) 170if (!string.IsNullOrWhiteSpace(options.Location)) 175_options.TenantId = string.IsNullOrWhiteSpace(options.TenantId) ? null : options.TenantId; 293if (!string.IsNullOrWhiteSpace(tenantInput.Value) && !Guid.TryParse(tenantInput.Value, out _)) 300if (!string.IsNullOrWhiteSpace(subscriptionInput.Value) && !Guid.TryParse(subscriptionInput.Value, out _))

Provisioning\Provisioners\BicepProvisioner.cs (1)

458if (!string.IsNullOrWhiteSpace(locationOverride))

src\Shared\PathLookupHelper.cs (3)

22Debug.Assert(!string.IsNullOrWhiteSpace(executablePath)); 112Debug.Assert(!string.IsNullOrWhiteSpace(command)); 134Debug.Assert(!string.IsNullOrWhiteSpace(command));

Aspire.Hosting.Azure.AppService (2)

AppSvcUrls.cs (1)

23if (!string.IsNullOrWhiteSpace(deploymentSlot))

AzureAppServiceWebSiteResource.cs (1)

120if (string.IsNullOrWhiteSpace(deploymentSlot))

Aspire.Hosting.Azure.ContainerRegistry (1)

AzureContainerRegistryExtensions.cs (1)

198if (!string.IsNullOrWhiteSpace(taskName))

Aspire.Hosting.Azure.Kubernetes (3)

src\Shared\PathLookupHelper.cs (3)

22Debug.Assert(!string.IsNullOrWhiteSpace(executablePath)); 112Debug.Assert(!string.IsNullOrWhiteSpace(command)); 134Debug.Assert(!string.IsNullOrWhiteSpace(command));

Aspire.Hosting.Azure.Tests (2)

AzureEnvironmentResourceExtensionsTests.cs (2)

997Assert.False(string.IsNullOrWhiteSpace(property.DisplayName)); 4253Assert.False(string.IsNullOrWhiteSpace(property.DisplayName));

Aspire.Hosting.Blazor (1)

BlazorHostedExtensions.cs (1)

245if (string.IsNullOrWhiteSpace(result.StandardOutput))

Aspire.Hosting.Browsers (23)

BrowserConfiguration.cs (3)

55if (string.IsNullOrWhiteSpace(resolvedBrowser)) 60if (resolvedProfile is not null && string.IsNullOrWhiteSpace(resolvedProfile)) 118if (string.IsNullOrWhiteSpace(value))

BrowserConnectionDiagnosticsLogger.cs (1)

45var message = string.IsNullOrWhiteSpace(current.Message)

BrowserEndpointDiscovery.cs (2)

96string.IsNullOrWhiteSpace(metadata.Endpoint) || 251if (string.IsNullOrWhiteSpace(path))

BrowserLogsArtifacts.cs (1)

98if (string.IsNullOrWhiteSpace(appHostKey))

BrowserLogsCdpConnection.cs (1)

503if (!string.IsNullOrWhiteSpace(result.CloseStatusDescription))

BrowserLogsCdpProtocol.cs (1)

313var message = string.IsNullOrWhiteSpace(error.Message)

BrowserLogsConfigurationManager.cs (6)

216!string.IsNullOrWhiteSpace(browser)) 247if (!string.IsNullOrWhiteSpace(profile) && !options.ContainsKey(profile)) 258if (!string.IsNullOrWhiteSpace(profile.DisplayName) && 276if (string.IsNullOrWhiteSpace(browser.Value)) 291!string.IsNullOrWhiteSpace(profile.Value) && 471var profile = string.IsNullOrWhiteSpace(profileValue) ||

BrowserPageSession.cs (2)

313if (!string.IsNullOrWhiteSpace(preferredTarget?.TargetId)) 323!string.IsNullOrWhiteSpace(targetInfo.TargetId))

BrowserUserDataPathResolver.cs (1)

103if (string.IsNullOrWhiteSpace(configuration.AppHostKey))

ChromiumDevToolsActivePortParser.cs (2)

15if (string.IsNullOrWhiteSpace(activePortFileContents)) 33if (string.IsNullOrWhiteSpace(browserPathLine))

src\Shared\PathLookupHelper.cs (3)

22Debug.Assert(!string.IsNullOrWhiteSpace(executablePath)); 112Debug.Assert(!string.IsNullOrWhiteSpace(command)); 134Debug.Assert(!string.IsNullOrWhiteSpace(command));

Aspire.Hosting.Browsers.Tests (23)

src\Aspire.Hosting.Browsers\BrowserConfiguration.cs (3)

55if (string.IsNullOrWhiteSpace(resolvedBrowser)) 60if (resolvedProfile is not null && string.IsNullOrWhiteSpace(resolvedProfile)) 118if (string.IsNullOrWhiteSpace(value))

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

45var message = string.IsNullOrWhiteSpace(current.Message)

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

96string.IsNullOrWhiteSpace(metadata.Endpoint) || 251if (string.IsNullOrWhiteSpace(path))

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

98if (string.IsNullOrWhiteSpace(appHostKey))

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

503if (!string.IsNullOrWhiteSpace(result.CloseStatusDescription))

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

313var message = string.IsNullOrWhiteSpace(error.Message)

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

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

313if (!string.IsNullOrWhiteSpace(preferredTarget?.TargetId)) 323!string.IsNullOrWhiteSpace(targetInfo.TargetId))

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

103if (string.IsNullOrWhiteSpace(configuration.AppHostKey))

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

15if (string.IsNullOrWhiteSpace(activePortFileContents)) 33if (string.IsNullOrWhiteSpace(browserPathLine))

src\Shared\PathLookupHelper.cs (3)

22Debug.Assert(!string.IsNullOrWhiteSpace(executablePath)); 112Debug.Assert(!string.IsNullOrWhiteSpace(command)); 134Debug.Assert(!string.IsNullOrWhiteSpace(command));

Aspire.Hosting.CodeGeneration.Go (1)

AtsGoCodeGenerator.cs (1)

2211if (string.IsNullOrWhiteSpace(name))

Aspire.Hosting.CodeGeneration.Java (5)

AtsJavaCodeGenerator.cs (5)

144if (string.IsNullOrWhiteSpace(trimmed) || trimmed.StartsWith("//", StringComparison.Ordinal)) 186else if (pendingLines.Count > 0 && string.IsNullOrWhiteSpace(trimmed)) 220if (string.IsNullOrWhiteSpace(trimmedLine)) 829if (!string.IsNullOrWhiteSpace(valueInfo.Description)) 2682if (string.IsNullOrWhiteSpace(name))

Aspire.Hosting.CodeGeneration.Python (1)

AtsPythonCodeGenerator.cs (1)

895if (!string.IsNullOrWhiteSpace(valueInfo.Description))

Aspire.Hosting.CodeGeneration.Rust (2)

AtsRustCodeGenerator.cs (2)

309if (!string.IsNullOrWhiteSpace(valueInfo.Description)) 1150if (string.IsNullOrWhiteSpace(name))

Aspire.Hosting.CodeGeneration.TypeScript (7)

AtsTypeScriptCodeGenerator.cs (7)

482.Where(static p => !string.IsNullOrWhiteSpace(p.Summary)) 485if (!string.IsNullOrWhiteSpace(optionsParameterName)) 503var capability = getter is not null && (getter.Documentation is not null || !string.IsNullOrWhiteSpace(getter.Description) || getter.IsObsolete) 539lines.Add(string.IsNullOrWhiteSpace(obsoleteMessage) 565if (string.IsNullOrWhiteSpace(text)) 601if (string.IsNullOrWhiteSpace(text)) 656if (!string.IsNullOrWhiteSpace(label))

Aspire.Hosting.DevTunnels (6)

DevTunnelCli.cs (6)

27if (string.IsNullOrWhiteSpace(filePath)) 311if (string.IsNullOrWhiteSpace(a)) 362if (string.IsNullOrWhiteSpace(a)) 473if (!string.IsNullOrWhiteSpace(v)) 485var tokens = values.Where(l => !string.IsNullOrWhiteSpace(l)); 487if (!string.IsNullOrWhiteSpace(joined))

Aspire.Hosting.Docker (5)

EnvFile.cs (2)

104if (!string.IsNullOrWhiteSpace(entry.Comment)) 138if (!string.IsNullOrWhiteSpace(entry.Comment))

src\Shared\PathLookupHelper.cs (3)

22Debug.Assert(!string.IsNullOrWhiteSpace(executablePath)); 112Debug.Assert(!string.IsNullOrWhiteSpace(command)); 134Debug.Assert(!string.IsNullOrWhiteSpace(command));

Aspire.Hosting.Dotnet (2)

DotnetProjectHostingExtensions.cs (1)

197return launchProfile is not null && !string.IsNullOrWhiteSpace(launchProfile.CommandLineArgs)

DotnetProjectResource.cs (1)

134if (!string.IsNullOrWhiteSpace(selectedStepName) &&

Aspire.Hosting.EntityFrameworkCore (3)

EFCoreOperationExecutor.cs (1)

313: string.IsNullOrWhiteSpace(startResult.Message) ? "dotnet-ef command failed" : startResult.Message

EFMigrationResourceBuilderExtensions.cs (1)

353if (!string.IsNullOrWhiteSpace(configured))

EFResourceBuilderExtensions.cs (1)

526Message = string.IsNullOrWhiteSpace(errorMessage)

Aspire.Hosting.Foundry (1)

HostedAgent\HostedAgentBuilderExtension.cs (1)

339if (string.IsNullOrWhiteSpace(message.Value))

Aspire.Hosting.GitHub.Models (2)

src\Shared\IConfigurationExtensions.cs (2)

124if (string.IsNullOrWhiteSpace(uri)) 154if (string.IsNullOrWhiteSpace(uris))

Aspire.Hosting.Java (5)

JavaHostingExtensions.cs (4)

1912if (manifest.TryGetValue("Start-Class", out var startClass) && !string.IsNullOrWhiteSpace(startClass)) 1917if (!manifest.TryGetValue("Main-Class", out var entryPoint) || string.IsNullOrWhiteSpace(entryPoint)) 2041return string.IsNullOrWhiteSpace(artifactId) ? null : artifactId.Trim(); 2121return manifest.TryGetValue("Main-Class", out var mainClass) && !string.IsNullOrWhiteSpace(mainClass)

JavaVersionDetector.cs (1)

421if (string.IsNullOrWhiteSpace(value))

Aspire.Hosting.JavaScript (2)

JavaScriptHostingExtensions.cs (2)

1303var runCommand = string.IsNullOrWhiteSpace(publishMode.RunScriptArguments) 2627if (string.IsNullOrWhiteSpace(versionString))

Aspire.Hosting.Kubernetes (10)

Deployment\HelmVersionValidator.cs (1)

119if (string.IsNullOrWhiteSpace(output))

KubernetesEnvironmentResource.cs (1)

990if (!string.IsNullOrWhiteSpace(storageClass))

KubernetesPublishingContext.cs (4)

385if (string.IsNullOrWhiteSpace(templatedItem.Metadata.Name)) 440if (!string.IsNullOrWhiteSpace(name)) 450if (!string.IsNullOrWhiteSpace(version)) 460if (!string.IsNullOrWhiteSpace(description))

KubernetesResource.cs (4)

780return string.IsNullOrWhiteSpace(rawPort) 789_ when !string.IsNullOrWhiteSpace(port.Expression) 795return string.IsNullOrWhiteSpace(portValue) 1008if (string.IsNullOrWhiteSpace(Expression))

Aspire.Hosting.Maui (14)

MauiAndroidExtensions.cs (2)

177if (!string.IsNullOrWhiteSpace(deviceId)) 382if (!string.IsNullOrWhiteSpace(emulatorId))

MauiiOSExtensions.cs (4)

191if (!string.IsNullOrWhiteSpace(deviceId)) 221if (!string.IsNullOrWhiteSpace(deviceId)) 394if (!string.IsNullOrWhiteSpace(simulatorId)) 423if (!string.IsNullOrWhiteSpace(simulatorId))

MauiOtlpExtensions.cs (3)

165if (string.IsNullOrWhiteSpace(configuredGrpcUrl) && string.IsNullOrWhiteSpace(configuredHttpUrl)) 170return !string.IsNullOrWhiteSpace(configuredGrpcUrl)

src\Shared\IConfigurationExtensions.cs (2)

124if (string.IsNullOrWhiteSpace(uri)) 154if (string.IsNullOrWhiteSpace(uris))

Utilities\ProjectFileReader.cs (3)

79if (process.ExitCode != 0 || string.IsNullOrWhiteSpace(output)) 96if (string.IsNullOrWhiteSpace(targetFrameworksValue) && 102if (string.IsNullOrWhiteSpace(targetFrameworksValue))

Aspire.Hosting.Maui.Tests (1)

MauiPlatformExtensionsTests.cs (1)

662Assert.False(string.IsNullOrWhiteSpace(endpointValue));

Aspire.Hosting.OpenAI (3)

OpenAIHealthCheck.cs (1)

59var client = string.IsNullOrWhiteSpace(_httpClientName)

src\Shared\IConfigurationExtensions.cs (2)

124if (string.IsNullOrWhiteSpace(uri)) 154if (string.IsNullOrWhiteSpace(uris))

Aspire.Hosting.PostgreSQL (1)

PostgresBuilderExtensions.cs (1)

715if (string.IsNullOrWhiteSpace(tag))

Aspire.Hosting.Python (3)

PythonAppResourceBuilderExtensions.cs (1)

1257if (string.IsNullOrWhiteSpace(pathVariable))

PythonVersionDetector.cs (2)

24if (!string.IsNullOrWhiteSpace(version)) 91if (string.IsNullOrWhiteSpace(output))

Aspire.Hosting.Radius (10)

Annotations\RadiusRecipeParametersAnnotation.cs (1)

68if (string.IsNullOrWhiteSpace(key))

Publishing\RadCredentialRegisterStep.cs (1)

359if (secretFlags.Contains(args[i]) && !string.IsNullOrWhiteSpace(args[i + 1]))

Publishing\SealedSecretApplyStep.cs (5)

213if (!string.IsNullOrWhiteSpace(@namespace)) 252if (!string.IsNullOrWhiteSpace(kubeContext)) 400string.IsNullOrWhiteSpace(condition.Message) ? "the Sealed Secrets controller reported Synced=False" : condition.Message); 812if (!string.IsNullOrWhiteSpace(overrideContext)) 817if (!string.IsNullOrWhiteSpace(parsedContext))

Secrets\RadiusSecretStoreType.cs (1)

102if (string.IsNullOrWhiteSpace(encoding))

Secrets\SealedSecretManifest.cs (2)

213if (string.IsNullOrWhiteSpace(name)) 221var namespaceWasExplicit = !string.IsNullOrWhiteSpace(ns);

Aspire.Hosting.RemoteHost (30)

AssemblyLoader.cs (7)

44string.IsNullOrWhiteSpace(libsPath) ? "<none>" : libsPath, 45string.IsNullOrWhiteSpace(probeManifestPath) ? "<none>" : probeManifestPath); 131if (!string.IsNullOrWhiteSpace(name) && seen.Add(name)) 154if (string.IsNullOrWhiteSpace(directory) || !Directory.Exists(directory)) 182if (string.IsNullOrWhiteSpace(assemblyName)) 251if (string.IsNullOrWhiteSpace(integrationLibsPath) || !Directory.Exists(integrationLibsPath)) 325if (!string.IsNullOrWhiteSpace(integrationLibsPath) && Directory.Exists(integrationLibsPath))

AtsCapabilityScanner.cs (12)

1410if (string.IsNullOrWhiteSpace(pathSegment) || !(IsAsciiLetter(pathSegment[0]) || pathSegment[0] == '_')) 1988if (string.IsNullOrWhiteSpace(rawId)) 3549return string.IsNullOrWhiteSpace(parameter?.Description) 3638if (string.IsNullOrWhiteSpace(cref)) 3647builder.Append(string.IsNullOrWhiteSpace(fallbackText) ? cref : fallbackText); 3653if (!string.IsNullOrWhiteSpace(explicitText)) 3722if (!string.IsNullOrWhiteSpace(langword)) 3729if (!string.IsNullOrWhiteSpace(explicitText)) 3736if (!string.IsNullOrWhiteSpace(cref)) 3751if (!string.IsNullOrWhiteSpace(term)) 3754if (!string.IsNullOrWhiteSpace(description)) 3779if (string.IsNullOrWhiteSpace(text))

AtsContextFilter.cs (3)

44var normalizedAssemblyNames = new HashSet<string>(assemblyNames.Where(static name => !string.IsNullOrWhiteSpace(name)), StringComparer.OrdinalIgnoreCase); 288if (!string.IsNullOrWhiteSpace(assemblyName)) 308if (string.IsNullOrWhiteSpace(diagnostic.Location))

CodeGeneration\CodeGenerationDiagnostic.cs (2)

299if (!string.IsNullOrWhiteSpace(informational)) 321if (string.IsNullOrWhiteSpace(message))

CodeGeneration\CodeGenerationService.cs (1)

247if (!string.IsNullOrWhiteSpace(assemblyName))

Diagnostics\RemoteHostProfilingTelemetry.cs (1)

497.Where(name => !string.IsNullOrWhiteSpace(name))

src\Shared\IntegrationPackageProbeManifest.cs (4)

Aspire.Hosting.RemoteHost.Tests (5)

CodeGenerationDiagnosticBuilderTests.cs (5)

38Assert.False(string.IsNullOrWhiteSpace(diagnostic.RemediationHint)); 39Assert.False(string.IsNullOrWhiteSpace(localRpc.Message)); 54Assert.False(string.IsNullOrWhiteSpace(localRpc.Message)); 69Assert.False(string.IsNullOrWhiteSpace(diagnostic.MemberName)); 109Assert.False(string.IsNullOrWhiteSpace(diagnostic.RuntimeAspireHostingVersion));

Aspire.Hosting.Rust (1)

CargoMetadataReader.cs (1)

151if (string.IsNullOrWhiteSpace(standardError))

Aspire.Hosting.SqlServer (3)

SqlServerBuilderExtensions.cs (3)

295if (!string.IsNullOrWhiteSpace(batch)) 306if (!string.IsNullOrWhiteSpace(line)) 317if (!string.IsNullOrWhiteSpace(batch))

Aspire.Hosting.Tasks (7)

CommandPathResolver.cs (2)

16if (string.IsNullOrWhiteSpace(path)) 47if (string.IsNullOrWhiteSpace(path))

ResolveAspireCliBundle.cs (3)

94if (!string.IsNullOrWhiteSpace(AspireCliBundlePath)) 110if (!string.IsNullOrWhiteSpace(AspireCliPath)) 461return string.IsNullOrWhiteSpace(aspireHome)

ResolveAspireCliInvocation.cs (1)

68if (!string.IsNullOrWhiteSpace(AspireCliPath))

RunAspireCliCommand.cs (1)

67if (string.IsNullOrWhiteSpace(FileName))

Aspire.Hosting.Tests (28)

Dcp\DcpExecutorTests.cs (26)

InteractionServiceTests.cs (1)

815Assert.True(collection.Names.All(name => !string.IsNullOrWhiteSpace(name)));

UserSecretsParameterDefaultTests.cs (1)

394if (!string.IsNullOrWhiteSpace(json))

Aspire.Hosting.Yarp (1)

ConfigurationBuilder\YarpCluster.cs (1)

298if (!string.IsNullOrWhiteSpace(config.Version))

Aspire.Microsoft.Data.SqlClient (1)

src\Components\Common\ConnectionStringValidation.cs (1)

10if (string.IsNullOrWhiteSpace(connectionString) && !isEfDesignTime)

Aspire.Microsoft.EntityFrameworkCore.SqlServer (1)

src\Components\Common\ConnectionStringValidation.cs (1)

10if (string.IsNullOrWhiteSpace(connectionString) && !isEfDesignTime)

Aspire.MongoDB.Driver (4)

AspireMongoDBDriverExtensions.cs (3)

126if (string.IsNullOrWhiteSpace(connectionString)) 133if (string.IsNullOrWhiteSpace(mongoUrl.DatabaseName)) 164if (settings.DisableHealthChecks || string.IsNullOrWhiteSpace(settings.ConnectionString))

src\Components\Common\ConnectionStringValidation.cs (1)

10if (string.IsNullOrWhiteSpace(connectionString) && !isEfDesignTime)

Aspire.MongoDB.EntityFrameworkCore (1)

src\Components\Common\ConnectionStringValidation.cs (1)

10if (string.IsNullOrWhiteSpace(connectionString) && !isEfDesignTime)

Aspire.MySqlConnector (1)

src\Components\Common\ConnectionStringValidation.cs (1)

10if (string.IsNullOrWhiteSpace(connectionString) && !isEfDesignTime)

Aspire.Npgsql (1)

src\Components\Common\ConnectionStringValidation.cs (1)

10if (string.IsNullOrWhiteSpace(connectionString) && !isEfDesignTime)

Aspire.Npgsql.EntityFrameworkCore.PostgreSQL (1)

src\Components\Common\ConnectionStringValidation.cs (1)

10if (string.IsNullOrWhiteSpace(connectionString) && !isEfDesignTime)

Aspire.Oracle.EntityFrameworkCore (1)

src\Components\Common\ConnectionStringValidation.cs (1)

10if (string.IsNullOrWhiteSpace(connectionString) && !isEfDesignTime)

Aspire.Playground.Tests (3)

src\Shared\PathLookupHelper.cs (3)

22Debug.Assert(!string.IsNullOrWhiteSpace(executablePath)); 112Debug.Assert(!string.IsNullOrWhiteSpace(command)); 134Debug.Assert(!string.IsNullOrWhiteSpace(command));

Aspire.Pomelo.EntityFrameworkCore.MySql (1)

src\Components\Common\ConnectionStringValidation.cs (1)

10if (string.IsNullOrWhiteSpace(connectionString) && !isEfDesignTime)

Aspire.StackExchange.Redis (2)

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

167if (string.IsNullOrWhiteSpace(stringValue))

src\Vendoring\OpenTelemetry.Instrumentation.StackExchangeRedis\StackExchangeRedisConnectionInstrumentation.cs (1)

74Name = string.IsNullOrWhiteSpace(name) ? "OpenTelemetry.Redis" : $"OpenTelemetry.Redis{{{name}}}",

Aspire.Templates.Tests (1)

tests\Shared\TemplatesTesting\ToolCommand.cs (1)

256if (!string.IsNullOrWhiteSpace(WorkingDirectory))

Aspire.TerminalHost (1)

TerminalHostApp.cs (1)

423if (string.IsNullOrWhiteSpace(value))

Aspire.TestTools (9)

GitHubCli.cs (3)

216if (!string.IsNullOrWhiteSpace(fixtureDirectory)) 286var message = string.IsNullOrWhiteSpace(stderr) ? stdout : stderr; 374if (string.IsNullOrWhiteSpace(fixtureDirectory))

TrxReader.cs (6)

60.Where(static testDefinition => !string.IsNullOrWhiteSpace(testDefinition.Id)) 67if (string.IsNullOrWhiteSpace(unitTestResult.TestName) || string.IsNullOrWhiteSpace(unitTestResult.Outcome)) 94if (string.IsNullOrWhiteSpace(filePath)) 157if (!string.IsNullOrWhiteSpace(unitTestResult.TestId) 238new[] { ErrorMessage, StackTrace }.Where(static value => !string.IsNullOrWhiteSpace(value)));

Aspire.TestUtilities (3)

src\Shared\PathLookupHelper.cs (3)

22Debug.Assert(!string.IsNullOrWhiteSpace(executablePath)); 112Debug.Assert(!string.IsNullOrWhiteSpace(command)); 134Debug.Assert(!string.IsNullOrWhiteSpace(command));

AspireJavaScript.ServiceDefaults (1)

Extensions.cs (1)

72var useOtlpExporter = !string.IsNullOrWhiteSpace(builder.Configuration["OTEL_EXPORTER_OTLP_ENDPOINT"]);

AspireWithMaui.MauiServiceDefaults (1)

Extensions.cs (1)

119var useOtlpExporter = !string.IsNullOrWhiteSpace(builder.Configuration["OTEL_EXPORTER_OTLP_ENDPOINT"]);

AspireWithMaui.ServiceDefaults (1)

Extensions.cs (1)

82var useOtlpExporter = !string.IsNullOrWhiteSpace(builder.Configuration["OTEL_EXPORTER_OTLP_ENDPOINT"]);

AspireWithNode.ServiceDefaults (1)

Extensions.cs (1)

72var useOtlpExporter = !string.IsNullOrWhiteSpace(builder.Configuration["OTEL_EXPORTER_OTLP_ENDPOINT"]);

blazor-gateway (1)

BlazorGateway.cs (1)

149var useOtlpExporter = !string.IsNullOrWhiteSpace(builder.Configuration["OTEL_EXPORTER_OTLP_ENDPOINT"]);

crossgen2 (1)

Program.cs (1)

440if (string.IsNullOrWhiteSpace(rtrHeaderSymbolName))

csc (2)

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

73Debug.Assert(!string.IsNullOrWhiteSpace(CompilerHash), "A hash value is required to communicate with the server"); 85Debug.Assert(!string.IsNullOrWhiteSpace(compilerHash), "CompilerHash is required to send request to the build server");

CSharpSyntaxGenerator (2)

SourceWriter.cs (2)

1905foreach (var line in lines.Where(l => !string.IsNullOrWhiteSpace(l))) 1923foreach (string line in lines.Where(l => !string.IsNullOrWhiteSpace(l)))

datacollector (3)

src\vstest\src\Microsoft.TestPlatform.Execution.Shared\DebuggerBreakpoint.cs (3)

28if (string.IsNullOrWhiteSpace(environmentVariable)) 122if (string.IsNullOrWhiteSpace(environmentVariable)) 148if (string.IsNullOrWhiteSpace(environmentVariable))

datacollector.arm64 (3)

src\vstest\src\Microsoft.TestPlatform.Execution.Shared\DebuggerBreakpoint.cs (3)

28if (string.IsNullOrWhiteSpace(environmentVariable)) 122if (string.IsNullOrWhiteSpace(environmentVariable)) 148if (string.IsNullOrWhiteSpace(environmentVariable))

dotnet (129)

CommandFactory\CommandResolution\LocalToolsCommandResolver.cs (3)

26if (arguments == null || string.IsNullOrWhiteSpace(arguments.CommandName)) 44if (arguments == null || string.IsNullOrWhiteSpace(arguments.CommandName)) 50string.IsNullOrWhiteSpace(arguments.CommandName.Substring(LeadingDotnetPrefix.Length)))

Commands\New\DotnetCommandCallbacks.cs (2)

22if (!string.IsNullOrWhiteSpace(version)) 59if (!string.IsNullOrWhiteSpace(solutionFolder))

Commands\New\MSBuildEvaluation\CapabilityExpressionEvaluator.cs (1)

56if (string.IsNullOrWhiteSpace(expression))

Commands\New\MSBuildEvaluation\MSBuildEvaluator.cs (3)

132if (!IsSdkStyleProject || string.IsNullOrWhiteSpace(targetFramework) && targetFrameworks == null) 148if (!string.IsNullOrWhiteSpace(targetFramework)) 216if (!string.IsNullOrWhiteSpace(tfm))

Commands\New\MSBuildEvaluation\ProjectCapabilityConstraint.cs (3)

67if (string.IsNullOrWhiteSpace(args)) 89if (string.IsNullOrWhiteSpace(configuredCapability)) 181if (!string.IsNullOrWhiteSpace(capability.EvaluatedInclude))

Commands\New\NewCommandParser.cs (1)

127string preferredLang = string.IsNullOrWhiteSpace(preferredLangEnvVar) ? "C#" : preferredLangEnvVar;

Commands\New\PostActions\DotnetAddPostActionProcessor.cs (1)

158if (string.IsNullOrWhiteSpace(version))

Commands\New\PostActions\DotnetSlnPostActionProcessor.cs (1)

118if (!string.IsNullOrWhiteSpace(solutionFolder) && inRoot is true)

Commands\Project\Convert\ProjectConvertCommand.cs (2)

620string pathToValidate = string.IsNullOrWhiteSpace(path) ? defaultValue : Path.GetFullPath(path); 631targetDirectory = string.IsNullOrWhiteSpace(answer) ? defaultValue : Path.GetFullPath(answer);

Commands\Run\Api\RunApiCommand.cs (1)

27if (string.IsNullOrWhiteSpace(line))

Commands\Run\CSharpCompilerCommand.cs (1)

350Debug.Assert(!string.IsNullOrWhiteSpace(result));

Commands\Run\RunCommand.cs (7)

257if (!string.IsNullOrWhiteSpace(Device)) 268bool hasFramework = globalProperties.TryGetValue("TargetFramework", out var existingFramework) && !string.IsNullOrWhiteSpace(existingFramework); 269bool hasDevice = globalProperties.TryGetValue("Device", out var preSpecifiedDevice) && !string.IsNullOrWhiteSpace(preSpecifiedDevice); 347if (globalProperties.TryGetValue("TargetFramework", out var existingFramework) && !string.IsNullOrWhiteSpace(existingFramework)) 602if (string.IsNullOrWhiteSpace(project.GetPropertyValue("TargetFramework")) && string.IsNullOrEmpty(project.GetPropertyValue("TargetFrameworks"))) 706if (string.IsNullOrWhiteSpace(projectFileOrDirectoryPath)) 866if (!string.IsNullOrWhiteSpace(launchProfile))

Commands\Run\RunCommandSelector.cs (8)

126if (_globalProperties.TryGetValue("TargetFramework", out var existingFramework) && !string.IsNullOrWhiteSpace(existingFramework)) 140if (string.IsNullOrWhiteSpace(targetFrameworks)) 478if (!string.IsNullOrWhiteSpace(device.Description)) 483if (!string.IsNullOrWhiteSpace(device.Type)) 486if (!string.IsNullOrWhiteSpace(device.Status)) 492else if (!string.IsNullOrWhiteSpace(device.Status)) 538if (!string.IsNullOrWhiteSpace(device.Description)) 562if (!string.IsNullOrWhiteSpace(d.Description))

Commands\Solution\Add\SolutionAddCommand.cs (1)

37return !string.IsNullOrWhiteSpace(relativePath)

Commands\Test\MTP\MicrosoftTestingPlatformTestCommand.cs (2)

62&& (buildOptions.ListDevices || !string.IsNullOrWhiteSpace(buildOptions.Device))) 88if (!string.IsNullOrWhiteSpace(buildOptions.Device))

Commands\Test\MTP\SolutionAndProjectUtility.cs (2)

429if (!string.IsNullOrWhiteSpace(buildOptions.Device)) 439if (globalProperties.TryGetValue("Device", out var deviceProp) && !string.IsNullOrWhiteSpace(deviceProp))

Commands\Test\MTP\Terminal\AnsiCodes.cs (2)

131=> string.IsNullOrWhiteSpace(s) ? s ?? string.Empty : $"{CSI}{(int)color}{SetColor}{s}{SetDefaultColor}"; 134=> string.IsNullOrWhiteSpace(s) ? s ?? string.Empty : $"{CSI}{SetBold}{s}{SetDefaultColor}";

Commands\Test\MTP\Terminal\AnsiTerminal.cs (2)

170if (string.IsNullOrWhiteSpace(path)) 178bool linkToFile = !string.IsNullOrWhiteSpace(extension) && KnownFileExtensions.Contains(extension);

Commands\Test\MTP\Terminal\SimpleTerminalBase.cs (1)

135if (!String.IsNullOrWhiteSpace(activeTest?.Text))

Commands\Test\MTP\Terminal\TerminalTestReporter.cs (14)

Commands\Test\MTP\TestApplication.cs (1)

813string.IsNullOrWhiteSpace(protocolVersions))

Commands\Test\MTP\TestApplicationHandler.cs (3)

51string failureMessage = handshakeMessage.Properties.TryGetValue(HandshakeMessagePropertyNames.SupportedProtocolVersions, out string? supportedProtocolVersions) && !string.IsNullOrWhiteSpace(supportedProtocolVersions) 202if (handshakeMessage.Properties.TryGetValue(propertyId, out value) && !string.IsNullOrWhiteSpace(value)) 217if (string.IsNullOrWhiteSpace(value))

Commands\Test\VSTest\TestCommand.cs (1)

452if (string.IsNullOrWhiteSpace(parameter))

Commands\Test\VSTest\VSTestArgumentConverter.cs (4)

426if (!string.IsNullOrWhiteSpace(_legacyBlame)) 445if (!string.IsNullOrWhiteSpace(_collectCrashDumpType)) 454if (!string.IsNullOrWhiteSpace(_collectHangDumpType)) 459if (!string.IsNullOrWhiteSpace(_collectHangDumpTimeout))

Commands\Test\VSTest\VSTestForwardingApp.cs (1)

33if (!string.IsNullOrWhiteSpace(vsTestConsolePath))

Commands\Tool\Common\ToolManifestFinderExtensions.cs (1)

20if (!string.IsNullOrWhiteSpace(explicitManifestFile))

Commands\Tool\Install\LocalToolsResolverCacheExtensions.cs (1)

29if (string.IsNullOrWhiteSpace(targetFrameworkToInstall))

Commands\Tool\Install\ToolInstallCommand.cs (2)

41if (_global || !string.IsNullOrWhiteSpace(_toolPath)) 47if (!string.IsNullOrWhiteSpace(_framework))

Commands\Tool\Install\ToolInstallLocalCommand.cs (1)

211return string.IsNullOrWhiteSpace(_explicitManifestFile)

Commands\Tool\List\ToolListGlobalOrToolPathCommand.cs (2)

32if (!string.IsNullOrWhiteSpace(packageIdArgument)) 38if (!string.IsNullOrWhiteSpace(toolPathOption))

Commands\Tool\List\ToolListLocalCommand.cs (1)

35PackageId? packageId = string.IsNullOrWhiteSpace(packageIdArgument) ? null : new(packageIdArgument);

Commands\Tool\Restore\ToolRestoreCommand.cs (1)

228if (string.IsNullOrWhiteSpace(message))

Commands\Tool\Search\SearchResultPrinter.cs (2)

66if (!string.IsNullOrWhiteSpace(p.Summary)) 71if (!string.IsNullOrWhiteSpace(p.Description))

Commands\Tool\Search\ToolSearchCommand.cs (1)

48if (string.IsNullOrWhiteSpace(valueFromParser))

Commands\Tool\Uninstall\ToolUninstallCommand.cs (1)

40if (_global || !string.IsNullOrWhiteSpace(_toolPath))

Commands\Tool\Uninstall\ToolUninstallGlobalOrToolPathCommand.cs (1)

36if (!string.IsNullOrWhiteSpace(toolPath))

Commands\Tool\Update\ToolUpdateCommand.cs (2)

48DirectoryPath? location = string.IsNullOrWhiteSpace(_toolPath) ? null : new DirectoryPath(_toolPath); 134if (_global || !string.IsNullOrWhiteSpace(_toolPath))

Commands\Workload\Config\WorkloadConfigCommand.cs (1)

55shouldUseWorkloadSets ??= string.IsNullOrWhiteSpace(globalJsonVersion) ? null : true;

Commands\Workload\Install\WorkloadInstallCommand.cs (5)

81_packageSourceLocation, RestoreActionConfiguration, elevationRequired: !_printDownloadLinkOnly && string.IsNullOrWhiteSpace(_downloadToCacheOption)); 125bool usedRollback = !string.IsNullOrWhiteSpace(_fromRollbackDefinition); 147else if (!string.IsNullOrWhiteSpace(_downloadToCacheOption)) 236DirectoryPath? offlineCache = string.IsNullOrWhiteSpace(_fromCacheOption) ? null : new DirectoryPath(_fromCacheOption); 241if (string.IsNullOrWhiteSpace(_fromRollbackDefinition) &&

Commands\Workload\Install\WorkloadInstallerFactory.cs (1)

31dotnetDir = string.IsNullOrWhiteSpace(dotnetDir) ? Path.GetDirectoryName(Environment.ProcessPath) : dotnetDir;

Commands\Workload\InstallingWorkloadCommand.cs (5)

52protected bool UseRollback => !string.IsNullOrWhiteSpace(_fromRollbackDefinition); 55protected bool SpecifiedWorkloadSetVersionInGlobalJson => !string.IsNullOrWhiteSpace(_workloadSetVersionFromGlobalJson); 197if (FromHistory && !string.IsNullOrWhiteSpace(_WorkloadHistoryRecord.WorkloadSetVersion)) 264if (string.IsNullOrWhiteSpace(resolvedWorkloadSetVersion) && !UseRollback && !FromHistory) 309if (UseRollback || FromHistory && string.IsNullOrWhiteSpace(_WorkloadHistoryRecord.WorkloadSetVersion))

Commands\Workload\Update\WorkloadUpdateCommand.cs (5)

52_historyManifestOnlyOption = !string.IsNullOrWhiteSpace(parseResult.GetValue(updateDef.HistoryManifestOnlyOption)); 60elevationRequired: !_printDownloadLinkOnly && !_printRollbackDefinitionOnly && string.IsNullOrWhiteSpace(_downloadToCacheOption)); 80if (!string.IsNullOrWhiteSpace(_downloadToCacheOption)) 107string.IsNullOrWhiteSpace(_fromCacheOption) ? 152DirectoryPath? offlineCache = string.IsNullOrWhiteSpace(_fromCacheOption) ? null : new DirectoryPath(_fromCacheOption);

Commands\Workload\WorkloadCommandBase.cs (2)

112TempDirectoryPath = !string.IsNullOrWhiteSpace(tempDirPath) 114: Definition.TempDirOption != null && !string.IsNullOrWhiteSpace(parseResult.GetValue(Definition.TempDirOption))

Commands\Workload\WorkloadInfoHelper.cs (2)

53string.IsNullOrWhiteSpace(_targetSdkVersion) 127if (!string.IsNullOrWhiteSpace(_targetSdkVersion))

Commands\Workload\WorkloadInstallDetector.cs (1)

36dotnetDir = string.IsNullOrWhiteSpace(dotnetDir) ? Path.GetDirectoryName(Environment.ProcessPath) : dotnetDir;

Extensions\ProjectInstanceExtensions.cs (3)

34.Where(p => !string.IsNullOrWhiteSpace(p)) 41if (string.IsNullOrWhiteSpace(foundConfig)) 48.Where(c => !string.IsNullOrWhiteSpace(c))

Extensions\ProjectRootElementExtensions.cs (1)

19.LastOrDefault(g => !string.IsNullOrWhiteSpace(g));

NugetPackageDownloader\NuGetPackageDownloader.cs (7)

457if (string.IsNullOrWhiteSpace(source)) 545if (string.IsNullOrWhiteSpace(source)) 591if (string.IsNullOrWhiteSpace(additionalSource)) 646if (string.IsNullOrWhiteSpace(packageIdentifier)) 732if (string.IsNullOrWhiteSpace(packageIdentifier)) 826if (string.IsNullOrWhiteSpace(packageIdentifier)) 910if (string.IsNullOrWhiteSpace(packageIdentifier))

NugetSearch\NugetToolSearchApiRequest.cs (1)

55if (!string.IsNullOrWhiteSpace(searchTerm))

ShellShim\ZshDetector.cs (1)

19if (string.IsNullOrWhiteSpace(environmentVariable))

SlnFileFactory.cs (1)

24if (string.IsNullOrWhiteSpace(slnFileOrDirectory) || slnFileOrDirectory.IndexOfAny(Path.GetInvalidPathChars()) != -1)

src\sdk\artifacts\.packages\microsoft.codeanalysis.buildclient\5.11.0-1.26424.106\contentFiles\cs\net11.0\BuildProtocol.cs (2)

SudoEnvironmentDirectoryOverride.cs (1)

28if (!string.IsNullOrWhiteSpace(Environment.GetEnvironmentVariable("SUDO_UID")))

Telemetry\TelemetryClient.cs (2)

130if (!string.IsNullOrWhiteSpace(s_diskLogPath)) 310if (string.IsNullOrWhiteSpace(s_diskLogPath))

ToolManifest\ToolManifestFinder.cs (1)

179if (!string.IsNullOrWhiteSpace(environmentVariableValue))

ToolPackage\ToolConfiguration.cs (2)

18if (string.IsNullOrWhiteSpace(commandName)) 23if (string.IsNullOrWhiteSpace(toolAssemblyEntryPoint) && ridSpecificPackages?.Any() != true)

ToolPackage\ToolConfigurationDeserializer.cs (1)

115if (string.IsNullOrWhiteSpace(dotNetCliTool.Version))

dotnet-aot (28)

src\sdk\src\Cli\dotnet\CommandFactory\CommandResolution\LocalToolsCommandResolver.cs (3)

src\sdk\src\Cli\dotnet\Commands\Run\AotRunCommand.cs (1)

270return !string.IsNullOrWhiteSpace(runtimeVersion);

src\sdk\src\Cli\dotnet\Commands\Test\VSTest\VSTestForwardingApp.cs (1)

33if (!string.IsNullOrWhiteSpace(vsTestConsolePath))

src\sdk\src\Cli\dotnet\Commands\Tool\Common\ToolManifestFinderExtensions.cs (1)

20if (!string.IsNullOrWhiteSpace(explicitManifestFile))

src\sdk\src\Cli\dotnet\Commands\Tool\List\ToolListLocalCommand.cs (1)

35PackageId? packageId = string.IsNullOrWhiteSpace(packageIdArgument) ? null : new(packageIdArgument);

src\sdk\src\Cli\dotnet\Commands\Tool\Search\SearchResultPrinter.cs (2)

66if (!string.IsNullOrWhiteSpace(p.Summary)) 71if (!string.IsNullOrWhiteSpace(p.Description))

src\sdk\src\Cli\dotnet\Commands\Tool\Search\ToolSearchCommand.cs (1)

48if (string.IsNullOrWhiteSpace(valueFromParser))

src\sdk\src\Cli\dotnet\Commands\Workload\WorkloadInfoHelper.cs (1)

53string.IsNullOrWhiteSpace(_targetSdkVersion)

src\sdk\src\Cli\dotnet\Commands\Workload\WorkloadInstallDetector.cs (1)

36dotnetDir = string.IsNullOrWhiteSpace(dotnetDir) ? Path.GetDirectoryName(Environment.ProcessPath) : dotnetDir;

src\sdk\src\Cli\dotnet\Extensions\ProjectInstanceExtensions.cs (3)

34.Where(p => !string.IsNullOrWhiteSpace(p)) 41if (string.IsNullOrWhiteSpace(foundConfig)) 48.Where(c => !string.IsNullOrWhiteSpace(c))

src\sdk\src\Cli\dotnet\NugetPackageDownloader\NuGetPackageDownloader.cs (7)

src\sdk\src\Cli\dotnet\NugetSearch\NugetToolSearchApiRequest.cs (1)

55if (!string.IsNullOrWhiteSpace(searchTerm))

src\sdk\src\Cli\dotnet\ShellShim\ZshDetector.cs (1)

19if (string.IsNullOrWhiteSpace(environmentVariable))

src\sdk\src\Cli\dotnet\SlnFileFactory.cs (1)

24if (string.IsNullOrWhiteSpace(slnFileOrDirectory) || slnFileOrDirectory.IndexOfAny(Path.GetInvalidPathChars()) != -1)

src\sdk\src\Cli\dotnet\Telemetry\TelemetryClient.cs (2)

130if (!string.IsNullOrWhiteSpace(s_diskLogPath)) 310if (string.IsNullOrWhiteSpace(s_diskLogPath))

src\sdk\src\Cli\dotnet\ToolManifest\ToolManifestFinder.cs (1)

179if (!string.IsNullOrWhiteSpace(environmentVariableValue))

dotnet-dev-certs (1)

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

374if (string.IsNullOrWhiteSpace(dir))

dotnet-format (1)

CodeFormatter.cs (1)

102if (exitCode == 0 && !string.IsNullOrWhiteSpace(formatOptions.ReportPath))

dotnet-suggest (5)

FileSuggestionRegistration.cs (3)

19if (!string.IsNullOrWhiteSpace(registrationsConfigurationFilePath)) 26if (!string.IsNullOrWhiteSpace(testDirectoryOverride)) 82if (!string.IsNullOrWhiteSpace(line))

SuggestionStore.cs (2)

15if (string.IsNullOrWhiteSpace(exeFileName)) 20if (string.IsNullOrWhiteSpace(suggestionTargetArguments))

dotnet-svcutil-lib (65)

CmdCredentialsProvider.cs (1)

28while (string.IsNullOrWhiteSpace(username))

CodeDomFixup\CodeDomHelpers.cs (1)

247return !String.IsNullOrWhiteSpace(name) &&

CodeDomFixup\VisitorFixup.cs (1)

82if (string.IsNullOrWhiteSpace(language))

CodeSerializer.cs (7)

135if (string.IsNullOrWhiteSpace(fileName)) 144if (!string.IsNullOrWhiteSpace(fileName) && fileName.IndexOfAny(Path.GetInvalidFileNameChars()) == -1) 151if (string.IsNullOrWhiteSpace(fileName)) 158if (!string.IsNullOrWhiteSpace(fileName) && fileName.IndexOfAny(Path.GetInvalidFileNameChars()) == -1) 165if (string.IsNullOrWhiteSpace(fileName)) 174if (!string.IsNullOrWhiteSpace(fileName) && fileName.IndexOfAny(Path.GetInvalidFileNameChars()) == -1) 181if (string.IsNullOrWhiteSpace(fileName))

CommandLineParser.cs (3)

79if (string.IsNullOrWhiteSpace(other)) 133if (string.IsNullOrWhiteSpace(arg)) 167if (string.IsNullOrWhiteSpace(argValue) || !IsArgumentValue(argValue))

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

623if (!String.IsNullOrWhiteSpace(coreAssemblyFileName))

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

597if (!String.IsNullOrWhiteSpace(coreAssemblyFileName))

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

307if (string.IsNullOrWhiteSpace(asnString))

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

241if (!(requested == null ? string.IsNullOrWhiteSpace(obtained) : requested.Equals(obtained, StringComparison.OrdinalIgnoreCase)))

MarkupTelemetryHelper.cs (2)

95if (!String.IsNullOrWhiteSpace(propName)) 112if (ToolConsole.IsMarkupEnabled && !String.IsNullOrWhiteSpace(str))

Metadata\MetadaExchangeResolver.cs (1)

437if (!string.IsNullOrWhiteSpace(charset))

Metadata\MetadataDocumentLoader.cs (3)

261if (!string.IsNullOrWhiteSpace(uri)) 354if (!string.IsNullOrWhiteSpace(import.Location)) 535if (!File.Exists(fullFileName) && !string.IsNullOrWhiteSpace(specNamespace))

Metadata\MetadataFileNameManager.cs (7)

26if (string.IsNullOrWhiteSpace(fileName)) 31if (string.IsNullOrWhiteSpace(extension)) 36if (string.IsNullOrWhiteSpace(basePath)) 67if (string.IsNullOrWhiteSpace(fileName)) 72if (string.IsNullOrWhiteSpace(extension)) 77if (string.IsNullOrWhiteSpace(basePath)) 98if (string.IsNullOrWhiteSpace(ns))

Metadata\ServiceDescriptor.cs (1)

35if (string.IsNullOrWhiteSpace(serviceUri))

OutputPathHelper.cs (2)

19Debug.Assert(!string.IsNullOrWhiteSpace(filePath), "filePath must have a valid value!"); 20if (string.IsNullOrWhiteSpace(filePath))

Shared\MSBuildProj.cs (5)

194if (!string.IsNullOrWhiteSpace(targetFramework)) 623if (this.RuntimeIdentifier != runtimeIdentifier && !string.IsNullOrWhiteSpace(runtimeIdentifier)) 646if (_targetFramework != targetFramework && !string.IsNullOrWhiteSpace(targetFramework)) 725var restoreParams = "restore --ignore-failed-sources" + (string.IsNullOrWhiteSpace(this.RuntimeIdentifier) ? "" : (" -r " + this.RuntimeIdentifier)); 884var depsFile = this.GlobalProperties.TryGetValue("Configuration", out var activeConfiguration) && !string.IsNullOrWhiteSpace(activeConfiguration) ?

Shared\Options\OptionBase.cs (2)

29if (string.IsNullOrWhiteSpace(name)) 156OptionValueParser.ThrowInvalidValueIf(value == null || (stringValue != null && string.IsNullOrWhiteSpace(stringValue)), jToken, this);

Shared\ProjectDependency.cs (14)

Shared\ProjectPropertyResolver.cs (1)

246if (string.IsNullOrWhiteSpace(propertyName) || propertyName.Any(c => chars.Contains(c) || !char.IsLetterOrDigit(c)))

Shared\Utilities\PathHelper.cs (1)

53if (!string.IsNullOrWhiteSpace(input))

Shared\Utilities\ProcessRunner.cs (5)

61if (string.IsNullOrWhiteSpace(currentDir)) 79foreach (var environmentVar in environmentVariables.Where(e => !string.IsNullOrWhiteSpace(e.Key))) 94if (!string.IsNullOrWhiteSpace(e.Data)) 151throw new ProcessException(string.IsNullOrWhiteSpace(errorText) ? outputText : errorText, exitCode); 153else if (string.IsNullOrWhiteSpace(outputText))

Shared\Utilities\Utilities.cs (1)

41if (!(e is AggregateException) && !string.IsNullOrWhiteSpace(exMsg) && !message.ToString().Contains(exMsg))

ToolConsole.cs (3)

80if (!string.IsNullOrWhiteSpace(errMsg)) 82if (!string.IsNullOrWhiteSpace(prefix)) 207if (!string.IsNullOrWhiteSpace(conversionError.Message))

dotnet-svcutil-lib.Tests (7)

E2ETests.cs (1)

48Assert.False(string.IsNullOrWhiteSpace(this_TestCaseName), $"{nameof(this_TestCaseName)} not initialized!");

GlobalToolTests.cs (1)

18Assert.False(string.IsNullOrWhiteSpace(this_TestCaseName), $"{nameof(this_TestCaseName)} not initialized!");

TestInit.cs (3)

240Assert.False(string.IsNullOrWhiteSpace(testCaseName), $"{nameof(testCaseName)} is not initialized!"); 482fileLines1 = fileLines1.Where(f => !string.IsNullOrWhiteSpace(f)).ToList(); 483fileLines2 = fileLines2.Where(f => !string.IsNullOrWhiteSpace(f)).ToList();

UnitTest.cs (2)

19Assert.False(string.IsNullOrWhiteSpace(this_TestCaseName), $"{nameof(this_TestCaseName)} not initialized!"); 62var verbosityOption = string.IsNullOrWhiteSpace(verbosity) ? string.Empty : $" -v {verbosity}";

dotnet-user-jwts (2)

src\aspnetcore\src\Tools\Shared\SecretsHelpers\UserSecretsCreator.cs (2)

21string newSecretsId = string.IsNullOrWhiteSpace(overrideId) 37if (string.IsNullOrWhiteSpace(overrideId))

dotnet-user-secrets (2)

src\aspnetcore\src\Tools\Shared\SecretsHelpers\UserSecretsCreator.cs (2)

21string newSecretsId = string.IsNullOrWhiteSpace(overrideId) 37if (string.IsNullOrWhiteSpace(overrideId))

dotnet-watch (4)

UI\SpectreBuildParametersSelectionPrompt.cs (4)

53if (!string.IsNullOrWhiteSpace(device.Description)) 58if (!string.IsNullOrWhiteSpace(device.Type)) 61if (!string.IsNullOrWhiteSpace(device.Status)) 67else if (!string.IsNullOrWhiteSpace(device.Status))

DotNetHostedAgent (3)

DevTemporaryLocalUserIdProvider.cs (2)

29var userId = !string.IsNullOrWhiteSpace(context?.PlatformContext?.UserIdKey) 33if (string.IsNullOrWhiteSpace(userId))

Program.cs (1)

99if (string.IsNullOrWhiteSpace(value))

EventSourceGenerator (2)

EventSourceGenerator.Emitter.cs (2)

38if (!string.IsNullOrWhiteSpace(ec.Namespace)) 59if (!string.IsNullOrWhiteSpace(ec.Namespace))

GenerateDocumentationAndConfigFiles (12)

Program.cs (5)

559if (!string.IsNullOrWhiteSpace(descriptor.HelpLinkUri)) 579if (string.IsNullOrWhiteSpace(description)) 658if (!string.IsNullOrWhiteSpace(args.AnalyzerVersion)) 798if (!string.IsNullOrWhiteSpace(helpLinkUri) && 807if (!string.IsNullOrWhiteSpace(helpLinkUri))

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\RoslynString.cs (2)

17/// <inheritdoc cref="string.IsNullOrWhiteSpace(string)"/> 19=> string.IsNullOrWhiteSpace(value);

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

60if (string.IsNullOrWhiteSpace(lineText) || lineText.StartsWith(";", StringComparison.Ordinal))

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

312!string.IsNullOrWhiteSpace(prefixedFirstMatchOrDefault.Key)) 322!string.IsNullOrWhiteSpace(unprefixedFirstMatchOrDefault.Key)) 332!string.IsNullOrWhiteSpace(partialFirstMatchOrDefault.Key))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Indentation\AbstractIndentation.Indenter.cs (1)

137while (token != default && string.IsNullOrWhiteSpace(token.ToString()))

GetDocument.Insider (3)

Commands\GetDocumentCommandWorker.cs (3)

290if (!string.IsNullOrWhiteSpace(_context.FileName) && !Regex.IsMatch(_context.FileName, "^([A-Za-z0-9-_]+)$")) 360if (!string.IsNullOrWhiteSpace(_context.OpenApiVersion)) 389fileName = !string.IsNullOrWhiteSpace(fileName) ? fileName : projectName;

ILCompiler.MetadataTransform (1)

Internal\Metadata\NativeFormat\Writer\NativeMetadataWriter.cs (1)

890string.Join(", ", VarArgParameters.Select(p => p.ToString(false))) + ")"}.Where(e => !string.IsNullOrWhiteSpace(e)));

ILCompiler.ReadyToRun (1)

CodeGen\ReadyToRunObjectWriter.cs (1)

299string symbolName = string.IsNullOrWhiteSpace(configuredSymbolName) ? "RTR_HEADER" : configuredSymbolName;

ILLink.CodeFixProvider (1)

UnconditionalSuppressMessageCodeFixProvider.cs (1)

52string.IsNullOrWhiteSpace(ruleTitle) ? diagnostic.Id : $"{diagnostic.Id}:{ruleTitle}"));

Infrastructure.Common (10)

ConditionalTestDetectors.cs (7)

150if (String.IsNullOrWhiteSpace(runWithCoreWCFService)) 166if (String.IsNullOrWhiteSpace(host)) 188return !String.IsNullOrWhiteSpace(GetExplicitUserName()) && 189!String.IsNullOrWhiteSpace(GetExplicitPassword()); 197return !String.IsNullOrWhiteSpace(GetDomain()); 206return !String.IsNullOrWhiteSpace(GetSPN()); 215return !String.IsNullOrWhiteSpace(GetUPN());

ConditionalWcfTest.cs (2)

50if (!String.IsNullOrWhiteSpace(value) && bool.TryParse(value, out parsedValue)) 62if (!String.IsNullOrWhiteSpace(value) && bool.TryParse(value, out parsedValue))

xunit\ConditionAttribute.cs (1)

52if (string.IsNullOrWhiteSpace(conditionMemberName))

Infrastructure.Tests (24)

CreateFailingTestIssue\CreateFailingTestIssueToolTests.cs (2)

667if (!string.IsNullOrWhiteSpace(stdout)) 672if (!string.IsNullOrWhiteSpace(stderr))

DownloadFailingJobLogs\DownloadFailingJobLogsToolTests.cs (2)

123if (!string.IsNullOrWhiteSpace(stdout)) 128if (!string.IsNullOrWhiteSpace(stderr))

GenerateTestSummary\GenerateTestSummaryToolTests.cs (2)

284if (!string.IsNullOrWhiteSpace(stdout)) 289if (!string.IsNullOrWhiteSpace(stderr))

PowerShellScripts\BuildTestMatrixTests.cs (3)

674Assert.False(string.IsNullOrWhiteSpace(include), 676Assert.False(string.IsNullOrWhiteSpace(msbuildProp), 678Assert.False(string.IsNullOrWhiteSpace(defaultVal),

PowerShellScripts\PowerShellCommand.cs (1)

242if (!string.IsNullOrWhiteSpace(WorkingDirectory))

src\Shared\PathLookupHelper.cs (3)

22Debug.Assert(!string.IsNullOrWhiteSpace(executablePath)); 112Debug.Assert(!string.IsNullOrWhiteSpace(command)); 134Debug.Assert(!string.IsNullOrWhiteSpace(command));

TestTriggerMap\TestTriggerMapTests.cs (10)

WorkflowScripts\NodeCommand.cs (1)

218if (string.IsNullOrWhiteSpace(WorkingDirectory))

installer.tasks (7)

GenerateFileVersionProps.cs (2)

121bool generatePropsFile = !string.IsNullOrWhiteSpace(PropsFile); 149if (!string.IsNullOrWhiteSpace(PropsFile))

StaticFileRegeneration\TpnDocument.cs (1)

39.SkipWhile(line => string.IsNullOrWhiteSpace(line))

StaticFileRegeneration\TpnSectionHeader.cs (4)

96.TakeWhile(s => !string.IsNullOrWhiteSpace(s)) 134.TakeWhile(s => !string.IsNullOrWhiteSpace(s)) 156if (string.IsNullOrWhiteSpace(lines[i - 1]) && 157string.IsNullOrWhiteSpace(lines[i + 1]) &&

Microsoft.Agents.AI.ProjectTemplates.Tests (3)

TestCommandResult.cs (3)

26{(!string.IsNullOrWhiteSpace(StandardOutput) ? 32{(!string.IsNullOrWhiteSpace(StandardError) ? 40Assert.True(ExitCode == 0 && string.IsNullOrWhiteSpace(StandardError), output);

Microsoft.Analyzers.Extra (2)

LegacyLoggingFixer.cs (2)

107if (string.IsNullOrWhiteSpace(details.Message)) 119if (string.IsNullOrWhiteSpace(details.Level))

Microsoft.Analyzers.Local (2)

InternalReferencedInPublicDocAnalyzer.cs (1)

139if (string.IsNullOrWhiteSpace(referencedName))

ModelLoader.cs (1)

56if (string.IsNullOrWhiteSpace(publicInterface))

Microsoft.Analyzers.Local.Tests (1)

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Microsoft.Arcade.Common (1)

Command.cs (1)

216if (string.IsNullOrWhiteSpace(info.Arguments))

Microsoft.AspNetCore.AsyncState (1)

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Microsoft.AspNetCore.Authentication.Certificate (7)

CertificateAuthenticationHandler.cs (7)

265if (!string.IsNullOrWhiteSpace(value)) 271if (!string.IsNullOrWhiteSpace(value)) 277if (!string.IsNullOrWhiteSpace(value)) 283if (!string.IsNullOrWhiteSpace(value)) 289if (!string.IsNullOrWhiteSpace(value)) 295if (!string.IsNullOrWhiteSpace(value)) 301if (!string.IsNullOrWhiteSpace(value))

Microsoft.AspNetCore.Authentication.OpenIdConnect (1)

OpenIdConnectHandler.cs (1)

248if (string.IsNullOrWhiteSpace(properties.RedirectUri))

Microsoft.AspNetCore.Authorization (3)

AuthorizationPolicy.cs (3)

206if (!string.IsNullOrWhiteSpace(authorizeDatum.Policy)) 220var trimmedRolesSplit = rolesSplit.Where(r => !string.IsNullOrWhiteSpace(r)).Select(r => r.Trim()); 230if (!string.IsNullOrWhiteSpace(authType))

Microsoft.AspNetCore.Components.AI (1)

Components\MessageInput.cs (1)

149if (_isDisabled || string.IsNullOrWhiteSpace(_text))

Microsoft.AspNetCore.Components.Media (1)

FileDownload.cs (1)

101if (Source is null || !IsInteractive || string.IsNullOrWhiteSpace(FileName))

Microsoft.AspNetCore.Components.QuickGrid (1)

Columns\ColumnBase.razor.cs (1)

120string displayName = string.IsNullOrWhiteSpace(Title) ? "(unnamed)" : Title;

Microsoft.AspNetCore.Components.Server (1)

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

203allowDeduplication: string.IsNullOrWhiteSpace(frame.TextContent));

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

GenerateE2EManifest.cs (2)

64if (string.IsNullOrWhiteSpace(mode)) 89if (isCompiledHarness && string.IsNullOrWhiteSpace(runtimeIdentifier))

Microsoft.AspNetCore.Components.Web (5)

EnvironmentView.cs (4)

85if (string.IsNullOrWhiteSpace(Include) && string.IsNullOrWhiteSpace(Exclude)) 94if (!string.IsNullOrWhiteSpace(Exclude)) 106if (string.IsNullOrWhiteSpace(Include))

Routing\FocusOnNavigate.cs (1)

43if (string.IsNullOrWhiteSpace(Selector))

Microsoft.AspNetCore.Components.WebAssembly (1)

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

203allowDeduplication: string.IsNullOrWhiteSpace(frame.TextContent));

Microsoft.AspNetCore.Components.WebView (2)

FileExtensionContentTypeProvider.cs (1)

456if (string.IsNullOrWhiteSpace(path))

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

203allowDeduplication: string.IsNullOrWhiteSpace(frame.TextContent));

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

RootComponent.cs (2)

39 if (string.IsNullOrWhiteSpace(Selector)) 55 if (string.IsNullOrWhiteSpace(Selector))

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

RootComponent.cs (1)

24 if (string.IsNullOrWhiteSpace(selector))

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

RootComponent.cs (1)

38 if (string.IsNullOrWhiteSpace(Selector))

Microsoft.AspNetCore.DeveloperCertificates.XPlat (1)

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

374if (string.IsNullOrWhiteSpace(dir))

Microsoft.AspNetCore.Diagnostics (1)

StatusCodePage\StatusCodePagesOptions.cs (1)

51string.IsNullOrWhiteSpace(reasonPhrase) ? "" : "; ",

Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore (1)

MigrationsEndPointMiddleware.cs (1)

100if (string.IsNullOrWhiteSpace(contextTypeName))

Microsoft.AspNetCore.Diagnostics.Middleware.PerformanceTests (1)

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Microsoft.AspNetCore.Grpc.JsonTranscoding (1)

src\aspnetcore\src\Grpc\JsonTranscoding\src\Shared\X509CertificateHelpers.cs (1)

41if (string.IsNullOrWhiteSpace(asnString))

Microsoft.AspNetCore.HeaderParsing (1)

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

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

HttpConnection.cs (1)

518if (string.IsNullOrWhiteSpace(connectionId))

Internal\WebSocketsTransport.cs (1)

246if (!string.IsNullOrWhiteSpace(accessToken))

Microsoft.AspNetCore.HttpLogging (1)

W3CLoggingMiddleware.cs (1)

233return !string.IsNullOrWhiteSpace(value);

Microsoft.AspNetCore.Localization (3)

CookieRequestCultureProvider.cs (1)

67if (string.IsNullOrWhiteSpace(value))

QueryStringRequestCultureProvider.cs (2)

40if (!string.IsNullOrWhiteSpace(QueryStringKey)) 45if (!string.IsNullOrWhiteSpace(UIQueryStringKey))

Microsoft.AspNetCore.Mvc.Core (8)

ModelBinding\Binders\DateTimeModelBinder.cs (1)

60if (string.IsNullOrWhiteSpace(value))

ModelBinding\Binders\DecimalModelBinder.cs (1)

62if (string.IsNullOrWhiteSpace(value))

ModelBinding\Binders\DoubleModelBinder.cs (1)

62if (string.IsNullOrWhiteSpace(value))

ModelBinding\Binders\FloatModelBinder.cs (1)

62if (string.IsNullOrWhiteSpace(value))

ModelBinding\Binders\SimpleTypeModelBinder.cs (2)

63if (bindingContext.ModelMetadata.ConvertEmptyStringToNull && string.IsNullOrWhiteSpace(value)) 72else if (string.IsNullOrWhiteSpace(value))

ModelBinding\Binders\TryParseModelBinder.cs (1)

64if (string.IsNullOrWhiteSpace(value))

ModelBinding\ModelBindingHelper.cs (1)

687if (value is string valueAsString && string.IsNullOrWhiteSpace(valueAsString))

Microsoft.AspNetCore.Mvc.TagHelpers (4)

EnvironmentTagHelper.cs (3)

75if (string.IsNullOrWhiteSpace(Names) && string.IsNullOrWhiteSpace(Include) && string.IsNullOrWhiteSpace(Exclude))

GlobbingUrlBuilder.cs (1)

131if (!string.IsNullOrWhiteSpace(exclude))

Microsoft.AspNetCore.OpenApi (2)

Extensions\ApiDescriptionExtensions.cs (1)

26if (string.IsNullOrWhiteSpace(httpMethod))

Services\Schemas\OpenApiSchemaService.cs (1)

659if (string.IsNullOrWhiteSpace(refPath))

Microsoft.AspNetCore.OpenApi.SourceGenerators (3)

Helpers\StringExtensions.cs (3)

29if (string.IsNullOrWhiteSpace(line)) 54if (trimStart && string.IsNullOrWhiteSpace(line)) 68if (string.IsNullOrWhiteSpace(line))

Microsoft.AspNetCore.OutputCaching (1)

OutputCacheEntryFormatter.cs (1)

514if (!string.IsNullOrWhiteSpace(header)) // omit null/empty values

Microsoft.AspNetCore.Razor (5)

TagHelpers\DefaultTagHelperContent.cs (2)

271return string.IsNullOrWhiteSpace(stringValue); 326if (IsEmptyOrWhiteSpace && !string.IsNullOrWhiteSpace(value))

TagHelpers\TagHelperOutput.cs (3)

285var isTagNameNullOrWhitespace = string.IsNullOrWhiteSpace(TagName); 334var isTagNameNullOrWhitespace = string.IsNullOrWhiteSpace(TagName); 389var isTagNameNullOrWhitespace = string.IsNullOrWhiteSpace(TagName);

Microsoft.AspNetCore.Razor.Utilities.Shared (2)

src\roslyn\src\Razor\src\Shared\Microsoft.AspNetCore.Razor.SharedUtilities\StringExtensions.cs (2)

42/// <see cref="string.IsNullOrWhiteSpace(string?)"/> is not annotated for nullability. 45=> string.IsNullOrWhiteSpace(value);

Microsoft.AspNetCore.Server.HttpSys (7)

RequestProcessing\Response.cs (1)

136if (string.IsNullOrWhiteSpace(reasonPhrase))

src\aspnetcore\src\Shared\HttpSys\RequestProcessing\HeaderCollection.cs (1)

131!string.IsNullOrWhiteSpace(rawValue[0]) &&

src\aspnetcore\src\Shared\HttpSys\RequestProcessing\HeaderParser.cs (2)

37if (!string.IsNullOrWhiteSpace(subValue)) 48if (!string.IsNullOrWhiteSpace(subValue))

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

187!string.IsNullOrWhiteSpace(rawValue[0]) &&

UrlPrefix.cs (2)

37if (!string.IsNullOrWhiteSpace(port)) 84if (string.IsNullOrWhiteSpace(path))

Microsoft.AspNetCore.Server.IIS (4)

src\aspnetcore\src\Shared\HttpSys\RequestProcessing\HeaderCollection.cs (1)

131!string.IsNullOrWhiteSpace(rawValue[0]) &&

src\aspnetcore\src\Shared\HttpSys\RequestProcessing\HeaderParser.cs (2)

37if (!string.IsNullOrWhiteSpace(subValue)) 48if (!string.IsNullOrWhiteSpace(subValue))

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

187!string.IsNullOrWhiteSpace(rawValue[0]) &&

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

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

374if (string.IsNullOrWhiteSpace(dir))

Microsoft.AspNetCore.Session (1)

SessionMiddleware.cs (1)

66if (string.IsNullOrWhiteSpace(sessionKey) || sessionKey.Length != SessionKeyLength)

Microsoft.AspNetCore.SpaServices.Extensions (2)

Npm\NodeScriptRunner.cs (2)

89if (!string.IsNullOrWhiteSpace(line) && logger.IsEnabled(LogLevel.Information)) 99if (!string.IsNullOrWhiteSpace(line))

Microsoft.AspNetCore.StaticFiles (1)

FileExtensionContentTypeProvider.cs (1)

450if (string.IsNullOrWhiteSpace(path))

Microsoft.AspNetCore.Testing (1)

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Microsoft.AspNetCore.WebSockets (2)

HandshakeHelpers.cs (2)

28if (!string.IsNullOrWhiteSpace(subProtocol)) 41if (string.IsNullOrWhiteSpace(value))

Microsoft.Build (43)

BackEnd\BuildManager\BuildManager.cs (1)

636if (_buildParameters.UsesOutputCache() && string.IsNullOrWhiteSpace(_buildParameters.OutputResultsCacheFile))

BackEnd\BuildManager\CacheSerialization.cs (1)

27if (string.IsNullOrWhiteSpace(outputCacheFile))

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

310if (!string.IsNullOrWhiteSpace(subcategoryResourceName))

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

739&& !string.IsNullOrWhiteSpace(solutionConfigurationXml)) 778string.IsNullOrWhiteSpace(buildProjectInSolution.Value) is false &&

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

1570if (String.IsNullOrWhiteSpace(warnings))

BackEnd\Components\SdkResolution\SdkResolverService.cs (1)

463if (!string.IsNullOrWhiteSpace(warning))

BackEnd\Shared\BuildRequestConfiguration.cs (1)

913if (items.Count == 0 || items.All(i => string.IsNullOrWhiteSpace(i.EvaluatedInclude)))

BackEnd\TaskExecutionHost\TaskExecutionHost.cs (1)

536if (!string.IsNullOrWhiteSpace(realTaskAssemblyLocation) && realTaskAssemblyLocation != _taskFactoryWrapper.TaskFactoryLoadedType.Path)

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

76if (string.IsNullOrWhiteSpace(line))

Construction\ProjectRootElement.cs (1)

1912if (!string.IsNullOrWhiteSpace(sdkAttribute))

Construction\Solution\SolutionFile.cs (3)

1597if (String.IsNullOrWhiteSpace(str) || str[0] == CommentStartChar) 1644if (String.IsNullOrWhiteSpace(str) || str[0] == CommentStartChar) 1721if (String.IsNullOrWhiteSpace(str) || str[0] == CommentStartChar)

Evaluation\Evaluator.cs (2)

2106if (string.IsNullOrWhiteSpace(importExpressionEscaped)) 2770if (provideProperty is null || string.IsNullOrWhiteSpace(provideProperty.EvaluatedValue))

Evaluation\Expander.Function.cs (2)

486string startingDirectory = String.IsNullOrWhiteSpace(elementLocation.File) ? String.Empty : Path.GetDirectoryName(elementLocation.File); 678if (string.IsNullOrWhiteSpace(typeName))

Evaluation\Expander\WellKnownFunctions.cs (1)

812returnVal = string.IsNullOrWhiteSpace(arg0);

Evaluation\LazyItemEvaluator.UpdateOperation.cs (1)

161if (!string.IsNullOrWhiteSpace(metadataReference.Value.ItemName))

Evaluation\Preprocessor.cs (1)

309if (!String.IsNullOrWhiteSpace(importSdk) && projectSdk.IndexOf(importSdk, StringComparison.OrdinalIgnoreCase) >= 0)

Evaluation\ProjectParser.cs (5)

721(String.IsNullOrWhiteSpace(itemNameAttribute?.Value) && !String.IsNullOrWhiteSpace(propertyNameAttribute?.Value)) || (!String.IsNullOrWhiteSpace(itemNameAttribute?.Value) && String.IsNullOrWhiteSpace(propertyNameAttribute?.Value)), 729ProjectErrorUtilities.VerifyThrowInvalidProject(String.IsNullOrWhiteSpace(propertyNameAttribute?.Value) || !ReservedPropertyNames.IsReservedProperty(propertyNameAttribute.Value), element.Location, "CannotModifyReservedProperty", propertyNameAttribute?.Value);

Graph\GraphBuilder.cs (1)

736if (string.IsNullOrWhiteSpace(targetsMetadata))

Graph\ProjectGraph.cs (1)

822if (targetNames.Any(targetName => string.IsNullOrWhiteSpace(targetName)))

Graph\ProjectInterpretation.cs (9)

Logging\TerminalLogger\TerminalNodesFrame.cs (4)

60var targetWithoutAnsiLength = !string.IsNullOrWhiteSpace(targetPrefix) 86var renderedTarget = !string.IsNullOrWhiteSpace(targetPrefix) ? $"{AnsiCodes.Colorize(targetPrefix, targetPrefixColor)} {target}" : target; 89if (!string.IsNullOrWhiteSpace(targetFramework)) 93if (!string.IsNullOrWhiteSpace(runtimeIdentifier))

Utilities\EngineFileUtilities.cs (1)

242bool excludeFileSpecIsEmpty = string.IsNullOrWhiteSpace(excludeFileSpec);

Xml\ProjectXmlUtilities.XmlElementChildIterator.cs (1)

91if (child.NodeType == XmlNodeType.Text && String.IsNullOrWhiteSpace(child.InnerText))

Microsoft.Build.Framework (17)

BuildCanceledEventArgs.cs (1)

47if (string.IsNullOrWhiteSpace(message))

DebugUtils.cs (3)

72if (!string.IsNullOrWhiteSpace(debugDirectory) && FileUtilities.CanWriteToDirectory(debugDirectory)) 87if (string.IsNullOrWhiteSpace(environmentDebugPath)) 107var thisProcessMatchesName = string.IsNullOrWhiteSpace(processNameToBreakInto) ||

Logging\AnsiCodes.cs (2)

127if (string.IsNullOrWhiteSpace(s)) 137if (string.IsNullOrWhiteSpace(s))

Logging\LoggerParametersHelper.cs (1)

55if (string.IsNullOrWhiteSpace(parameter))

NodeMode.cs (1)

126if (string.IsNullOrWhiteSpace(commandLine))

Polyfills\StringExtensions.cs (2)

17/// <inheritdoc cref="string.IsNullOrWhiteSpace(string)"/> 19=> string.IsNullOrWhiteSpace(value);

Sdk\SdkReference.cs (6)

82if (string.IsNullOrWhiteSpace(sdk)) 94if (string.IsNullOrWhiteSpace(parts[0])) 99if (parts.Length == 1 || string.IsNullOrWhiteSpace(parts[1])) 149if (string.IsNullOrWhiteSpace(Version) && string.IsNullOrWhiteSpace(MinimumVersion)) 154return string.IsNullOrWhiteSpace(Version) ?

Utilities\ConversionUtilities.cs (1)

45if (nullOrWhitespaceIsFalse && string.IsNullOrWhiteSpace(parameterValue))

Microsoft.Build.NuGetSdkResolver (8)

GlobalJsonReader.cs (5)

57if (string.IsNullOrWhiteSpace(startingPath) || string.IsNullOrWhiteSpace(fileName)) 109if (!string.IsNullOrWhiteSpace(context.SolutionFilePath)) 114if (!string.IsNullOrWhiteSpace(context.ProjectFilePath)) 134if (string.IsNullOrWhiteSpace(file) || startingDirectory == null || !startingDirectory.Exists)

NuGetSdkResolver.cs (3)

121if (!string.IsNullOrWhiteSpace(version)) 131if (string.IsNullOrWhiteSpace(context?.ProjectFilePath)) 140!string.IsNullOrWhiteSpace(globalJsonVersion))

Microsoft.Build.Tasks.CodeAnalysis (8)

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

264if (!string.IsNullOrWhiteSpace(VsSessionGuid))

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

96if (!string.IsNullOrWhiteSpace(itemType) && !string.IsNullOrWhiteSpace(metadataName))

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

561if (!string.IsNullOrWhiteSpace(this.VsSessionGuid))

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\RoslynString.cs (2)

17/// <inheritdoc cref="string.IsNullOrWhiteSpace(string)"/> 19=> string.IsNullOrWhiteSpace(value);

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

Microsoft.Build.Tasks.Core (20)

DownloadFile.cs (2)

329filename = !string.IsNullOrWhiteSpace(DestinationFileName?.ItemSpec) 333return !string.IsNullOrWhiteSpace(filename);

FormatUrl.cs (1)

47if (InputUrl.Length > 0 && NativeMethodsShared.IsWindows && string.IsNullOrWhiteSpace(InputUrl))

NativeMethods.cs (5)

319if (!string.IsNullOrWhiteSpace(assemblyName)) 373if (!string.IsNullOrWhiteSpace(assemblyName)) 378if (!string.IsNullOrWhiteSpace(versionString)) 387!string.IsNullOrWhiteSpace( 397if (!string.IsNullOrWhiteSpace(match.Groups[3].Value))

ResourceHandling\MSBuildResXReader.cs (1)

137if (!preserve && string.IsNullOrWhiteSpace(value))

RoslynCodeTaskFactory\RoslynCodeTaskFactory.cs (6)

401if (String.IsNullOrWhiteSpace(includeAttribute?.Value)) 415if (String.IsNullOrWhiteSpace(namespaceAttribute?.Value)) 485if (String.IsNullOrWhiteSpace(sourceAttribute.Value)) 507if (String.IsNullOrWhiteSpace(typeAttribute.Value)) 526if (String.IsNullOrWhiteSpace(languageAttribute.Value)) 562if (String.IsNullOrWhiteSpace(taskInfo.SourceCode))

RoslynCodeTaskFactory\RoslynCodeTaskFactoryCompilers.cs (1)

124if (!String.IsNullOrWhiteSpace(ToolExe) && Path.IsPathRooted(ToolExe))

TarDirectory.cs (2)

427if (string.IsNullOrWhiteSpace(Format)) 453if (string.IsNullOrWhiteSpace(Compression))

Untar.cs (1)

423if (!string.IsNullOrWhiteSpace(pattern))

Unzip.cs (1)

341if (!string.IsNullOrWhiteSpace(pattern))

Microsoft.Build.Tasks.Git (7)

GitDataReader\GitEnvironment.cs (6)

43if (!string.IsNullOrWhiteSpace(homeDirectory)) 48if (!string.IsNullOrWhiteSpace(xdgConfigHomeDirectory)) 53if (!string.IsNullOrWhiteSpace(programDataDirectory)) 58if (!string.IsNullOrWhiteSpace(systemDirectory)) 138var gitExe = paths.FirstOrDefault(dir => !string.IsNullOrWhiteSpace(dir) && File.Exists(PathUtils.CombinePaths(dir, "git.exe"))); 144var gitCmd = paths.FirstOrDefault(dir => !string.IsNullOrWhiteSpace(dir) && File.Exists(PathUtils.CombinePaths(dir, "git.cmd")));

src\sourcelink\src\Common\Utilities\NullableAttributes.cs (1)

100=> string.IsNullOrWhiteSpace(str);

Microsoft.Build.Utilities.Core (2)

ToolLocationHelper.cs (1)

1221if (string.IsNullOrWhiteSpace(folderName) || sdkVersion != "10.0" || !string.Equals(sdkIdentifier, "Windows", StringComparison.OrdinalIgnoreCase))

ToolTask.cs (1)

530if (string.IsNullOrWhiteSpace(pathToTool) || (ToolPath == null && !FileSystems.Default.FileExists(TaskEnvironment.GetAbsolutePath(pathToTool))))

Microsoft.CodeAnalysis (19)

CommandLine\AnalyzerConfig.cs (1)

211if (string.IsNullOrWhiteSpace(line))

CommandLine\AnalyzerConfigSet.cs (1)

524bool isGlobalSection = string.IsNullOrWhiteSpace(section);

CommandLine\CommandLineParser.cs (1)

484if (string.IsNullOrWhiteSpace(outputFileName))

CommandLine\CommonCompiler.cs (4)

825string.IsNullOrWhiteSpace(Arguments.OutputFileName); 852Debug.Assert(!string.IsNullOrWhiteSpace(Arguments.OutputFileName)); 1165var hasExplicitGeneratedOutDir = !string.IsNullOrWhiteSpace(explicitGeneratedOutDir); 1177Debug.Assert(!string.IsNullOrWhiteSpace(tree.FilePath));

Compilation\SubsystemVersion.cs (1)

85if (!string.IsNullOrWhiteSpace(str))

Diagnostic\DiagnosticDescriptor.cs (1)

164if (string.IsNullOrWhiteSpace(id))

Diagnostic\SuppressionDescriptor.cs (2)

58if (string.IsNullOrWhiteSpace(id)) 63if (string.IsNullOrWhiteSpace(suppressedDiagnosticId))

InternalUtilities\RoslynString.cs (2)

17/// <inheritdoc cref="string.IsNullOrWhiteSpace(string)"/> 19=> string.IsNullOrWhiteSpace(value);

MetadataReader\PEModule.cs (1)

1340if (string.IsNullOrWhiteSpace(diagnosticId))

SourceGeneration\AdditionalSourcesCollection.cs (1)

46if (string.IsNullOrWhiteSpace(hintName))

Symbols\Attributes\CommonAttributeData.cs (1)

277if (string.IsNullOrWhiteSpace(diagnosticId))

Syntax\GreenNode.cs (1)

525if (string.IsNullOrWhiteSpace(annotationKind))

VersionHelper.cs (2)

57if (string.IsNullOrWhiteSpace(s)) 103if (string.IsNullOrWhiteSpace(elements[i]))

Microsoft.CodeAnalysis.Analyzers (13)

MetaAnalyzers\Fixers\AnalyzerReleaseTrackingFix.cs (1)

278if (string.IsNullOrWhiteSpace(lineText))

MetaAnalyzers\ReleaseTrackingHelper.cs (1)

60if (string.IsNullOrWhiteSpace(lineText) || lineText.StartsWith(";", StringComparison.Ordinal))

MetaAnalyzers\SymbolIsBannedInAnalyzersAnalyzer.cs (1)

99if (string.IsNullOrWhiteSpace(text))

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\RoslynString.cs (2)

17/// <inheritdoc cref="string.IsNullOrWhiteSpace(string)"/> 19=> string.IsNullOrWhiteSpace(value);

src\roslyn\src\RoslynAnalyzers\Microsoft.CodeAnalysis.BannedApiAnalyzers\Core\SymbolIsBannedAnalyzerBase.cs (4)

315string.IsNullOrWhiteSpace(entry.Message) ? "" : ": " + entry.Message)); 346string.IsNullOrWhiteSpace(entry.Message) ? "" : ": " + entry.Message)); 358string.IsNullOrWhiteSpace(entry.Message) ? "" : ": " + entry.Message)); 428string.IsNullOrWhiteSpace(entry.Message) ? "" : ": " + entry.Message));

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

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Indentation\AbstractIndentation.Indenter.cs (1)

137while (token != default && string.IsNullOrWhiteSpace(token.ToString()))

Microsoft.CodeAnalysis.AnalyzerUtilities (6)

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\RoslynString.cs (2)

17/// <inheritdoc cref="string.IsNullOrWhiteSpace(string)"/> 19=> string.IsNullOrWhiteSpace(value);

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

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Indentation\AbstractIndentation.Indenter.cs (1)

137while (token != default && string.IsNullOrWhiteSpace(token.ToString()))

Microsoft.CodeAnalysis.CodeStyle (4)

src\roslyn\src\Analyzers\Core\Analyzers\OrderModifiers\OrderModifiersHelpers.cs (1)

45if (string.IsNullOrWhiteSpace(value))

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\RoslynString.cs (2)

17/// <inheritdoc cref="string.IsNullOrWhiteSpace(string)"/> 19=> string.IsNullOrWhiteSpace(value);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Indentation\AbstractIndentation.Indenter.cs (1)

137while (token != default && string.IsNullOrWhiteSpace(token.ToString()))

Microsoft.CodeAnalysis.CodeStyle.Fixes (7)

src\roslyn\src\Analyzers\Core\CodeFixes\AddParameter\AbstractAddParameterCodeFixProvider.cs (3)

207var isNamedArgument = !string.IsNullOrWhiteSpace(syntaxFacts.GetNameForArgument(argumentOpt)); 417if (!string.IsNullOrWhiteSpace(argumentName)) 448if (!string.IsNullOrWhiteSpace(argumentName))

src\roslyn\src\Analyzers\Core\CodeFixes\ConflictMarkerResolution\AbstractConflictMarkerCodeFixProvider.cs (2)

271var takeTopText = string.IsNullOrWhiteSpace(topText) 276var takeBottomText = string.IsNullOrWhiteSpace(bottomText)

src\roslyn\src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateMethodService.State.cs (1)

143if (string.IsNullOrWhiteSpace(IdentifierToken.ValueText))

src\roslyn\src\Analyzers\Core\CodeFixes\GenerateVariable\AbstractGenerateVariableService.State.cs (1)

245if (string.IsNullOrWhiteSpace(identifierToken.ValueText))

Microsoft.CodeAnalysis.CSharp (7)

Binder\Binder_Symbols.cs (1)

870if (string.IsNullOrWhiteSpace(identifierValueText))

CommandLine\CSharpCommandLineParser.cs (2)

694if (string.IsNullOrWhiteSpace(value)) 1668if (string.IsNullOrWhiteSpace(noQuotes))

Compilation\CSharpCompilation.cs (1)

2018if (nameParts.Any(n => string.IsNullOrWhiteSpace(n)))

Compiler\DocumentationCommentCompiler.cs (1)

1099if (string.IsNullOrWhiteSpace(currentLinePattern))

Symbols\Source\SourceAssemblySymbol.cs (1)

124Debug.Assert(!String.IsNullOrWhiteSpace(moduleName));

Syntax\CSharpPragmaWarningStateMap.cs (1)

135if (!string.IsNullOrWhiteSpace(errorId))

Microsoft.CodeAnalysis.CSharp.CodeStyle (2)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Formatting\Engine\Trivia\TriviaDataFactory.cs (2)

74Debug.Assert(string.IsNullOrWhiteSpace(this.TreeInfo.GetTextBetween(token1, token2))); 82Debug.Assert(string.IsNullOrWhiteSpace(this.TreeInfo.GetTextBetween(token1, token2)));

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

src\roslyn\src\Analyzers\CSharp\CodeFixes\DisambiguateSameVariable\CSharpDisambiguateSameVariableCodeFixProvider.cs (1)

93if (string.IsNullOrWhiteSpace(localOrParamName))

Microsoft.CodeAnalysis.CSharp.Features (15)

CodeFixes\Suppression\CSharpSuppressionCodeFixProvider.cs (2)

63if (!string.IsNullOrWhiteSpace(title)) 184var ruleIdText = string.IsNullOrWhiteSpace(title) ? diagnostic.Id : string.Format("{0}:{1}", diagnostic.Id, title);

Completion\CompletionProviders\XmlDocCommentCompletionProvider.cs (1)

215if (token.IsKind(SyntaxKind.XmlTextLiteralToken) && string.IsNullOrWhiteSpace(token.Text))

ConvertPrimaryToRegularConstructor\ConvertPrimaryToRegularConstructorCodeRefactoringProvider_DocumentationComments.cs (3)

57t => t.Kind() == SyntaxKind.XmlTextLiteralNewLineToken || string.IsNullOrWhiteSpace(t.Text)))) 85if (lastIndex - 1 >= 0 && tokens[lastIndex - 1].Kind() == SyntaxKind.XmlTextLiteralToken && string.IsNullOrWhiteSpace(tokens[lastIndex - 1].Text)) 157if (textToken.Kind() == SyntaxKind.XmlTextLiteralToken && string.IsNullOrWhiteSpace(textToken.Text))

Copilot\CSharpImplementNotImplementedExceptionFixProvider.cs (1)

126Contract.ThrowIfTrue(string.IsNullOrWhiteSpace(implementationDetails.Message));

DocumentationComments\CSharpDocumentationCommentSnippetService.cs (2)

294if (textTokens.Count != 1 && string.IsNullOrWhiteSpace(firstTextToken.ValueText)) 351if (textTokens.Any(t => !string.IsNullOrWhiteSpace(t.ToString())))

DocumentationComments\DocCommentConverter.cs (1)

89if (!string.IsNullOrWhiteSpace(line))

GenerateType\CSharpGenerateTypeService.cs (1)

716if (string.IsNullOrWhiteSpace(includeUsingsOrImports))

LineSeparators\CSharpLineSeparatorService.cs (1)

337if (string.IsNullOrWhiteSpace(syntaxTree.GetText(cancellationToken).Lines[line + 1].ToString()))

QuickInfo\CSharpDiagnosticAnalyzerQuickInfoProvider.cs (1)

150var idTag = !string.IsNullOrWhiteSpace(descriptor.HelpLinkUri)

QuickInfo\CSharpDiagnosticAnalyzerQuickInfoProviderExtensions.cs (1)

17if (string.IsNullOrWhiteSpace(result))

src\roslyn\src\Analyzers\CSharp\CodeFixes\DisambiguateSameVariable\CSharpDisambiguateSameVariableCodeFixProvider.cs (1)

93if (string.IsNullOrWhiteSpace(localOrParamName))

Microsoft.CodeAnalysis.CSharp.Workspaces (3)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Formatting\Engine\Trivia\TriviaDataFactory.cs (2)

74Debug.Assert(string.IsNullOrWhiteSpace(this.TreeInfo.GetTextBetween(token1, token2))); 82Debug.Assert(string.IsNullOrWhiteSpace(this.TreeInfo.GetTextBetween(token1, token2)));

SyncedSource\FileBasedPrograms\VirtualProjectBuilder.cs (1)

622Debug.Assert(!string.IsNullOrWhiteSpace(artifactsPath));

Microsoft.CodeAnalysis.Extensions.Package (2)

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\RoslynString.cs (2)

17/// <inheritdoc cref="string.IsNullOrWhiteSpace(string)"/> 19=> string.IsNullOrWhiteSpace(value);

Microsoft.CodeAnalysis.Features (24)

AddImport\CodeActions\AssemblyReferenceCodeAction.cs (1)

94if (string.IsNullOrWhiteSpace(resolvedPath))

AddImport\SearchScopes\SearchScope.cs (1)

42if (name != null && string.IsNullOrWhiteSpace(name))

ChangeSignature\Parameter.cs (1)

69public override bool HasDefaultValue => !string.IsNullOrWhiteSpace(DefaultValue);

CodeFixes\Service\CodeFixService.cs (2)

923if (string.IsNullOrWhiteSpace(id)) 1012if (string.IsNullOrWhiteSpace(id))

Completion\Providers\AbstractInternalsVisibleToCompletionProvider.cs (1)

213if (!string.IsNullOrWhiteSpace(assemblyName))

Completion\Providers\AbstractSymbolCompletionProvider.cs (1)

169if (!string.IsNullOrWhiteSpace(texts.displayText))

DocumentationComments\AbstractDocumentationCommentSnippetService.cs (1)

397string.IsNullOrWhiteSpace(currentLine.ToString()) &&

EditAndContinue\EditAndContinueService.cs (1)

81if (string.IsNullOrWhiteSpace(path))

GenerateType\AbstractGenerateTypeService.Editor.cs (4)

167if (!string.IsNullOrWhiteSpace(rootNamespace)) 208if (!string.IsNullOrWhiteSpace(rootNamespace)) 510if (!string.IsNullOrWhiteSpace(defaultNamespace)) 534if (!string.IsNullOrWhiteSpace(rootNamespaceOfTheProjectGeneratedInto))

GenerateType\AbstractGenerateTypeService.State.cs (1)

96if (string.IsNullOrWhiteSpace(Name))

InlineHints\AbstractInlineTypeHintsService.cs (1)

89if (finalParts.All(p => string.IsNullOrWhiteSpace(p.ToString())))

MetadataAsSource\AbstractMetadataAsSourceService.DocCommentFormatter.cs (1)

148if (string.IsNullOrWhiteSpace(rawText))

src\roslyn\src\Analyzers\Core\Analyzers\OrderModifiers\OrderModifiersHelpers.cs (1)

45if (string.IsNullOrWhiteSpace(value))

src\roslyn\src\Analyzers\Core\CodeFixes\AddParameter\AbstractAddParameterCodeFixProvider.cs (3)

src\roslyn\src\Analyzers\Core\CodeFixes\ConflictMarkerResolution\AbstractConflictMarkerCodeFixProvider.cs (2)

271var takeTopText = string.IsNullOrWhiteSpace(topText) 276var takeBottomText = string.IsNullOrWhiteSpace(bottomText)

src\roslyn\src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateMethodService.State.cs (1)

143if (string.IsNullOrWhiteSpace(IdentifierToken.ValueText))

src\roslyn\src\Analyzers\Core\CodeFixes\GenerateVariable\AbstractGenerateVariableService.State.cs (1)

245if (string.IsNullOrWhiteSpace(identifierToken.ValueText))

Microsoft.CodeAnalysis.NetAnalyzers (9)

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

53|| string.IsNullOrWhiteSpace(methodSymbol.Name))

Microsoft.NetCore.Analyzers\Resources\MarkAssembliesWithNeutralResourcesLanguage.cs (1)

158if (data.ConstructorArguments.Any(c => c.Value is string constantValue && !string.IsNullOrWhiteSpace(constantValue)))

Microsoft.NetCore.Analyzers\Security\DoNotUseInsecureDeserializerWithoutBinderBase.cs (2)

72Debug.Assert(!string.IsNullOrWhiteSpace(this.DeserializerTypeMetadataName)); 73Debug.Assert(!string.IsNullOrWhiteSpace(this.SerializationBinderPropertyMetadataName));

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

311!string.IsNullOrWhiteSpace(prefixedFirstMatchOrDefault.Key)) 322!string.IsNullOrWhiteSpace(unprefixedFirstMatchOrDefault.Key)) 332!string.IsNullOrWhiteSpace(partialFirstMatchOrDefault.Key))

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

15/// <inheritdoc cref="string.IsNullOrWhiteSpace(string)"/> 17=> string.IsNullOrWhiteSpace(value);

Microsoft.CodeAnalysis.Razor.Compiler (25)

CSharp\GenericTypeNameRewriter.cs (1)

70var replacement = !string.IsNullOrWhiteSpace(content) ? content : "object";

CSharp\Utf8WriteLiteralDetectionPass.cs (1)

34if (baseType is null || string.IsNullOrWhiteSpace(baseType.BaseType.Content))

Language\BoundAttributeDescriptorBuilder.cs (1)

267else if (IndexerAttributeNamePrefix.Length > 0 && string.IsNullOrWhiteSpace(IndexerAttributeNamePrefix))

Language\CodeGeneration\CodeWriterExtensions.cs (1)

723var hasBaseType = !string.IsNullOrWhiteSpace(baseType?.BaseType.Content);

Language\CodeGeneration\IntermediateNodeWriter.cs (1)

136if (token == null || !string.IsNullOrWhiteSpace(token.Content))

Language\Components\ComponentGenericTypePass.cs (1)

302if (binding.Node == null || string.IsNullOrWhiteSpace(binding.Content?.Content))

Language\Components\ComponentInjectDirectivePass.cs (2)

32var hasType = tokens.Length > 0 && !string.IsNullOrWhiteSpace(tokens[0].Content); 37var hasMemberName = tokens.Length > 1 && !string.IsNullOrWhiteSpace(tokens[1].Content);

Language\Components\ComponentLoweringPass.cs (1)

561string.IsNullOrWhiteSpace(token.Content))

Language\Components\ComponentNodeWriter.cs (1)

661if (child is not IntermediateToken token || !string.IsNullOrWhiteSpace(token.Content))

Language\Components\ComponentWhitespacePass.cs (1)

101shouldRemoveNode = string.IsNullOrWhiteSpace(intermediateToken.Content);

Language\DefaultTagHelperResolutionPhase.cs (3)

597if (token is IntermediateToken t && !string.IsNullOrWhiteSpace(t.Content)) 1250if (!string.IsNullOrWhiteSpace(token.Content)) 1259if (hc is IntermediateToken ht && !string.IsNullOrWhiteSpace(ht.Content))

Language\Legacy\ImplicitExpressionEditHandler.cs (1)

440return string.IsNullOrWhiteSpace(target.GetContent().Substring(offset));

Language\Legacy\TagHelperBlockRewriter.cs (3)

124if (!string.IsNullOrWhiteSpace(literalContent)) 148if (string.IsNullOrWhiteSpace(content)) 188string.IsNullOrWhiteSpace(GetAttributeValueContent(result.RewrittenAttribute))))

Language\Legacy\TagHelperParseTreeRewriter.cs (1)

577if (!string.IsNullOrWhiteSpace(content))

Language\Legacy\WhiteSpaceRewriter.cs (1)

56var containsNonWhitespace = literal.DescendantTokens().Any(static t => !string.IsNullOrWhiteSpace(t.Content));

Language\Syntax\BaseMarkupStartTagSyntax.cs (1)

70if (!string.IsNullOrWhiteSpace(token.Content))

Mvc\InjectDirective.cs (2)

71var hasType = tokens.Length > 0 && !string.IsNullOrWhiteSpace(tokens[0].Content); 76var hasMemberName = tokens.Length > 1 && !string.IsNullOrWhiteSpace(tokens[1].Content);

Mvc\InjectTargetExtension.cs (1)

28if (!string.IsNullOrWhiteSpace(node.TypeSource?.FilePath))

SourceGenerators\RazorSourceGenerator.RazorProviders.cs (1)

115if (hasTargetPath && !string.IsNullOrWhiteSpace(encodedRelativePath))

Microsoft.CodeAnalysis.ResxSourceGenerator (6)

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\RoslynString.cs (2)

17/// <inheritdoc cref="string.IsNullOrWhiteSpace(string)"/> 19=> string.IsNullOrWhiteSpace(value);

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

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Indentation\AbstractIndentation.Indenter.cs (1)

137while (token != default && string.IsNullOrWhiteSpace(token.ToString()))

Microsoft.CodeAnalysis.VisualBasic (9)

CommandLine\VisualBasicCommandLineParser.vb (7)

389If String.IsNullOrWhiteSpace(value) = True Then 508If String.IsNullOrWhiteSpace(value) Then 584If String.IsNullOrWhiteSpace(documentationPath) Then 614If (String.IsNullOrWhiteSpace(unquoted)) Then 984If String.IsNullOrWhiteSpace(value) Then 1401If String.IsNullOrWhiteSpace(rootNamespace) OrElse Not OptionsValidator.IsValidNamespaceName(rootNamespace) Then 1613If String.IsNullOrWhiteSpace(noQuotes) Then

Symbols\AnonymousTypes\AnonymousTypeDescriptor.vb (1)

186Me.Name = If(String.IsNullOrWhiteSpace(name), "<Empty Name>", name)

Symbols\Source\SourceAssemblySymbol.vb (1)

84Debug.Assert(Not String.IsNullOrWhiteSpace(moduleName))

Microsoft.CodeAnalysis.VisualBasic.CodeStyle.Fixes (1)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\Extensions\SemanticModelExtensions.vb (1)

90Return If(String.IsNullOrWhiteSpace(result), [Shared].Extensions.ITypeSymbolExtensions.DefaultParameterName, result)

Microsoft.CodeAnalysis.VisualBasic.Features (6)

CodeFixes\Suppression\VisualBasicSuppressionCodeFixProvider.vb (2)

65If Not String.IsNullOrWhiteSpace(title) Then 182Dim ruleIdText = If(String.IsNullOrWhiteSpace(title), diagnostic.Id, String.Format("{0}:{1}", diagnostic.Id, title))

Completion\CompletionProviders\NamedParameterCompletionProvider.vb (1)

125Where(Function(i) Not String.IsNullOrWhiteSpace(i))

DocumentationComments\VisualBasicDocumentationCommentSnippetService.vb (1)

226If textTokens.Any(Function(t) Not String.IsNullOrWhiteSpace(t.ToString())) Then

GenerateType\VisualBasicGenerateTypeService.vb (1)

620If String.IsNullOrWhiteSpace(includeUsingsOrImports) Then

MetadataAsSource\VisualBasicMetadataAsSourceService.vb (1)

201If Not String.IsNullOrWhiteSpace(line) Then

Microsoft.CodeAnalysis.VisualBasic.Workspaces (3)

CaseCorrection\VisualBasicCaseCorrectionService.Rewriter.vb (1)

30If Not String.IsNullOrWhiteSpace(importsClause.Alias.Identifier.ValueText) Then

CodeCleanup\Providers\NormalizeModifiersOrOperatorsCodeCleanupProvider.vb (1)

283If String.IsNullOrWhiteSpace(expectedText) OrElse actualText = expectedText Then

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\Extensions\SemanticModelExtensions.vb (1)

90Return If(String.IsNullOrWhiteSpace(result), [Shared].Extensions.ITypeSymbolExtensions.DefaultParameterName, result)

Microsoft.CodeAnalysis.Workspaces (18)

FindSymbols\Declarations\DeclarationFinder_AllDeclarations.cs (1)

34if (string.IsNullOrWhiteSpace(query.Name))

FindSymbols\Declarations\DeclarationFinder_SourceDeclarations.cs (2)

38if (string.IsNullOrWhiteSpace(name)) 76if (string.IsNullOrWhiteSpace(name))

FindSymbols\SymbolFinder_Declarations_CustomQueries.cs (2)

51if (query.Name != null && string.IsNullOrWhiteSpace(query.Name)) 96if (query.Name != null && string.IsNullOrWhiteSpace(query.Name))

PatternMatching\FuzzyPatternMatcher.cs (1)

31_invalidPattern = string.IsNullOrWhiteSpace(pattern) || pattern.Length < WordSimilarityChecker.MinFuzzyLength;

PatternMatching\PatternMatcher.cs (1)

149=> _invalidPattern || string.IsNullOrWhiteSpace(candidate);

Shared\Utilities\DocumentationComment.cs (4)

258if (!string.IsNullOrWhiteSpace(name) && !_comment._parameterTexts.ContainsKey(name)) 269if (!string.IsNullOrWhiteSpace(name) && !_comment._typeParameterTexts.ContainsKey(name)) 280if (!string.IsNullOrWhiteSpace(type)) 294if (!string.IsNullOrWhiteSpace(cref))

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\RoslynString.cs (2)

17/// <inheritdoc cref="string.IsNullOrWhiteSpace(string)"/> 19=> string.IsNullOrWhiteSpace(value);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Indentation\AbstractIndentation.Indenter.cs (1)

137while (token != default && string.IsNullOrWhiteSpace(token.ToString()))

TaskList\TaskListItemDescriptor.cs (1)

37!string.IsNullOrWhiteSpace(token) &&

Workspace\Host\PersistentStorage\IPersistentStorageConfiguration.cs (2)

67if (string.IsNullOrWhiteSpace(solutionKey.FilePath)) 97return string.IsNullOrWhiteSpace(val) ? "None" : val;

Workspace\Solution\ProjectInfo.cs (1)

406=> nameof(ProjectInfo) + " " + Name + (!string.IsNullOrWhiteSpace(FilePath) ? " " + FilePath : "");

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

MSBuild\ProjectFile\Extensions.cs (2)

82return !string.IsNullOrWhiteSpace(aliasesText) 91return string.IsNullOrWhiteSpace(referenceOutputAssemblyText) ||

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\RoslynString.cs (2)

17/// <inheritdoc cref="string.IsNullOrWhiteSpace(string)"/> 19=> string.IsNullOrWhiteSpace(value);

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

ProjectFileInfo.cs (1)

166=> string.IsNullOrWhiteSpace(TargetFramework)

Microsoft.Data.Analysis (2)

DataFrame.cs (2)

741if (string.IsNullOrWhiteSpace(variableName)) 746if (string.IsNullOrWhiteSpace(valueName))

Microsoft.Data.Analysis.Tests (2)

test\Microsoft.ML.TestFramework\BaseTestClass.cs (2)

106if (string.IsNullOrWhiteSpace(name)) 113if (string.IsNullOrWhiteSpace(name))

Microsoft.Deployment.DotNet.Releases (13)

ProductRelease.cs (1)

58public bool IsPreview => !string.IsNullOrWhiteSpace(Version.Prerelease);

ReleaseVersion.cs (12)

Microsoft.Diagnostics.NETCore.Client (1)

DiagnosticsClient\DiagnosticsClient.cs (1)

904if (string.IsNullOrWhiteSpace(message))

Microsoft.DotNet.ApiCompat.Task (1)

ValidateAssembliesTask.cs (1)

204if (string.IsNullOrWhiteSpace(replacementString))

Microsoft.DotNet.ApiSymbolExtensions (2)

Filtering\DocIdSymbolFilter.cs (2)

30if (string.IsNullOrWhiteSpace(docIdsFile)) 81if (!string.IsNullOrWhiteSpace(id) && !id.StartsWith('#') && !id.StartsWith("//"))

Microsoft.DotNet.Arcade.Sdk (9)

src\DownloadFile.cs (3)

67if (string.IsNullOrWhiteSpace(Uri) && (Uris == null || Uris.Count() == 0)) { 74if (!string.IsNullOrWhiteSpace(Uri)) { 84if (!string.IsNullOrWhiteSpace(encodedToken))

src\InstallDotNetCore.cs (5)

208if (includeRuntimeSourceOptions && !string.IsNullOrWhiteSpace(RuntimeSourceFeed)) 214if (includeRuntimeSourceOptions && !string.IsNullOrWhiteSpace(RuntimeSourceFeed) && !string.IsNullOrWhiteSpace(RuntimeSourceFeedKey)) 224if (!string.IsNullOrWhiteSpace(architecture)) 228else if (!string.IsNullOrWhiteSpace(Platform) && !string.Equals(Platform, "AnyCpu", StringComparison.OrdinalIgnoreCase))

src\ValidateLicense.cs (1)

51where !string.IsNullOrWhiteSpace(line)

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

src\CreateWixBuildWixpack.cs (2)

96if (string.IsNullOrWhiteSpace(WixpackWorkingDir)) 462if (string.IsNullOrWhiteSpace(entry))

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

GeneratePackageReport.cs (1)

297if (String.IsNullOrWhiteSpace(packageItem.TargetPath))

GetApplicableAssetsFromPackages.cs (1)

156if (String.IsNullOrWhiteSpace(packageItem.TargetPath))

PackageItem.cs (2)

21if (!String.IsNullOrWhiteSpace(value)) 71if (!String.IsNullOrWhiteSpace(versionString))

ValidatePackage.cs (2)

450return !String.IsNullOrWhiteSpace(path) && Path.GetExtension(path).Equals(".dll", StringComparison.OrdinalIgnoreCase); 487if (!String.IsNullOrWhiteSpace(runtimeIdList))

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

Msi\WixDocument.cs (1)

62if (string.IsNullOrWhiteSpace(id))

Msi\WixXmlExtensions.cs (2)

58if (!string.IsNullOrWhiteSpace(name)) 91if (!string.IsNullOrWhiteSpace(root))

Swix\SwixComponent.cs (1)

162Version componentVersion = resourceItem != null && !string.IsNullOrWhiteSpace(resourceItem.GetMetadata(Metadata.Version)) ?

Utils.cs (1)

57(string.IsNullOrWhiteSpace(suffix) ? null : $".{suffix}");

WorkloadPackageBase.cs (2)

312!string.IsNullOrWhiteSpace(packageId) && packageId.IndexOf(separator) > -1 ? 330if (!string.IsNullOrWhiteSpace(package.GetMetadata(Metadata.MsiVersion)))

Microsoft.DotNet.Cli.Definitions (15)

Commands\New\CommandDefinitionExtensions.cs (3)

74if (!string.IsNullOrWhiteSpace(token.Value)) 98if (optionResult.IdentifierToken is { } && !string.IsNullOrWhiteSpace(optionResult.IdentifierToken.Value)) 104if (token is { } t && !string.IsNullOrWhiteSpace(t.Value))

Commands\New\SharedOptionsFactory.cs (1)

155values.AddRange(value.Split(",", StringSplitOptions.TrimEntries).Where(s => !string.IsNullOrWhiteSpace(s)));

Common\CommonOptions.cs (1)

208return string.IsNullOrWhiteSpace(configuration) ? null : configuration;

Help\HelpBuilder.cs (7)

142if (!string.IsNullOrWhiteSpace(second)) 257.Where(value => !string.IsNullOrWhiteSpace(value)) 286if (string.IsNullOrWhiteSpace(text)) 389return string.Join(" ", GetUsageParts().Where(x => !string.IsNullOrWhiteSpace(x))); 479if (!string.IsNullOrWhiteSpace(heading)) 484if (!string.IsNullOrWhiteSpace(description)) 532if (string.IsNullOrWhiteSpace(displayedDefaultValue))

Help\HelpBuilder.Default.cs (2)

61if (!string.IsNullOrWhiteSpace(helpName)) 240if (!string.IsNullOrWhiteSpace(argumentFirstColumnText))

src\sdk\src\Resolvers\Microsoft.DotNet.NativeWrapper\EnvironmentProvider.cs (1)

88if (!string.IsNullOrWhiteSpace(dotnetExeFromPath))

Microsoft.DotNet.Cli.Telemetry (5)

Implementation\AzureMonitorConnectionString.cs (3)

30if (string.IsNullOrWhiteSpace(connectionString)) 53else if (key.Equals(IngestionEndpointName, StringComparison.OrdinalIgnoreCase) && !string.IsNullOrWhiteSpace(value)) 59if (string.IsNullOrWhiteSpace(instrumentationKey))

PersistentStorageLoggerOptionsExtensions.cs (1)

40if (connectionString is null || string.IsNullOrWhiteSpace(telemetryOptions.StorageDirectory))

PersistentStorageTracerProviderBuilderExtensions.cs (1)

39if (connectionString is null || string.IsNullOrWhiteSpace(options.StorageDirectory))

Microsoft.DotNet.Cli.Utils (10)

AnsiConsole.cs (1)

18_ansiEnabled = string.IsNullOrWhiteSpace(Environment.GetEnvironmentVariable("NO_COLOR"));

Command.cs (1)

207if (string.IsNullOrWhiteSpace(info.Arguments))

DependencyProvider.cs (3)

98if (string.IsNullOrWhiteSpace(providerKeyName)) 122if (string.IsNullOrWhiteSpace(dependent)) 144if (string.IsNullOrWhiteSpace(dependent))

EnvironmentProvider.cs (1)

48.Where(p => !string.IsNullOrWhiteSpace(p))

Extensions\AnsiExtensions.cs (1)

12if (!string.IsNullOrWhiteSpace(environment))

MSBuildForwardingAppWithoutLogging.cs (2)

90if (string.IsNullOrWhiteSpace(tlpDefault)) 95if (!string.IsNullOrWhiteSpace(tlpDefault))

PathUtility.cs (1)

331if (string.IsNullOrWhiteSpace(path))

Microsoft.DotNet.CodeAnalysis (2)

Analyzers\MembersMustExistAnalyzer.cs (1)

75if (!string.IsNullOrWhiteSpace(lineStr) && !lineStr.StartsWith(CommentDelimiter))

Analyzers\PinvokeAnalyzer.cs (1)

80if (!string.IsNullOrWhiteSpace(lineStr) && !lineStr.StartsWith("<!--"))

Microsoft.DotNet.HotReload.Watch (1)

Browser\BrowserLauncher.cs (1)

56=> string.IsNullOrWhiteSpace(profileLaunchUrl) ? outputLaunchUrl :

Microsoft.DotNet.NativeWrapper (1)

EnvironmentProvider.cs (1)

88if (!string.IsNullOrWhiteSpace(dotnetExeFromPath))

Microsoft.DotNet.ProjectTools (1)

src\sdk\src\Cli\Microsoft.DotNet.FileBasedPrograms\VirtualProjectBuilder.cs (1)

628Debug.Assert(!string.IsNullOrWhiteSpace(artifactsPath));

Microsoft.DotNet.TemplateLocator (6)

src\sdk\src\Resolvers\Microsoft.NET.Sdk.WorkloadManifestReader\SdkDirectoryWorkloadManifestProvider.cs (2)

71if (string.IsNullOrWhiteSpace(sdkVersion)) 76if (string.IsNullOrWhiteSpace(sdkRootPath))

src\sdk\src\Resolvers\Microsoft.NET.Sdk.WorkloadManifestReader\SdkFeatureBand.cs (1)

112var release = string.IsNullOrWhiteSpace(releaseVersion.Prerelease) ? string.Empty : $"-{releaseVersion.Prerelease}";

src\sdk\src\Resolvers\Microsoft.NET.Sdk.WorkloadManifestReader\WorkloadPackId.cs (1)

22if (string.IsNullOrWhiteSpace(id))

TemplateLocator.cs (2)

43if (string.IsNullOrWhiteSpace(sdkVersion)) 48if (string.IsNullOrWhiteSpace(dotnetRootPath))

Microsoft.DotNet.XliffTasks (1)

Model\ResxDocument.cs (1)

44if (string.IsNullOrWhiteSpace(value))

Microsoft.Extensions.AI (22)

ChatCompletion\FunctionInvokingChatClient.cs (3)

310originalMessages, !string.IsNullOrWhiteSpace(options?.ConversationId), toolMessageId: null, functionCallContentFallbackMessageId: null); 481originalMessages, !string.IsNullOrWhiteSpace(options?.ConversationId), toolMessageId, functionCallContentFallbackMessageId); 1556if (!string.IsNullOrWhiteSpace(m.Response.Reason))

ChatCompletion\OpenTelemetryChatClient.cs (3)

282string.IsNullOrWhiteSpace(modelId) ? OpenTelemetryConsts.GenAI.ChatName : $"{OpenTelemetryConsts.GenAI.ChatName} {modelId}", 451if (!string.IsNullOrWhiteSpace(response.ResponseId)) 526if (!string.IsNullOrWhiteSpace(options?.Instructions))

ChatCompletion\OpenTelemetryImageGenerator.cs (1)

140string.IsNullOrWhiteSpace(modelId) ? OpenTelemetryConsts.GenAI.GenerateContentName : $"{OpenTelemetryConsts.GenAI.GenerateContentName} {modelId}",

ChatRouting\SemanticRoutingChatClient.cs (2)

157if (string.IsNullOrWhiteSpace(utterance)) 179if (string.IsNullOrWhiteSpace(query))

Common\OtelMessageSerializer.cs (2)

69case TextContent tc when !string.IsNullOrWhiteSpace(tc.Text): 73case TextReasoningContent trc when !string.IsNullOrWhiteSpace(trc.Text):

Embeddings\OpenTelemetryEmbeddingGenerator.cs (1)

144string.IsNullOrWhiteSpace(modelId) ? OpenTelemetryConsts.GenAI.EmbeddingsName : $"{OpenTelemetryConsts.GenAI.EmbeddingsName} {modelId}",

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Realtime\OpenTelemetryRealtimeClientSession.cs (5)

381if (!string.IsNullOrWhiteSpace(responseCreateMsg.Instructions)) 670string.IsNullOrWhiteSpace(modelId) ? OpenTelemetryConsts.GenAI.RealtimeName : $"{OpenTelemetryConsts.GenAI.RealtimeName} {modelId}", 715if (!string.IsNullOrWhiteSpace(options.Instructions)) 823if (!string.IsNullOrWhiteSpace(response.ResponseId)) 833if (!string.IsNullOrWhiteSpace(response.Status))

SpeechToText\OpenTelemetrySpeechToTextClient.cs (2)

201string.IsNullOrWhiteSpace(modelId) ? OpenTelemetryConsts.GenAI.GenerateContentName : $"{OpenTelemetryConsts.GenAI.GenerateContentName} {modelId}", 288if (!string.IsNullOrWhiteSpace(response.ResponseId))

TextToSpeech\OpenTelemetryTextToSpeechClient.cs (2)

200string.IsNullOrWhiteSpace(modelId) ? OpenTelemetryConsts.GenAI.GenerateContentName : $"{OpenTelemetryConsts.GenAI.GenerateContentName} {modelId}", 283if (!string.IsNullOrWhiteSpace(response.ResponseId))

Microsoft.Extensions.AI.Abstractions (11)

ChatCompletion\ChatMessage.cs (2)

66set => _authorName = string.IsNullOrWhiteSpace(value) ? null : value; 116!string.IsNullOrWhiteSpace(text) ? new TextContent(text) :

ChatCompletion\ChatResponseUpdate.cs (2)

88set => field = string.IsNullOrWhiteSpace(value) ? null : value; 183!string.IsNullOrWhiteSpace(text) ? new TextContent(text) :

Contents\ErrorContent.cs (2)

42(!string.IsNullOrWhiteSpace(ErrorCode) ? $" ({ErrorCode})" : string.Empty) + 43(!string.IsNullOrWhiteSpace(Details) ? $" - \"{Details}\"" : string.Empty);

Functions\AIFunctionFactory.cs (1)

913if (string.IsNullOrWhiteSpace(parameter.Name))

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Utilities\AIJsonUtilities.Schema.Create.cs (3)

94if (string.IsNullOrWhiteSpace(parameter.Name)) 155if (!string.IsNullOrWhiteSpace(title)) 160if (!string.IsNullOrWhiteSpace(description))

Microsoft.Extensions.AI.Evaluation (6)

ChatMessageExtensions.cs (1)

126return string.IsNullOrWhiteSpace(author)

EvaluationMetricExtensions.cs (1)

157if (!string.IsNullOrWhiteSpace(response.ModelId))

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Utilities\ModelInfo.cs (3)

95if (!string.IsNullOrWhiteSpace(host)) 123=> !string.IsNullOrWhiteSpace(modelProvider) && KnownHostMonikersRegex.IsMatch(modelProvider); 130=> !string.IsNullOrWhiteSpace(modelProvider) && LocalMachineHostMonikerRegex.IsMatch(modelProvider);

Microsoft.Extensions.AI.Evaluation.Console (11)

Commands\ReportCommand.cs (1)

275string.IsNullOrWhiteSpace(value))

parent\Microsoft.Extensions.AI.Evaluation\Utilities\ModelInfo.cs (3)

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Telemetry\DeviceIdHelper.cs (2)

37if (string.IsNullOrWhiteSpace(deviceId)) 138if (string.IsNullOrWhiteSpace(xdgCacheHome))

Telemetry\EnvironmentHelper.cs (1)

56if (Array.TrueForAll(variables, static variable => !string.IsNullOrWhiteSpace(Environment.GetEnvironmentVariable(variable))))

Telemetry\TelemetryConstants.cs (2)

125if (string.IsNullOrWhiteSpace(homeDirectoryPath)) 133string.IsNullOrWhiteSpace(homeDirectoryPath)

Telemetry\TelemetryExtensions.cs (1)

26string.IsNullOrWhiteSpace(value) ? defaultValue : value;

Microsoft.Extensions.AI.Evaluation.NLP (4)

BLEUEvaluator.cs (1)

54if (string.IsNullOrWhiteSpace(modelResponse.Text))

F1Evaluator.cs (1)

54if (string.IsNullOrWhiteSpace(modelResponse.Text))

GLEUEvaluator.cs (1)

54if (string.IsNullOrWhiteSpace(modelResponse.Text))

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Microsoft.Extensions.AI.Evaluation.Quality (15)

CoherenceEvaluator.cs (1)

81if (string.IsNullOrWhiteSpace(modelResponse.Text))

CompletenessEvaluator.cs (1)

78if (string.IsNullOrWhiteSpace(modelResponse.Text))

EquivalenceEvaluator.cs (1)

79if (string.IsNullOrWhiteSpace(modelResponse.Text))

FluencyEvaluator.cs (1)

75if (string.IsNullOrWhiteSpace(modelResponse.Text))

GroundednessEvaluator.cs (1)

76if (string.IsNullOrWhiteSpace(modelResponse.Text))

IntentResolutionEvaluator.cs (3)

353if (string.IsNullOrWhiteSpace(repairedJson)) 391if (!string.IsNullOrWhiteSpace(rating.AgentPerceivedIntent)) 396if (!string.IsNullOrWhiteSpace(rating.ActualUserIntent))

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

RelevanceEvaluator.cs (2)

79if (!messages.TryGetUserRequest(out ChatMessage? userRequest) || string.IsNullOrWhiteSpace(userRequest.Text)) 88if (string.IsNullOrWhiteSpace(modelResponse.Text))

RelevanceTruthAndCompletenessEvaluator.cs (3)

100string.IsNullOrWhiteSpace(userRequest.Text)) 109if (string.IsNullOrWhiteSpace(modelResponse.Text)) 301if (string.IsNullOrWhiteSpace(repairedJson))

RetrievalEvaluator.cs (1)

84if (!messages.TryGetUserRequest(out ChatMessage? userRequest) || string.IsNullOrWhiteSpace(userRequest.Text))

Microsoft.Extensions.AI.Evaluation.Reporting (6)

parent\parent\Microsoft.Extensions.AI.Evaluation\Utilities\ModelInfo.cs (3)

parent\parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

ReportingConfiguration.cs (2)

270if (!string.IsNullOrWhiteSpace(providerName)) 276if (!string.IsNullOrWhiteSpace(modelId))

Microsoft.Extensions.AI.Evaluation.Reporting.Azure (1)

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Microsoft.Extensions.AI.Evaluation.Safety (11)

ContentSafetyEvaluator.cs (1)

115!string.IsNullOrWhiteSpace(contextString))

ContentSafetyService.cs (3)

226if (string.IsNullOrWhiteSpace(discoveryUrl)) 280if (!string.IsNullOrWhiteSpace(supportedCapability) && 336if (string.IsNullOrWhiteSpace(resultUrl))

ContentSafetyServiceConfiguration.cs (3)

80!string.IsNullOrWhiteSpace(SubscriptionId) && 81!string.IsNullOrWhiteSpace(ResourceGroupName) && 82!string.IsNullOrWhiteSpace(ProjectName) &&

parent\Microsoft.Extensions.AI.Evaluation\Utilities\ModelInfo.cs (3)

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Microsoft.Extensions.AI.Integration.Tests (1)

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Microsoft.Extensions.AI.OpenAI (16)

OpenAIAssistantsChatClient.cs (4)

269if (!string.IsNullOrWhiteSpace(tau.InputFileId)) 274else if (!string.IsNullOrWhiteSpace(tau.OutputFileId)) 592string.IsNullOrWhiteSpace(runAndCallIDs[0]) || // run ID 593string.IsNullOrWhiteSpace(runAndCallIDs[1]) || // call ID

OpenAIChatClient.cs (3)

155if (chatOptions?.Instructions is { } instructions && !string.IsNullOrWhiteSpace(instructions)) 463if (!string.IsNullOrWhiteSpace(fci.Name)) 538if (!string.IsNullOrWhiteSpace(toolCall.FunctionName))

OpenAIClientExtensions.cs (4)

374if (!string.IsNullOrWhiteSpace(serviceTier)) 379if (!string.IsNullOrWhiteSpace(systemFingerprint)) 412bool needsServiceTier = capturedServiceTier is null && !string.IsNullOrWhiteSpace(serviceTier); 413bool needsSystemFingerprint = capturedSystemFingerprint is null && !string.IsNullOrWhiteSpace(systemFingerprint);

OpenAIResponsesChatClient.cs (4)

258Inputs = !string.IsNullOrWhiteSpace(cicri.Code) ? [new DataContent(Encoding.UTF8.GetBytes(cicri.Code), OpenAIClientExtensions.PythonMediaType)] : null, 1295if (!string.IsNullOrWhiteSpace(text)) 1696if (!string.IsNullOrWhiteSpace(part.InputImageFileId)) 1700else if (!string.IsNullOrWhiteSpace(part.InputFileId))

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Microsoft.Extensions.AI.Templates.Tests (3)

TestCommandResult.cs (3)

26{(!string.IsNullOrWhiteSpace(StandardOutput) ? 32{(!string.IsNullOrWhiteSpace(StandardError) ? 40Assert.True(ExitCode == 0 && string.IsNullOrWhiteSpace(StandardError), output);

Microsoft.Extensions.AmbientMetadata.Application (1)

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Microsoft.Extensions.AmbientMetadata.Build (1)

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Microsoft.Extensions.AsyncState (1)

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Microsoft.Extensions.Caching.Hybrid (4)

Internal\DefaultHybridCache.cs (1)

287if (string.IsNullOrWhiteSpace(key))

Internal\DefaultHybridCache.TagInvalidation.cs (1)

26if (string.IsNullOrWhiteSpace(tag))

Internal\TagSet.cs (1)

225if (string.IsNullOrWhiteSpace(tag))

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Microsoft.Extensions.Compliance.Abstractions (2)

Classification\DataClassification.cs (1)

99public override string ToString() => string.IsNullOrWhiteSpace(TaxonomyName) ? Value : $"{TaxonomyName}:{Value}";

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Microsoft.Extensions.Compliance.Redaction (1)

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Microsoft.Extensions.Compliance.Testing (1)

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Microsoft.Extensions.Configuration.Binder (1)

ConfigurationBinder.cs (1)

1205return !string.IsNullOrWhiteSpace(name) ? name : property.Name;

Microsoft.Extensions.Configuration.Ini (1)

IniStreamConfigurationProvider.cs (1)

39if (string.IsNullOrWhiteSpace(line))

Microsoft.Extensions.DataIngestion (2)

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Processors\ClassificationEnricher.cs (1)

36if (string.IsNullOrWhiteSpace(fallbackClass))

Microsoft.Extensions.DataIngestion.Abstractions (1)

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Microsoft.Extensions.DataIngestion.Markdig (2)

MarkdownParser.cs (1)

311if (!string.IsNullOrWhiteSpace(MapBlock(outputContent, previousWasBreak: false, tableCell[0]).Text))

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Microsoft.Extensions.DataIngestion.MarkItDown (2)

parent\Microsoft.Extensions.DataIngestion.Markdig\MarkdownParser.cs (1)

311if (!string.IsNullOrWhiteSpace(MapBlock(outputContent, previousWasBreak: false, tableCell[0]).Text))

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Microsoft.Extensions.DependencyInjection.AutoActivation (1)

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Microsoft.Extensions.Diagnostics.ExceptionSummarization (1)

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Microsoft.Extensions.Diagnostics.HealthChecks.Common (1)

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Microsoft.Extensions.Diagnostics.HealthChecks.ResourceUtilization (1)

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Microsoft.Extensions.Diagnostics.Probes (1)

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Microsoft.Extensions.Diagnostics.ResourceMonitoring (1)

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

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

KubernetesMetadata.cs (1)

60if (string.IsNullOrWhiteSpace(value))

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Microsoft.Extensions.Diagnostics.Testing (1)

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Microsoft.Extensions.Hosting.Testing (1)

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Microsoft.Extensions.Http.Resilience (1)

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Microsoft.Extensions.Identity.Core (7)

AuthenticatorTokenProvider.cs (1)

25return !string.IsNullOrWhiteSpace(key);

EmailTokenProvider.cs (1)

25return !string.IsNullOrWhiteSpace(email) && await manager.IsEmailConfirmedAsync(user).ConfigureAwait(false);

PasswordValidator.cs (1)

46if (string.IsNullOrWhiteSpace(password) || password.Length < options.RequiredLength)

PhoneNumberTokenProvider.cs (1)

36return !string.IsNullOrWhiteSpace(phoneNumber) && await manager.IsPhoneNumberConfirmedAsync(user).ConfigureAwait(false);

RoleValidator.cs (1)

50if (string.IsNullOrWhiteSpace(roleName))

UserValidator.cs (2)

56if (string.IsNullOrWhiteSpace(userName)) 85if (string.IsNullOrWhiteSpace(email))

Microsoft.Extensions.Logging.Configuration (1)

LoggerProviderConfigurationFactory.cs (1)

31if (!string.IsNullOrWhiteSpace(alias))

Microsoft.Extensions.Logging.Generators (6)

LoggerMessageGenerator.Emitter.cs (3)

89if (!string.IsNullOrWhiteSpace(lc.Namespace)) 140if (!string.IsNullOrWhiteSpace(lc.Namespace)) 436string eventName = string.IsNullOrWhiteSpace(lm.EventName) ? $"nameof({lm.Name})" : $"\"{lm.EventName}\"";

LoggerMessageGenerator.Parser.cs (3)

234eventId = GetNonRandomizedHashCode(string.IsNullOrWhiteSpace(eventName) ? logMethodSymbol.Name : eventName); 360if (string.IsNullOrWhiteSpace(paramName)) 873if (string.IsNullOrWhiteSpace(templateName)) // braces with no named argument, such as {} and { }

Microsoft.Extensions.ObjectPool.DependencyInjection (1)

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Microsoft.Extensions.Options.Contextual (1)

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Microsoft.Extensions.Resilience (1)

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Microsoft.Extensions.ServiceDiscovery (4)

Configuration\ConfigurationServiceEndpointProvider.cs (2)

76if (string.IsNullOrWhiteSpace(_endpointName)) 110if (!string.IsNullOrWhiteSpace(namedSection.Value))

Configuration\ConfigurationServiceEndpointProviderOptionsValidator.cs (1)

12if (string.IsNullOrWhiteSpace(options.SectionName))

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Microsoft.Extensions.ServiceDiscovery.Abstractions (2)

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

ServiceEndpoint.cs (1)

66if (!string.IsNullOrWhiteSpace(value))

Microsoft.Extensions.ServiceDiscovery.Dns (4)

DnsSrvServiceEndpointProviderFactory.cs (3)

35if (optionsValue.ServiceDomainNameCallback == null && string.IsNullOrWhiteSpace(_querySuffix)) 69if (!string.IsNullOrWhiteSpace(qualifiedNamespace)) 75if (!string.IsNullOrWhiteSpace(serviceAccountNamespace))

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Microsoft.Extensions.ServiceDiscovery.Yarp (1)

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Microsoft.Extensions.Telemetry (2)

Latency\Internal\LatencyContextRegistrySet.cs (1)

54if (string.IsNullOrWhiteSpace(name))

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Microsoft.Extensions.Telemetry.Abstractions (2)

Latency\Registration\LatencyRegistryServiceCollectionExtensions.cs (1)

73if (string.IsNullOrWhiteSpace(name))

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Microsoft.Extensions.TimeProvider.Testing (1)

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Microsoft.Extensions.VectorData.Abstractions (2)

parent\parent\parent\eng\MSBuild\parent\parent\src\Shared\Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

RecordDefinition\VectorStoreProperty.cs (1)

25if (string.IsNullOrWhiteSpace(name))

Microsoft.Gen.BuildMetadata (1)

GeneratorUtilities.cs (1)

148=> options.TryGetValue(name, out value) && !string.IsNullOrWhiteSpace(value);

Microsoft.Gen.ComplianceReports (2)

ComplianceReportsGenerator.cs (1)

89if (string.IsNullOrWhiteSpace(_directory))

GeneratorUtilities.cs (1)

148=> options.TryGetValue(name, out value) && !string.IsNullOrWhiteSpace(value);

Microsoft.Gen.ContextualOptions (1)

GeneratorUtilities.cs (1)

148=> options.TryGetValue(name, out value) && !string.IsNullOrWhiteSpace(value);

Microsoft.Gen.Logging (8)

Emitter.cs (2)

37if (!string.IsNullOrWhiteSpace(lt.Namespace)) 90if (!string.IsNullOrWhiteSpace(lt.Namespace))

Emitter.Method.cs (2)

22string eventName = string.IsNullOrWhiteSpace(lm.EventName) ? $"nameof({lm.Name})" : $"\"{lm.EventName}\""; 99var eventNameToCalcId = string.IsNullOrWhiteSpace(lm.EventName) ? lm.Name : lm.EventName!;

GeneratorUtilities.cs (1)

148=> options.TryGetValue(name, out value) && !string.IsNullOrWhiteSpace(value);

Parser.cs (2)

261string.IsNullOrWhiteSpace(lm.Message) && 589if (string.IsNullOrWhiteSpace(paramName))

TemplateProcessor.cs (1)

60if (string.IsNullOrWhiteSpace(templateName))

Microsoft.Gen.MetadataExtractor (7)

ComplianceReportsGenerator.cs (1)

89if (string.IsNullOrWhiteSpace(_directory))

GeneratorUtilities.cs (1)

148=> options.TryGetValue(name, out value) && !string.IsNullOrWhiteSpace(value);

MetadataReportsGenerator.cs (1)

78if (string.IsNullOrWhiteSpace(path))

MetricsReportsGenerator.cs (1)

53if (string.IsNullOrWhiteSpace(path))

Parser_2.cs (3)

270if (!string.IsNullOrWhiteSpace(ctorArg0)) 450MetricName = string.IsNullOrWhiteSpace(strongTypeAttrParams.MetricNameFromAttribute) ? metricNameFromMethod : strongTypeAttrParams.MetricNameFromAttribute, 529if (string.IsNullOrWhiteSpace(paramName))

Microsoft.Gen.Metrics (11)

Emitter.cs (3)

52if (!string.IsNullOrWhiteSpace(nspace)) 74if (!string.IsNullOrWhiteSpace(nspace)) 258var nsprefix = string.IsNullOrWhiteSpace(nspace)

GeneratorUtilities.cs (1)

148=> options.TryGetValue(name, out value) && !string.IsNullOrWhiteSpace(value);

MetricFactoryEmitter.cs (4)

62if (!string.IsNullOrWhiteSpace(nspace)) 90if (!string.IsNullOrWhiteSpace(nspace)) 100var nsprefix = string.IsNullOrWhiteSpace(nspace) 141var nsprefix = string.IsNullOrWhiteSpace(nspace)

Parser.cs (3)

Microsoft.Gen.MetricsReports (5)

GeneratorUtilities.cs (1)

148=> options.TryGetValue(name, out value) && !string.IsNullOrWhiteSpace(value);

MetricsReportsGenerator.cs (1)

53if (string.IsNullOrWhiteSpace(path))

Parser.cs (3)

Microsoft.Maui (9)

Converters\EasingTypeConverter.cs (1)

26 if (string.IsNullOrWhiteSpace(strValue))

Fonts\FontFile.cs (1)

158 if (!string.IsNullOrWhiteSpace(currentString))

Fonts\FontRegistrar.cs (2)

37 if (!string.IsNullOrWhiteSpace(alias)) 46 if (!string.IsNullOrWhiteSpace(alias))

Handlers\HybridWebView\FileExtensionContentTypeProvider.cs (1)

456 if (string.IsNullOrWhiteSpace(path))

Handlers\HybridWebView\HybridWebViewHandler.cs (1)

144 if (string.IsNullOrWhiteSpace(result))

Handlers\HybridWebView\HybridWebViewInvokeJavaScriptException.cs (1)

27 if (!string.IsNullOrWhiteSpace(name))

Hosting\Fonts\FontCollectionExtensions.cs (2)

21 if (string.IsNullOrWhiteSpace(filename)) 42 if (string.IsNullOrWhiteSpace(filename))

Microsoft.Maui.Controls (17)

BindablePropertyConverter.cs (2)

26 if (string.IsNullOrWhiteSpace(value)) 80 if (string.IsNullOrWhiteSpace(strValue))

Binding.cs (2)

33 if (string.IsNullOrWhiteSpace(path)) 77 _expression = new BindingExpression(this, !string.IsNullOrWhiteSpace(value) ? value : SelfPath);

Brush\BrushTypeConverter.cs (1)

108 if (string.IsNullOrWhiteSpace(css))

DragAndDrop\DragGestureRecognizer.cs (1)

133 if (String.IsNullOrWhiteSpace(args.Data.Text))

DragAndDrop\DropGestureRecognizer.cs (1)

128 if (String.IsNullOrWhiteSpace(text))

RadioButton\RadioButton.cs (2)

681 if (!string.IsNullOrWhiteSpace(contentAsString) && string.IsNullOrWhiteSpace(semantics?.Description))

Routing.cs (2)

207 if (!String.IsNullOrWhiteSpace(route)) 240 if (string.IsNullOrWhiteSpace(route))

Shapes\PointCollectionConverter.cs (1)

35 if (string.IsNullOrWhiteSpace(point))

Shell\ShellUriHandler.cs (2)

548 if (!String.IsNullOrWhiteSpace(collapsedMatch)) 585 if (!String.IsNullOrWhiteSpace(segmentMatch))

TemplateBinding.cs (2)

30 if (string.IsNullOrWhiteSpace(path)) 144 return new BindingExpression(this, !string.IsNullOrWhiteSpace(path) ? path : SelfPath);

UriTypeConverter.cs (1)

21 if (string.IsNullOrWhiteSpace(strValue))

Microsoft.Maui.Controls.Build.Tasks (6)

CompiledConverters\ColumnDefinitionCollectionTypeConverter.cs (1)

16 if (!string.IsNullOrWhiteSpace(value))

CompiledConverters\EasingTypeConverter.cs (1)

14 if (string.IsNullOrWhiteSpace(value))

CompiledConverters\GridLengthTypeConverter.cs (1)

17 if (!string.IsNullOrWhiteSpace(value))

CompiledConverters\RowDefinitionCollectionTypeConverter.cs (1)

16 if (!string.IsNullOrWhiteSpace(value))

CompiledConverters\UriTypeConverter.cs (1)

16 if (string.IsNullOrWhiteSpace(value))

SetPropertiesVisitor.cs (1)

676 if (string.IsNullOrWhiteSpace(path))

Microsoft.Maui.Controls.DesignTools (1)

ColorDesignTypeConverter.cs (1)

195 if (string.IsNullOrWhiteSpace(str))

Microsoft.Maui.Controls.SourceGen (3)

CodeBehindGenerator.cs (1)

696 if (string.IsNullOrWhiteSpace(plat))

src\Controls\src\Xaml\TypeArgumentsParser.cs (2)

13 while (!string.IsNullOrWhiteSpace(expression)) 25 if (type is null || !string.IsNullOrWhiteSpace(remaining))

Microsoft.Maui.Controls.Xaml (2)

TypeArgumentsParser.cs (2)

13 while (!string.IsNullOrWhiteSpace(expression)) 25 if (type is null || !string.IsNullOrWhiteSpace(remaining))

Microsoft.Maui.Essentials (18)

Email\Email.shared.cs (2)

77 if (!string.IsNullOrWhiteSpace(message.Subject)) 80 if (!string.IsNullOrWhiteSpace(message.Body))

FileSystem\FileSystem.shared.cs (8)

162 if (string.IsNullOrWhiteSpace(extension)) 193 if (string.IsNullOrWhiteSpace(fullPath)) 195 if (string.IsNullOrWhiteSpace(Path.GetFileName(fullPath))) 237 if (!string.IsNullOrWhiteSpace(contentType)) 242 if (!string.IsNullOrWhiteSpace(ext)) 245 if (!string.IsNullOrWhiteSpace(content)) 266 if (!string.IsNullOrWhiteSpace(fileName)) 270 if (!string.IsNullOrWhiteSpace(FullPath))

PhoneDialer\PhoneDialer.shared.cs (1)

69 if (string.IsNullOrWhiteSpace(number))

SecureStorage\SecureStorage.shared.cs (2)

212 if (string.IsNullOrWhiteSpace(key)) 220 if (string.IsNullOrWhiteSpace(key))

Sms\Sms.shared.cs (2)

99 if (!string.IsNullOrWhiteSpace(recipient)) 114 Recipients.AddRange(recipients.Where(x => !string.IsNullOrWhiteSpace(x)));

Types\Contact.shared.cs (3)

65 get => !string.IsNullOrWhiteSpace(displayName) ? displayName : BuildDisplayName(); 112 if (string.IsNullOrWhiteSpace(GivenName)) 114 if (string.IsNullOrWhiteSpace(FamilyName))

Microsoft.Maui.Resizetizer (6)

ResizeImageInfo.cs (4)

20 string.IsNullOrWhiteSpace(Alias) 21 ? string.IsNullOrWhiteSpace(Filename) 27 string.IsNullOrWhiteSpace(Alias) || !Path.HasExtension(Alias) 28 ? string.IsNullOrWhiteSpace(Filename) || !Path.HasExtension(Filename)

SkiaSharpAppIconTools.cs (2)

18 var hasBackground = !string.IsNullOrWhiteSpace(info.Filename) && File.Exists(info.Filename); 19 var hasForeground = !string.IsNullOrWhiteSpace(info.ForegroundFilename) && File.Exists(info.ForegroundFilename);

Microsoft.ML.AutoML (1)

ColumnInference\ColumnTypeInference.cs (1)

376return (hasHeader && !string.IsNullOrWhiteSpace(header)) ? header : string.Format("col{0}", column.ColumnId);

Microsoft.ML.Core (44)

CommandLine\ArgumentAttribute.cs (2)

86set { _name = string.IsNullOrWhiteSpace(value) ? null : value; } 93if (string.IsNullOrWhiteSpace(_shortName))

CommandLine\CmdParser.cs (8)

ComponentModel\ComponentCatalog.cs (5)

155public bool IsHidden => string.IsNullOrWhiteSpace(UserName); 228if (!string.IsNullOrWhiteSpace(attr.DocName)) 414if (string.IsNullOrWhiteSpace(attribute.FriendlyName)) 967if (string.IsNullOrWhiteSpace(name)) 1054if (string.IsNullOrWhiteSpace(settings))

ComponentModel\LoadableClassAttribute.cs (1)

171if (loadNames.Any(s => string.IsNullOrWhiteSpace(s)))

Data\ModelLoading.cs (2)

252if (!string.IsNullOrWhiteSpace(sig) && 266if (!string.IsNullOrWhiteSpace(sigAlt) &&

Data\Repository.cs (1)

243_ectx.CheckParam(!string.IsNullOrWhiteSpace(name), nameof(name));

Data\RoleMappedSchema.cs (5)

358if (!string.IsNullOrWhiteSpace(label)) 360if (!string.IsNullOrWhiteSpace(feature)) 362if (!string.IsNullOrWhiteSpace(group)) 364if (!string.IsNullOrWhiteSpace(weight)) 366if (!string.IsNullOrWhiteSpace(name))

EntryPoints\ModuleArgs.cs (1)

55if (string.IsNullOrWhiteSpace(value))

Environment\HostEnvironmentBase.cs (5)

585if (string.IsNullOrWhiteSpace(name)) 603if (string.IsNullOrWhiteSpace(name)) 618if (string.IsNullOrWhiteSpace(name)) 639if (string.IsNullOrWhiteSpace(name)) 657if (string.IsNullOrWhiteSpace(name))

Utilities\Contracts.cs (8)

613if (string.IsNullOrWhiteSpace(s)) 619if (string.IsNullOrWhiteSpace(s)) 639if (string.IsNullOrWhiteSpace(s)) 645if (string.IsNullOrWhiteSpace(s)) 917if (string.IsNullOrWhiteSpace(s)) 923if (string.IsNullOrWhiteSpace(s)) 943if (string.IsNullOrWhiteSpace(s)) 949if (string.IsNullOrWhiteSpace(s))

Utilities\LineParser.cs (1)

15if (string.IsNullOrWhiteSpace(line))

Utilities\PathUtils.cs (3)

71if (!string.IsNullOrWhiteSpace(customSearchDir) 79if (!string.IsNullOrWhiteSpace(envDir) 112if (!string.IsNullOrWhiteSpace(folderPrefix))

Utilities\ResourceManagerUtils.cs (1)

193if (!string.IsNullOrWhiteSpace(envTimeout) && int.TryParse(envTimeout, out var res))

Utilities\Stream.cs (1)

839if (string.IsNullOrWhiteSpace(file))

Microsoft.ML.Core.Tests (3)

UnitTests\TestEntryPoints.cs (3)

2562loader = string.IsNullOrWhiteSpace(loader) ? "" : string.Format(",'CustomSchema': '{0}'", loader); 3317string.IsNullOrWhiteSpace(loader) ? "" : string.Format(",'CustomSchema': 'sparse+ {0}'", loader), 3318string.IsNullOrWhiteSpace(trainerArgs) ? "" : trainerArgs,

Microsoft.ML.CpuMath (8)

src\Microsoft.ML.Core\Utilities\Contracts.cs (8)

Microsoft.ML.Data (66)

Commands\CrossValidationCommand.cs (3)

226if (!string.IsNullOrWhiteSpace(ImplOptions.OutputDataFile)) 293if (!string.IsNullOrWhiteSpace(ImplOptions.StratificationColumn)) 577if (string.IsNullOrWhiteSpace(outputModelFile))

Commands\DataCommand.cs (6)

218if (!string.IsNullOrWhiteSpace(ImplOptions.OutputModelFile)) 279Host.CheckUserArg(!string.IsNullOrWhiteSpace(ImplOptions.InputModelFile), nameof(ImplOptions.InputModelFile)); 335if (string.IsNullOrWhiteSpace(dataFile)) 339if (!string.IsNullOrWhiteSpace(ImplOptions.InputModelFile) && ImplOptions.Loader == null) 374Host.CheckUserArg(!string.IsNullOrWhiteSpace(ImplOptions.InputModelFile), nameof(ImplOptions.InputModelFile)); 383Host.Assert(!string.IsNullOrWhiteSpace(ImplOptions.InputModelFile));

Commands\EvaluateCommand.cs (1)

253if (!string.IsNullOrWhiteSpace(ImplOptions.OutputDataFile))

Commands\SaveDataCommand.cs (1)

132if (!string.IsNullOrWhiteSpace(ImplOptions.Columns))

Commands\SavePredictorCommand.cs (2)

63_host.CheckUserArg(!string.IsNullOrWhiteSpace(args.InputModelFile), nameof(args.InputModelFile), "Must specify input model file"); 101if (string.IsNullOrWhiteSpace(path))

Commands\ScoreCommand.cs (3)

85Host.CheckUserArg(!string.IsNullOrWhiteSpace(ImplOptions.InputModelFile), nameof(ImplOptions.InputModelFile), "The input model file is required."); 86Host.CheckUserArg(!string.IsNullOrWhiteSpace(ImplOptions.OutputDataFile), nameof(ImplOptions.OutputDataFile), "The output data file is required."); 132if (!string.IsNullOrWhiteSpace(ImplOptions.OutputModelFile))

Commands\TestCommand.cs (1)

132if (!string.IsNullOrWhiteSpace(ImplOptions.OutputDataFile))

Commands\TrainCommand.cs (7)

167if (!string.IsNullOrWhiteSpace(ImplOptions.ValidationFile)) 187if (!string.IsNullOrWhiteSpace(ImplOptions.TestFile)) 216if (string.IsNullOrWhiteSpace(dataFile)) 234if (string.IsNullOrWhiteSpace(userName)) 371if (!string.IsNullOrWhiteSpace(command)) 521ectx.CheckUserArg(!string.IsNullOrWhiteSpace(kindName.Value), nameof(TrainCommand.Arguments.CustomColumns), "Names for columns with custom kind must not be empty"); 522if (string.IsNullOrWhiteSpace(kindName.Key))

Commands\TrainTestCommand.cs (4)

91if (string.IsNullOrWhiteSpace(args.TestFile)) 153if (!string.IsNullOrWhiteSpace(ImplOptions.ValidationFile)) 173if (!string.IsNullOrWhiteSpace(ImplOptions.TestFile)) 222if (!string.IsNullOrWhiteSpace(ImplOptions.OutputDataFile))

Data\DataViewUtils.cs (3)

32if (!string.IsNullOrWhiteSpace(tag) && !schema.TryGetColumnIndex(tag, out col)) 37string name = string.IsNullOrWhiteSpace(tag) ? 62string name = string.IsNullOrWhiteSpace(tag) ?

DataLoadSave\Text\TextLoader.cs (6)

159if (string.IsNullOrWhiteSpace(Name = rgstr[istr++])) 194if (string.IsNullOrWhiteSpace(Name)) 1161if (!string.IsNullOrWhiteSpace(options.HeaderFile)) 1333if (string.IsNullOrWhiteSpace(str)) 1341if (!string.IsNullOrWhiteSpace(tmp)) 1358if (loader == null || string.IsNullOrWhiteSpace(loader.Name) || (loader.Name != LoaderSignature && loader.Name != "Text"))

Dirty\PredictionUtils.cs (2)

30if (string.IsNullOrWhiteSpace(settings)) 39errorMsg = err + (!string.IsNullOrWhiteSpace(name) ? "\nUSAGE FOR '" + name + "':\n" : "\nUSAGE:\n") + helpText;

Evaluators\EvaluatorUtils.cs (4)

118if (!string.IsNullOrWhiteSpace(name)) 150if (!string.IsNullOrWhiteSpace(defName) && schema.GetColumnOrNull(defName) is DataViewSchema.Column defCol) 173if (!string.IsNullOrWhiteSpace(name)) 1667string.IsNullOrWhiteSpace(prefix) ? "N0" : "F1");

Model\Pfa\SavePfaCommand.cs (4)

70_outputModelPath = string.IsNullOrWhiteSpace(args.Pfa) ? null : args.Pfa; 73else if (!string.IsNullOrWhiteSpace(args.Name)) 88if (string.IsNullOrWhiteSpace(toDrop)) 212if (!string.IsNullOrWhiteSpace(ImplOptions.OutputModelFile))

Prediction\Calibrator.cs (1)

946ch.CheckParam(!caliTrainer.NeedsTraining || !string.IsNullOrWhiteSpace(labelColumn), nameof(labelColumn),

Prediction\CalibratorCatalog.cs (1)

68if (!string.IsNullOrWhiteSpace(labelColumn))

Transforms\ColumnBindingsBase.cs (6)

98if (string.IsNullOrWhiteSpace(Name)) 100else if (string.IsNullOrWhiteSpace(Source)) 102return !string.IsNullOrWhiteSpace(Name); 201if (string.IsNullOrWhiteSpace(Name) || Utils.Size(Source) == 0) 226if (string.IsNullOrWhiteSpace(Name) || Utils.Size(Source) == 0) 323if (string.IsNullOrWhiteSpace(name))

Transforms\MetadataDispatcher.cs (1)

364Contracts.CheckParam(!kindsSrc.Any(k => string.IsNullOrWhiteSpace(k)), nameof(kindsSrc));

Transforms\NormalizeColumn.cs (1)

1130host.CheckUserArg(!string.IsNullOrWhiteSpace(args.LabelColumn), nameof(args.LabelColumn), "Must specify the label column name");

Transforms\TrainAndScoreTransformer.cs (1)

81env.CheckUserArg(!string.IsNullOrWhiteSpace(args.InputModelFile), nameof(args.InputModelFile), "The input model file is required.");

Transforms\ValueMapping.cs (1)

606env.CheckUserArg(!string.IsNullOrWhiteSpace(options.DataFile), nameof(options.DataFile));

Transforms\ValueToKeyMappingTransformer.cs (5)

278(!string.IsNullOrWhiteSpace(options.DataFile) || options.Loader != null || 279!string.IsNullOrWhiteSpace(options.TermsColumn))) 399if (string.IsNullOrWhiteSpace(file)) 418ch.CheckUserArg(!string.IsNullOrWhiteSpace(src), nameof(termsColumn), 430if (!string.IsNullOrWhiteSpace(src))

Utilities\ModelFileUtils.cs (2)

314h.CheckDecode(!string.IsNullOrWhiteSpace(roleStr), "Role name must not be empty"); 315h.CheckDecode(!string.IsNullOrWhiteSpace(colStr), "Column name must not be empty");

Microsoft.ML.EntryPoints (8)

JsonUtils\ExecuteGraphCommand.cs (4)

103_host.CheckUserArg(!string.IsNullOrWhiteSpace(varName), nameof(varName), "Specify a graph variable name."); 104_host.CheckUserArg(!string.IsNullOrWhiteSpace(path), nameof(path), "Specify a valid file path."); 136_host.CheckUserArg(!string.IsNullOrWhiteSpace(varName), nameof(varName), "Specify a graph variable name."); 137_host.CheckUserArg(!string.IsNullOrWhiteSpace(path), nameof(path), "Specify a valid file path.");

PermutationFeatureImportance.cs (4)

111if (string.IsNullOrWhiteSpace(slotNames[i])) 168if (string.IsNullOrWhiteSpace(slotNames[i])) 227if (string.IsNullOrWhiteSpace(slotNames[i])) 281if (string.IsNullOrWhiteSpace(slotNames[i]))

Microsoft.ML.FastTree (4)

GamModelParameters.cs (2)

749if (string.IsNullOrWhiteSpace(outFile)) 892if (hadCalibrator && !string.IsNullOrWhiteSpace(ImplOptions.OutputModelFile))

TreeEnsembleFeaturizer.cs (2)

619host.CheckUserArg(!string.IsNullOrWhiteSpace(args.TrainedModelFile) || args.Trainer != null, nameof(args.TrainedModelFile), 633if (!string.IsNullOrWhiteSpace(args.TrainedModelFile))

Microsoft.ML.ImageAnalytics (2)

ImageLoader.cs (2)

247if (!string.IsNullOrWhiteSpace(_parent.ImageFolder)) 278if (!string.IsNullOrWhiteSpace(_parent.ImageFolder))

Microsoft.ML.Maml (7)

HelpCommand.cs (7)

81if (string.IsNullOrWhiteSpace(_component)) 85if (string.IsNullOrWhiteSpace(_kind)) 290if (!string.IsNullOrWhiteSpace(info.UserName)) 345if (string.IsNullOrWhiteSpace(summary)) 450if (!string.IsNullOrWhiteSpace(_xmlFilename)) 465where !string.IsNullOrWhiteSpace(c.Info.UserName) 469string.IsNullOrWhiteSpace(c.Info.Summary) ? null : new XElement("Summary", c.Info.Summary),

Microsoft.ML.OnnxConverter (2)

SaveOnnxCommand.cs (2)

101_outputJsonModelPath = string.IsNullOrWhiteSpace(args.Json) ? null : args.Json; 415if (!string.IsNullOrWhiteSpace(ImplOptions.OutputModelFile))

Microsoft.ML.PerformanceTests (2)

BenchmarkBase.cs (2)

32if (string.IsNullOrWhiteSpace(name)) 40if (string.IsNullOrWhiteSpace(name))

Microsoft.ML.Predictor.Tests (1)

TestConcurrency.cs (1)

38if (!string.IsNullOrWhiteSpace(testFile))

Microsoft.ML.ResultProcessor (1)

ResultProcessor.cs (1)

726if (!string.IsNullOrWhiteSpace(rawLines[j]))

Microsoft.ML.StandardTrainers (4)

Standard\LinearPredictorUtils.cs (3)

184if (!string.IsNullOrWhiteSpace(userName)) 188if (!string.IsNullOrWhiteSpace(loadName)) 191if (!string.IsNullOrWhiteSpace(settings))

Standard\Online\OnlineLinear.cs (1)

144else if (!string.IsNullOrWhiteSpace(parent.OnlineLinearTrainerOptions.InitialWeights))

Microsoft.ML.Sweeper (1)

ConfigRunner.cs (1)

90if (!string.IsNullOrWhiteSpace(exe))

Microsoft.ML.TestFramework (14)

BaseTestBaseline.cs (1)

272if (string.IsNullOrWhiteSpace(name))

BaseTestClass.cs (2)

106if (string.IsNullOrWhiteSpace(name)) 113if (string.IsNullOrWhiteSpace(name))

BaseTestPredictorsMaml.cs (6)

117if (!string.IsNullOrWhiteSpace(loaderArgs)) 155string runcmd = string.Join(" ", args.Where(a => !string.IsNullOrWhiteSpace(a))); 242if (string.IsNullOrWhiteSpace(args[i])) 256runcmd = string.Join(" ", args.Where(a => !string.IsNullOrWhiteSpace(a))); 450if (val != null && !string.IsNullOrWhiteSpace(val.Path)) 460if (!string.IsNullOrWhiteSpace(sval) || ((sval == null) != (val == null)))

SubComponent.cs (1)

168if (string.IsNullOrWhiteSpace(str))

TestCommandBase.cs (4)

385if (!string.IsNullOrWhiteSpace(dataPath)) 387if (!string.IsNullOrWhiteSpace(loaderArgs)) 398if (!string.IsNullOrWhiteSpace(extraArgs)) 525if (string.IsNullOrWhiteSpace(dataPath))

Microsoft.ML.TestFrameworkCommon (7)

TestCommon.cs (7)

16if (string.IsNullOrWhiteSpace(name)) 22if (string.IsNullOrWhiteSpace(subDir)) 25if (string.IsNullOrWhiteSpace(name)) 32if (string.IsNullOrWhiteSpace(name)) 38if (string.IsNullOrWhiteSpace(name)) 46if (!string.IsNullOrWhiteSpace(path)) 53if (!string.IsNullOrWhiteSpace(path))

Microsoft.ML.TimeSeries (1)

MovingAverageTransform.cs (1)

75_weights = string.IsNullOrWhiteSpace(args.Weights) ? null : args.Weights.Split(',').Select(c => Convert.ToSingle(c)).ToArray();

Microsoft.ML.Transforms (28)

Dracula\CountTargetEncodingTransformer.cs (1)

171_host.CheckUserArg(!string.IsNullOrWhiteSpace(options.LabelColumn), nameof(options.LabelColumn), "Must specify the label column name");

ExpressionTransformer.cs (2)

79_host.Check(columns.All(col => !string.IsNullOrWhiteSpace(col.Expression))); 80_host.Check(columns.All(col => !string.IsNullOrWhiteSpace(col.Name)));

HashJoiningTransform.cs (1)

336if (!string.IsNullOrWhiteSpace(customSlotMap))

LoadTransform.cs (2)

81if (string.IsNullOrWhiteSpace(curList)) 86if (!string.IsNullOrWhiteSpace(tag))

SvmLight\SvmLightSaver.cs (4)

106var groupCol = !string.IsNullOrWhiteSpace(_groupCol) ? data.Schema.GetColumnOrNull(_groupCol) : default; 107if (!string.IsNullOrWhiteSpace(_groupCol) && !groupCol.HasValue) 110var weightCol = !string.IsNullOrWhiteSpace(_weightCol) ? data.Schema.GetColumnOrNull(_weightCol) : default; 111if (!string.IsNullOrWhiteSpace(_weightCol) && !weightCol.HasValue)

Text\LdaSingleBox.cs (1)

154if (string.IsNullOrWhiteSpace(trainOutput))

Text\NgramHashingTransformer.cs (2)

954Contracts.CheckParam(!inputColumnNames.Any(r => string.IsNullOrWhiteSpace(r)), nameof(inputColumnNames), 1022Contracts.CheckParam(!inputColumnNames.Any(r => string.IsNullOrWhiteSpace(r)), nameof(inputColumnNames),

Text\SentimentAnalyzingTransform.cs (1)

60if (string.IsNullOrWhiteSpace(args.Name))

Text\StopWordsRemovingTransformer.cs (3)

92if (!string.IsNullOrWhiteSpace(LanguagesColumn) || Language.HasValue) 333if (!string.IsNullOrWhiteSpace(stopWord)) 796ch.CheckUserArg(!string.IsNullOrWhiteSpace(stopwordsCol), nameof(Options.StopwordsColumn),

Text\TextFeaturizingEstimator.cs (1)

420_host.CheckParam(!source.Any(string.IsNullOrWhiteSpace), nameof(source));

Text\WordBagTransform.cs (6)

144h.CheckUserArg(!string.IsNullOrWhiteSpace(column.Name), nameof(column.Name)); 146h.CheckUserArg(column.Source.All(src => !string.IsNullOrWhiteSpace(src)), nameof(column.Source)); 686env.CheckUserArg(!string.IsNullOrWhiteSpace(col.Name), nameof(col.Name)); 688env.CheckUserArg(col.Source.All(src => !string.IsNullOrWhiteSpace(src)), nameof(col.Source)); 711env.CheckUserArg(!string.IsNullOrWhiteSpace(col.Name), nameof(col.Name)); 713col.Source.All(src => !string.IsNullOrWhiteSpace(src)), nameof(col.Source));

Text\WordEmbeddingsExtractor.cs (2)

240bool customLookup = !string.IsNullOrWhiteSpace(options.CustomLookupTable); 952bool customLookup = !string.IsNullOrWhiteSpace(_customLookupTable);

Text\WordHashBagProducingTransform.cs (2)

345h.CheckUserArg(!string.IsNullOrWhiteSpace(column.Name), nameof(column.Name)); 347column.Source.All(src => !string.IsNullOrWhiteSpace(src)), nameof(column.Source));

Microsoft.NET.Build.Containers (6)

AuthHandshakeMessageHandler.cs (2)

208if (string.IsNullOrWhiteSpace(privateRepoCreds.IdentityToken)) 464if (!string.IsNullOrWhiteSpace(privateRepoCreds.IdentityToken))

Registry\HttpExtensions.cs (1)

77s.AppendLine($"Response content: {(string.IsNullOrWhiteSpace(detail) ? "<empty>" : detail)}");

Tasks\ComputeDotnetBaseImageAndTag.cs (1)

176if (!string.IsNullOrWhiteSpace(ContainerFamily))

Tasks\CreateImageIndex.cs (1)

26private bool IsLocalPull => string.IsNullOrWhiteSpace(BaseRegistry);

Tasks\CreateNewImage.cs (1)

17private bool IsLocalPull => string.IsNullOrWhiteSpace(BaseRegistry);

Microsoft.NET.Build.Extensions.Tasks (3)

src\sdk\src\Tasks\Common\ItemUtilities.cs (3)

111if (string.IsNullOrWhiteSpace(sourcePath)) 132if (!string.IsNullOrWhiteSpace(value)) 146if (!string.IsNullOrWhiteSpace(destinationSubDirectory) && fileName is not null)

Microsoft.NET.Build.Tasks (14)

DependencyContextBuilder.cs (3)

113string.IsNullOrWhiteSpace(platformLibraryName)); 656string libraryPath = !string.IsNullOrWhiteSpace(library.Path) ? Path.Combine(mainProjectDirectory, library.Path) : null; 657var runtimeFile = !string.IsNullOrWhiteSpace(assembly.Path) && File.Exists(assembly.Path) ? CreateRuntimeFile(referenceProjectInfo.OutputName, assembly.Path, assembly.DestinationSubPath) :

GenerateBundle.cs (1)

68return string.IsNullOrWhiteSpace(sourcePath)

GenerateRuntimeConfigurationFiles.cs (1)

119string.IsNullOrWhiteSpace(PlatformLibraryName));

GenerateSupportedTargetFrameworkAlias.cs (1)

52var displayName = string.IsNullOrWhiteSpace(tfm.GetMetadata("DisplayName")) ? targetFrameworkAlias : tfm.GetMetadata("DisplayName");

ProcessFrameworkReferences.cs (1)

1191string netCoreRoot = string.IsNullOrWhiteSpace(NetCoreRoot) ? NetCoreRoot : TaskEnvironment.GetAbsolutePath(NetCoreRoot);

src\sdk\src\Resolvers\Microsoft.NET.Sdk.WorkloadManifestReader\SdkDirectoryWorkloadManifestProvider.cs (2)

71if (string.IsNullOrWhiteSpace(sdkVersion)) 76if (string.IsNullOrWhiteSpace(sdkRootPath))

src\sdk\src\Resolvers\Microsoft.NET.Sdk.WorkloadManifestReader\SdkFeatureBand.cs (1)

112var release = string.IsNullOrWhiteSpace(releaseVersion.Prerelease) ? string.Empty : $"-{releaseVersion.Prerelease}";

src\sdk\src\Resolvers\Microsoft.NET.Sdk.WorkloadManifestReader\WorkloadPackId.cs (1)

22if (string.IsNullOrWhiteSpace(id))

src\sdk\src\Tasks\Common\ItemUtilities.cs (3)

111if (string.IsNullOrWhiteSpace(sourcePath)) 132if (!string.IsNullOrWhiteSpace(value)) 146if (!string.IsNullOrWhiteSpace(destinationSubDirectory) && fileName is not null)

Microsoft.NET.HostModel (3)

Bundle\FileSpec.cs (2)

30return !string.IsNullOrWhiteSpace(SourcePath) && 31!string.IsNullOrWhiteSpace(BundleRelativePath);

ComHost\ClsidMap.cs (1)

63ProgId = !string.IsNullOrWhiteSpace(progId) ? progId : null

Microsoft.NET.Sdk.Publish.Tasks (2)

WebConfigTransform.cs (1)

98appPath = Path.ChangeExtension(appPath, !string.IsNullOrWhiteSpace(extension) ? extension : null);

WebJobsCommandGenerator.cs (1)

15command = Path.ChangeExtension(appName, !string.IsNullOrWhiteSpace(executableExtension) ? executableExtension : null);

Microsoft.NET.Sdk.Razor.Tasks (2)

DotnetToolTask.cs (2)

239if (!string.IsNullOrWhiteSpace(line)) 252if (!string.IsNullOrWhiteSpace(line))

Microsoft.NET.Sdk.StaticWebAssets.Tasks (10)

Compression\BrotliCompress.cs (1)

76.Where(td => !string.IsNullOrWhiteSpace(td))

Compression\GZipCompress.cs (1)

21.Where(td => !string.IsNullOrWhiteSpace(td))

JSModules\ApplyJsModules.cs (1)

120var razorItem = !string.IsNullOrWhiteSpace(explicitRazorItem) ?

ResolveStaticWebAssetsEmbeddedProjectConfiguration.cs (5)

107if (!string.IsNullOrWhiteSpace(rule.TargetFramework) && 115if (!string.IsNullOrWhiteSpace(rule.TargetFrameworkIdentifier) && 123if (!string.IsNullOrWhiteSpace(rule.TargetFrameworkVersion) && 131if (!string.IsNullOrWhiteSpace(rule.Platform) && 139if (!string.IsNullOrWhiteSpace(rule.PlatformVersion) &&

ScopedCss\ApplyCssScopes.cs (1)

126var razorItem = !string.IsNullOrWhiteSpace(explicitRazorItem) ?

ScopedCss\ConcatenateCssFiles.cs (1)

98string outputFile = string.IsNullOrWhiteSpace(OutputFile) ? OutputFile : TaskEnvironment.GetAbsolutePath(OutputFile);

Microsoft.NET.Sdk.WorkloadManifestReader (4)

SdkDirectoryWorkloadManifestProvider.cs (2)

71if (string.IsNullOrWhiteSpace(sdkVersion)) 76if (string.IsNullOrWhiteSpace(sdkRootPath))

SdkFeatureBand.cs (1)

112var release = string.IsNullOrWhiteSpace(releaseVersion.Prerelease) ? string.Empty : $"-{releaseVersion.Prerelease}";

WorkloadPackId.cs (1)

22if (string.IsNullOrWhiteSpace(id))

Microsoft.NET.Sdk.WorkloadMSBuildSdkResolver (2)

WorkloadSdkResolver.cs (2)

106if (!string.IsNullOrWhiteSpace(context.SolutionFilePath)) 110else if (!string.IsNullOrWhiteSpace(context.ProjectFilePath))

Microsoft.Private.Windows.Core (7)

src\winforms\src\Microsoft.Private.Windows.Polyfills\Exceptions\ArgumentExtensions.cs (1)

38if (string.IsNullOrWhiteSpace(argument))

System\Private\Windows\Nrbf\FullyQualifiedTypeName.cs (2)

15Debug.Assert(!string.IsNullOrWhiteSpace(assemblyName)); 16Debug.Assert(!string.IsNullOrWhiteSpace(fullTypeName));

System\Private\Windows\Ole\ClipboardCore.cs (1)

317if (string.IsNullOrWhiteSpace(format))

System\Private\Windows\Ole\Composition.NativeToManagedAdapter.cs (1)

644if (string.IsNullOrWhiteSpace(format))

System\Private\Windows\Ole\DataStore.cs (2)

29if (string.IsNullOrWhiteSpace(format)) 134if (string.IsNullOrWhiteSpace(format))

Microsoft.SourceLink.AzureDevOpsServer.Git (1)

src\sourcelink\src\Common\Utilities\NullableAttributes.cs (1)

100=> string.IsNullOrWhiteSpace(str);

Microsoft.SourceLink.AzureRepos.Git (1)

src\sourcelink\src\Common\Utilities\NullableAttributes.cs (1)

100=> string.IsNullOrWhiteSpace(str);

Microsoft.SourceLink.Bitbucket.Git (1)

src\sourcelink\src\Common\Utilities\NullableAttributes.cs (1)

100=> string.IsNullOrWhiteSpace(str);

Microsoft.SourceLink.Common (1)

src\sourcelink\src\Common\Utilities\NullableAttributes.cs (1)

100=> string.IsNullOrWhiteSpace(str);

Microsoft.SourceLink.Gitea (1)

src\sourcelink\src\Common\Utilities\NullableAttributes.cs (1)

100=> string.IsNullOrWhiteSpace(str);

Microsoft.SourceLink.Gitee (1)

src\sourcelink\src\Common\Utilities\NullableAttributes.cs (1)

100=> string.IsNullOrWhiteSpace(str);

Microsoft.SourceLink.GitHub (1)

src\sourcelink\src\Common\Utilities\NullableAttributes.cs (1)

100=> string.IsNullOrWhiteSpace(str);

Microsoft.SourceLink.GitLab (1)

src\sourcelink\src\Common\Utilities\NullableAttributes.cs (1)

100=> string.IsNullOrWhiteSpace(str);

Microsoft.SourceLink.GitWeb (1)

src\sourcelink\src\Common\Utilities\NullableAttributes.cs (1)

100=> string.IsNullOrWhiteSpace(str);

Microsoft.TemplateEngine.Abstractions (9)

Constraints\TemplateConstraintInfo.cs (1)

19if (string.IsNullOrWhiteSpace(type))

Constraints\TemplateConstraintResult.cs (4)

76if (string.IsNullOrWhiteSpace(localizedErrorMessage)) 97if (string.IsNullOrWhiteSpace(localizedErrorMessage)) 119if (string.IsNullOrWhiteSpace(type)) 124if (string.IsNullOrWhiteSpace(localizedErrorMessage))

Installer\InstallRequest.cs (2)

13if (string.IsNullOrWhiteSpace(identifier)) 27public string DisplayName => string.IsNullOrWhiteSpace(Version) ? PackageIdentifier : $"{PackageIdentifier}@{Version}";

Installer\UpdateRequest.cs (1)

21if (string.IsNullOrWhiteSpace(targetVersion))

TemplateFiltering\MatchInfo.cs (1)

21_ = string.IsNullOrWhiteSpace(name) ? throw new ArgumentException($"{nameof(name)} should not be null or empty") : false;

Microsoft.TemplateEngine.Cli (101)

ChoiceTemplateParameter.cs (1)

107if (!string.IsNullOrWhiteSpace(parameter.DefaultValue))

CliConsoleFormatter.cs (2)

61string format = !string.IsNullOrWhiteSpace(_formatterOptions.TimestampFormat) 72if (!string.IsNullOrWhiteSpace(logEntry.Category))

CliTemplateEngineHost.cs (1)

66if (string.IsNullOrWhiteSpace(workingPath) || !FileSystem.DirectoryExists(workingPath))

CliTemplateParameter.cs (10)

Commands\BaseCommand.cs (1)

281if (!string.IsNullOrWhiteSpace(ex.StackTrace))

Commands\CliPathInfo.cs (3)

17if (string.IsNullOrWhiteSpace(host.HostIdentifier)) 22if (string.IsNullOrWhiteSpace(host.Version)) 43var definedSettingsLocation = string.IsNullOrWhiteSpace(settingsLocation)

Commands\create\InstantiateCommand.cs (8)

Commands\create\InstantiateCommand.Help.cs (7)

22if (string.IsNullOrWhiteSpace(instantiateCommandArgs.ShortName)) 162if (!string.IsNullOrWhiteSpace(language)) 171if (!string.IsNullOrWhiteSpace(preferredTemplate.Author)) 176if (!string.IsNullOrWhiteSpace(preferredTemplate.Description)) 201if (string.IsNullOrWhiteSpace(language)) 237if (string.IsNullOrWhiteSpace(type)) 374if (!string.IsNullOrWhiteSpace(command.Name))

Commands\create\InstantiateCommand.NoMatchHandling.cs (1)

106if (string.IsNullOrWhiteSpace(invalidParam.ErrorMessage))

Commands\create\InstantiateCommand.TabCompletion.cs (1)

20if (string.IsNullOrWhiteSpace(templateName))

Commands\create\InstantiateCommandArgs.cs (2)

34if (!string.IsNullOrWhiteSpace(ShortName)) 63if (!string.IsNullOrWhiteSpace(ShortName))

Commands\create\InvalidTemplateOptionResult.cs (1)

161if (!string.IsNullOrWhiteSpace(choiceInfo.Value.Description))

Commands\create\TemplateCommand.cs (5)

66if (!string.IsNullOrWhiteSpace(templateLanguage)) 72if (!string.IsNullOrWhiteSpace(defaultLanguage) 91if (!string.IsNullOrWhiteSpace(templateType)) 99if (template.BaselineInfo.Any(b => !string.IsNullOrWhiteSpace(b.Key))) 103BaselineOption.FromAmongCaseInsensitive(template.BaselineInfo.Select(b => b.Key).Where(b => !string.IsNullOrWhiteSpace(b)).ToArray());

Commands\FilterOptionDefinition.cs (1)

70if (string.IsNullOrWhiteSpace(packageArg))

Commands\list\ListCommandArgs.cs (2)

15if (!string.IsNullOrWhiteSpace(nameCriteria)) 25if (!string.IsNullOrWhiteSpace(newCommandArgument))

Commands\search\SearchCommandArgs.cs (2)

15if (!string.IsNullOrWhiteSpace(nameCriteria)) 24if (!string.IsNullOrWhiteSpace(newCommandArgument))

Extensions.cs (4)

45if (!string.IsNullOrWhiteSpace(shortNames)) 49if (!string.IsNullOrWhiteSpace(templateLanguage)) 68if (string.IsNullOrWhiteSpace(constraintDisplayName)) 74if (!string.IsNullOrWhiteSpace(constraintResult.CallToAction))

HostSpecificDataLoader.cs (1)

46if (!string.IsNullOrWhiteSpace(hostData))

HostSpecificTemplateData.cs (2)

236if (value.UsageExamples != null && value.UsageExamples.Any(e => !string.IsNullOrWhiteSpace(e))) 242if (!string.IsNullOrWhiteSpace(example))

IReporterExtensions.cs (2)

50reporter.WriteLine(string.IsNullOrWhiteSpace(output) ? LocalizableStrings.Generic_Empty : output); 59reporter.WriteLine(string.IsNullOrWhiteSpace(output) ? LocalizableStrings.Generic_Empty : output);

NuGet\NugetApiManager.cs (1)

58if (!string.IsNullOrWhiteSpace(packageVersion))

PostActionDispatcher.cs (6)

77if (string.IsNullOrWhiteSpace(creationResult.OutputBaseDirectory)) 102if (!string.IsNullOrWhiteSpace(action.Description)) 115if (!string.IsNullOrWhiteSpace(action.Description)) 128if (!string.IsNullOrWhiteSpace(action.Description)) 181if (!string.IsNullOrWhiteSpace(action.Description)) 243if (string.IsNullOrWhiteSpace(action.ManualInstructions))

PostActionProcessors\PostActionProcessorBase.cs (3)

22if (string.IsNullOrWhiteSpace(outputBasePath)) 66if (string.IsNullOrWhiteSpace(targetFiles)) 93if (string.IsNullOrWhiteSpace(targetFiles))

PostActionProcessors\ProcessStartPostActionProcessor.cs (2)

19if (!actionConfig.Args.TryGetValue("executable", out string? executable) || string.IsNullOrWhiteSpace(executable)) 46if (!string.IsNullOrWhiteSpace(args))

TabularOutput\TabularOutput.cs (2)

61if ((_settings.ColumnsToDisplay.Count == 0 && defaultColumn) || showAlways || (!string.IsNullOrWhiteSpace(columnName) && _settings.ColumnsToDisplay.Contains(columnName)) || _settings.DisplayAllColumns) 385if (!string.IsNullOrWhiteSpace(text))

TabularOutput\TemplateGroupDisplay.cs (4)

84if (string.IsNullOrWhiteSpace(lang)) 179.Where(classification => !string.IsNullOrWhiteSpace(classification)) 247.GroupBy(template => string.IsNullOrWhiteSpace(template.Author) ? string.Empty : template.Author, StringComparer.OrdinalIgnoreCase) 264.Where(type => !string.IsNullOrWhiteSpace(type))

TemplateGroup.cs (3)

40GroupIdentity = templates.Select(t => string.IsNullOrWhiteSpace(t.GroupIdentity) ? null : t.GroupIdentity) 161if (!string.IsNullOrWhiteSpace(template.Author)) 173internal bool HasGroupIdentity => !string.IsNullOrWhiteSpace(GroupIdentity);

TemplateInvoker.cs (2)

154if (string.IsNullOrWhiteSpace(fallbackName)) 229if (!string.IsNullOrWhiteSpace(instantiateResult.ErrorMessage))

TemplateListCoordinator.cs (2)

120if (string.IsNullOrWhiteSpace(args.ListNameCriteria)) 206if (!string.IsNullOrWhiteSpace(mainCriteria))

TemplatePackageCoordinator.cs (5)

475$"{packageIdentity}{(string.IsNullOrWhiteSpace(packageVersion) ? string.Empty : $"@{packageVersion}")}"); 742if (string.IsNullOrWhiteSpace(managedPackages?.First().Identifier)) 784if (string.IsNullOrWhiteSpace(sourceIdentifier)) 806if (string.IsNullOrWhiteSpace(sourceIdentifier)) 888if (string.IsNullOrWhiteSpace(source))

TemplatePackageDisplay.cs (4)

91if (string.IsNullOrWhiteSpace(packageToInstall)) 240if (!string.IsNullOrWhiteSpace(managedSource.Version)) 287.Where(result => result.Success && !result.IsLatestVersion && !string.IsNullOrWhiteSpace(result.LatestVersion)) 408bool showIdentity = !string.IsNullOrWhiteSpace(template.Template.GroupIdentity) && templates.Count(t => t.GroupIdentity == template.Template.GroupIdentity) > 1;

TemplateResolution\CliFilters.cs (5)

98if (string.IsNullOrWhiteSpace(language) && string.IsNullOrWhiteSpace(defaultLanguage)) 104if (!string.IsNullOrWhiteSpace(language)) 107if (templateLanguages.Any(lang => string.IsNullOrWhiteSpace(lang))) 121if (!string.IsNullOrWhiteSpace(defaultLanguage))

TemplateResolution\TemplateGroupMatchInfo.cs (1)

321if ((languageMatch == null) || string.IsNullOrWhiteSpace(languageMatch.Value))

TemplateResolution\TemplateResolutionResult.cs (1)

270if (!string.IsNullOrWhiteSpace(parameterMatchInfo.Value) || !parameterList.ContainsKey(parameterMatchInfo.InputFormat ?? parameterMatchInfo.Name))

TemplateSearch\CliTemplateSearchCoordinator.cs (3)

252if (string.IsNullOrWhiteSpace(commandArgs.SearchNameCriteria) && !commandArgs.AppliedFilters.Any()) 281if (!string.IsNullOrWhiteSpace(commandArgs.SearchNameCriteria) && commandArgs.SearchNameCriteria.Length < 2) 302if (!string.IsNullOrWhiteSpace(mainCriteria))

Microsoft.TemplateEngine.Edge (55)

BuiltInManagedProvider\GlobalSettingsTemplatePackageProvider.cs (2)

275string.IsNullOrWhiteSpace(packageToBeUpdated.Version) 278string.IsNullOrWhiteSpace(version) ?

Constraints\ConstraintsExtensions.cs (1)

115if (string.IsNullOrWhiteSpace(args))

Constraints\HostConstraint.cs (3)

79if (string.IsNullOrWhiteSpace(hostName)) 83if (string.IsNullOrWhiteSpace(version)) 99if (string.IsNullOrWhiteSpace(host))

DefaultPathInfo.cs (11)

EngineEnvironmentSettings.cs (1)

38if (pathInfo != null && !string.IsNullOrWhiteSpace(settingsLocation))

Installers\Folder\FolderManagedTemplatePackage.cs (1)

20if (string.IsNullOrWhiteSpace(mountPointUri))

Installers\NuGet\NugetApiPackageManager.cs (8)

51if (string.IsNullOrWhiteSpace(identifier)) 55if (string.IsNullOrWhiteSpace(downloadPath)) 199if (string.IsNullOrWhiteSpace(identifier)) 213string[] additionalSources = string.IsNullOrWhiteSpace(additionalSource) ? [] : new[] { additionalSource! }; 253if (string.IsNullOrWhiteSpace(packageIdentifier)) 317if (string.IsNullOrWhiteSpace(packageIdentifier)) 370if (string.IsNullOrWhiteSpace(packageIdentifier)) 473if (string.IsNullOrWhiteSpace(source))

Installers\NuGet\NuGetInstaller.cs (4)

27if (string.IsNullOrWhiteSpace(installPath)) 50if (string.IsNullOrWhiteSpace(installPath)) 366if (string.IsNullOrWhiteSpace(updateRequest.Version)) 383if (updateRequest.TemplatePackage is NuGetManagedTemplatePackage nuGetManagedSource && !string.IsNullOrWhiteSpace(nuGetManagedSource.NuGetSource))

Installers\NuGet\NuGetManagedTemplatePackage.cs (5)

32if (string.IsNullOrWhiteSpace(mountPointUri)) 36if (string.IsNullOrWhiteSpace(packageIdentifier)) 62if (string.IsNullOrWhiteSpace(mountPointUri)) 73if (string.IsNullOrWhiteSpace(packageId)) 89public string DisplayName => string.IsNullOrWhiteSpace(Version) ? Identifier : $"{Identifier}@{Version}";

Settings\Scanner.cs (3)

55if (string.IsNullOrWhiteSpace(mountPointUri)) 76if (string.IsNullOrWhiteSpace(mountPointUri)) 97if (string.IsNullOrWhiteSpace(mountPointUri))

Settings\TemplateCache.cs (1)

149if (string.IsNullOrWhiteSpace(bestMatch))

Settings\TemplateInfo.cs (5)

24if (string.IsNullOrWhiteSpace(identity)) 29if (string.IsNullOrWhiteSpace(name)) 42if (shortNames.Any(string.IsNullOrWhiteSpace)) 47if (string.IsNullOrWhiteSpace(mountPointUri)) 52if (string.IsNullOrWhiteSpace(configPlace))

Settings\TemplateInfoReader.cs (2)

127if (string.IsNullOrWhiteSpace(type)) 146if (string.IsNullOrWhiteSpace(name))

Settings\TemplatePackageManager.cs (1)

232return string.IsNullOrWhiteSpace(packageVersion) || tp.Version == packageVersion;

Template\TemplateCreationResult.cs (2)

29if (string.IsNullOrWhiteSpace(templateName)) 36if (string.IsNullOrWhiteSpace(ErrorMessage) && status != CreationResultStatus.Success)

Template\TemplateCreator.cs (2)

138if (string.IsNullOrWhiteSpace(realName)) 146string targetDir = !string.IsNullOrWhiteSpace(outputPath) ? outputPath! : _environmentSettings.Host.FileSystem.GetCurrentDirectory();

Template\WellKnownSearchFilters.cs (3)

90if (string.IsNullOrWhiteSpace(tagFilter)) 195if (string.IsNullOrWhiteSpace(author)) 200if (string.IsNullOrWhiteSpace(template.Author))

Microsoft.TemplateEngine.IDE (1)

Bootstrapper.cs (1)

47if (string.IsNullOrWhiteSpace(hostSettingsLocation))

Microsoft.TemplateEngine.Orchestrator.RunnableProjects (72)

BindSymbolEvaluator.cs (5)

53else if (!result && !string.IsNullOrWhiteSpace(bindSymbol.DataType)) 60IEnumerable<BindSymbol> bindSymbols = symbols.Where(bs => !string.IsNullOrWhiteSpace(bs.Binding)); 142if (string.IsNullOrWhiteSpace(configuredBinding)) 155if (string.IsNullOrWhiteSpace(binding)) 161if (string.IsNullOrWhiteSpace(prefix))

ConfigModel\BaseSymbol.cs (1)

10if (string.IsNullOrWhiteSpace(name))

ConfigModel\BindSymbol.cs (2)

18if (string.IsNullOrWhiteSpace(binding)) 29if (string.IsNullOrWhiteSpace(binding))

ConfigModel\ComputedSymbol.cs (2)

18if (string.IsNullOrWhiteSpace(value)) 29if (string.IsNullOrWhiteSpace(value))

ConfigModel\DerivedSymbol.cs (4)

18if (string.IsNullOrWhiteSpace(valueTransform)) 23if (string.IsNullOrWhiteSpace(valueSource)) 36if (string.IsNullOrWhiteSpace(valueTransform)) 44if (string.IsNullOrWhiteSpace(valueSource))

ConfigModel\GeneratedSymbol.cs (2)

19if (string.IsNullOrWhiteSpace(generator)) 35if (string.IsNullOrWhiteSpace(generator))

ConfigModel\ParameterSymbol.cs (1)

46if (string.IsNullOrWhiteSpace(choiceName))

ConfigModel\PrimaryOutputModel.cs (2)

17if (string.IsNullOrWhiteSpace(path)) 42if (string.IsNullOrWhiteSpace(path))

ConfigModel\TemplateConfigModel.cs (6)

38if (string.IsNullOrWhiteSpace(identity)) 52if (string.IsNullOrWhiteSpace(identity)) 115if (string.IsNullOrWhiteSpace(prop.Key)) 189if (string.IsNullOrWhiteSpace(type)) 422if (string.IsNullOrWhiteSpace(content)) 512string? replaces = string.IsNullOrWhiteSpace(sourceName) ? null : sourceName;

DirectoryBasedTemplate.cs (1)

198if (string.IsNullOrWhiteSpace(ConfigurationModel.GeneratorVersions))

Macros\BaseMacroConfig.cs (3)

19if (string.IsNullOrWhiteSpace(type)) 24if (string.IsNullOrWhiteSpace(variableName)) 29if (!string.IsNullOrWhiteSpace(dataType))

Macros\CaseChangeMacroConfig.cs (1)

13if (string.IsNullOrWhiteSpace(sourceVariable))

Macros\CoalesceMacroConfig.cs (2)

19if (string.IsNullOrWhiteSpace(sourceVariableName)) 24if (string.IsNullOrWhiteSpace(fallbackVariableName))

Macros\EvaluateMacroConfig.cs (1)

16if (string.IsNullOrWhiteSpace(condition))

Macros\JoinMacroConfig.cs (1)

49if (type == JoinType.Ref && string.IsNullOrWhiteSpace(value))

Macros\ProcessValueFormMacroConfig.cs (2)

16if (string.IsNullOrWhiteSpace(sourceSymbol)) 21if (string.IsNullOrWhiteSpace(valueForm))

Macros\RegexMacroConfig.cs (1)

19if (string.IsNullOrWhiteSpace(sourceVariable))

Macros\RegexMatchMacroConfig.cs (1)

13if (string.IsNullOrWhiteSpace(sourceVariable))

Macros\SwitchMacroConfig.cs (1)

28if (!string.IsNullOrWhiteSpace(evaluator))

OperationConfig\ConditionalBlockCommentConfig.cs (4)

19if (string.IsNullOrWhiteSpace(startToken)) 23else if (string.IsNullOrWhiteSpace(endToken)) 33if (string.IsNullOrWhiteSpace(pseudoEndToken)) 110if (!string.IsNullOrWhiteSpace(pseudoEndToken))

OperationConfig\ConditionalKeywords.cs (4)

41if (!string.IsNullOrWhiteSpace(ifKeyword)) 47if (!string.IsNullOrWhiteSpace(elseIfKeyword)) 53if (!string.IsNullOrWhiteSpace(elseKeyword)) 59if (!string.IsNullOrWhiteSpace(endIfKeyword))

OperationConfig\ConditionalLineCommentConfig.cs (1)

18if (string.IsNullOrWhiteSpace(token))

OperationConfig\ConditionalOperationOptions.cs (1)

42if (!string.IsNullOrWhiteSpace(id))

Parameter.cs (1)

14if (string.IsNullOrWhiteSpace(name))

ParameterConverter.cs (1)

98if (string.IsNullOrWhiteSpace(dataType))

PrimaryOutput.cs (1)

14if (string.IsNullOrWhiteSpace(path))

RunnableProjectConfig.cs (5)

91public IReadOnlyList<string> IgnoreFileNames => !string.IsNullOrWhiteSpace(ConfigurationModel.PlaceholderFilename) ? new[] { ConfigurationModel.PlaceholderFilename! } : DefaultPlaceholderFilenames; 293if (!string.IsNullOrWhiteSpace(symbol.FileRename)) 315if (!string.IsNullOrWhiteSpace(symbol.FileRename)) 381if (!string.IsNullOrWhiteSpace(replaceSymbol.Replaces)) 400else if (!string.IsNullOrWhiteSpace(replaceSymbol.Replaces))

RunnableProjectGenerator.cs (2)

59localeConfig = string.IsNullOrWhiteSpace(extendedTemplateLocator.LocaleConfigPlace) ? null : mountPoint.FileInfo(extendedTemplateLocator.LocaleConfigPlace!); 60hostTemplateConfigFile = string.IsNullOrWhiteSpace(extendedTemplateLocator.HostConfigPlace) ? null : mountPoint.FileInfo(extendedTemplateLocator.HostConfigPlace!);

Validation\MandatoryValidationFactory.cs (7)

27vi => string.IsNullOrWhiteSpace(vi.ConfigModel.Identity)), 33vi => string.IsNullOrWhiteSpace(vi.ConfigModel.Name)), 46string.IsNullOrWhiteSpace(ps.DisplayName) ? ps.Name : ps.DisplayName, 61vi => string.IsNullOrWhiteSpace(vi.ConfigModel.SourceName)), 67vi => string.IsNullOrWhiteSpace(vi.ConfigModel.Author)), 73vi => string.IsNullOrWhiteSpace(vi.ConfigModel.GroupIdentity)), 79vi => string.IsNullOrWhiteSpace(vi.ConfigModel.GeneratorVersions)),

ValueFormRegistry.cs (1)

43if (string.IsNullOrWhiteSpace(identifier))

ValueForms\ActionableValueFormFactory.cs (1)

22if (string.IsNullOrWhiteSpace(name))

ValueForms\BaseValueFormFactory.cs (1)

16if (string.IsNullOrWhiteSpace(identifier))

ValueForms\ConfigurableValueFormFactory.cs (1)

27if (string.IsNullOrWhiteSpace(name))

ValueForms\DependentValueFormFactory.cs (1)

27if (string.IsNullOrWhiteSpace(name))

ValueForms\KebabCaseValueFormFactory.cs (1)

16if (string.IsNullOrWhiteSpace(value))

Microsoft.TemplateEngine.Utils (4)

InstallRequestPathResolution.cs (1)

28if (string.IsNullOrWhiteSpace(maskedPath))

WellKnownSearchFilters.cs (3)

120if (string.IsNullOrWhiteSpace(classification)) 199if (string.IsNullOrWhiteSpace(author)) 204if (string.IsNullOrWhiteSpace(template.Author))

Microsoft.TemplateSearch.Common (26)

Abstractions\TemplatePackageSearchData.cs (1)

26Name = !string.IsNullOrWhiteSpace(packInfo.Name) ? packInfo.Name

SearchResult.cs (1)

20if (!success && string.IsNullOrWhiteSpace(errorMessage))

TemplateDiscoveryMetadata\BlobStorageTemplateInfo.cs (7)

23if (string.IsNullOrWhiteSpace(templateInfo.Identity)) 28if (string.IsNullOrWhiteSpace(templateInfo.Name)) 56if (string.IsNullOrWhiteSpace(identity)) 61if (string.IsNullOrWhiteSpace(name)) 324if (string.IsNullOrWhiteSpace(parameter.Name)) 329DataType = !string.IsNullOrWhiteSpace(parameter.DataType) ? parameter.DataType : "string"; 353if (string.IsNullOrWhiteSpace(name))

TemplateSearchCache\TemplatePackageSearchData.Json.cs (4)

29Name = !string.IsNullOrWhiteSpace(name) ? name! 86if (!string.IsNullOrWhiteSpace(value.Version)) 119if (!string.IsNullOrWhiteSpace(value.Description)) 124if (!string.IsNullOrWhiteSpace(value.IconUrl))

TemplateSearchCache\TemplateSearchCache.Json.cs (2)

32if (!TryReadVersion(logger, cacheObject, out string? version) || string.IsNullOrWhiteSpace(version)) 115if (!string.IsNullOrWhiteSpace(version))

TemplateSearchCache\TemplateSearchData.Json.cs (11)

Microsoft.TestPlatform.AdapterUtilities (3)

ManagedNameUtilities\ManagedNameHelper.Reflection.cs (1)

283if (!string.IsNullOrWhiteSpace(methodName))

NullableHelpers.cs (2)

24/// <inheritdoc cref="string.IsNullOrWhiteSpace(string)"/> 27=> string.IsNullOrWhiteSpace(value);

Microsoft.TestPlatform.Build (2)

NullableHelpers.cs (2)

24/// <inheritdoc cref="string.IsNullOrWhiteSpace(string)"/> 27=> string.IsNullOrWhiteSpace(value);

Microsoft.TestPlatform.CommunicationUtilities (4)

NullableHelpers.cs (2)

24/// <inheritdoc cref="string.IsNullOrWhiteSpace(string)"/> 27=> string.IsNullOrWhiteSpace(value);

TestRequestSender.cs (2)

297if (!string.IsNullOrWhiteSpace(_clientExitErrorMessage)) 775if (!string.IsNullOrWhiteSpace(_clientExitErrorMessage))

Microsoft.TestPlatform.CoreUtilities (4)

NullableHelpers.cs (2)

24/// <inheritdoc cref="string.IsNullOrWhiteSpace(string)"/> 27=> string.IsNullOrWhiteSpace(value);

Utilities\JobQueue.cs (1)

104if (string.IsNullOrWhiteSpace(displayName))

Utilities\TimeSpanParser.cs (1)

20if (string.IsNullOrWhiteSpace(time))

Microsoft.TestPlatform.CrossPlatEngine (1)

NullableHelpers.cs (1)

27=> string.IsNullOrWhiteSpace(value);

Microsoft.TestPlatform.Extensions.BlameDataCollector (5)

NullableHelpers.cs (2)

24/// <inheritdoc cref="string.IsNullOrWhiteSpace(string)"/> 27=> string.IsNullOrWhiteSpace(value);

src\vstest\src\Microsoft.TestPlatform.Execution.Shared\DebuggerBreakpoint.cs (3)

28if (string.IsNullOrWhiteSpace(environmentVariable)) 122if (string.IsNullOrWhiteSpace(environmentVariable)) 148if (string.IsNullOrWhiteSpace(environmentVariable))

Microsoft.TestPlatform.Filter.Source (2)

Condition.cs (2)

207if (string.IsNullOrWhiteSpace(conditionString)) 231if (string.IsNullOrWhiteSpace(parts[index]))

Microsoft.TestPlatform.PlatformAbstractions (2)

NullableHelpers.cs (2)

24/// <inheritdoc cref="string.IsNullOrWhiteSpace(string)"/> 27=> string.IsNullOrWhiteSpace(value);

Microsoft.TestPlatform.TestHostRuntimeProvider (2)

NullableHelpers.cs (2)

24/// <inheritdoc cref="string.IsNullOrWhiteSpace(string)"/> 27=> string.IsNullOrWhiteSpace(value);

Microsoft.TestPlatform.Utilities (3)

InferRunSettingsHelper.cs (1)

309if (!string.IsNullOrWhiteSpace(collectorRef.FriendlyName) &&

NullableHelpers.cs (2)

24/// <inheritdoc cref="string.IsNullOrWhiteSpace(string)"/> 27=> string.IsNullOrWhiteSpace(value);

Microsoft.VisualBasic.Forms (7)

Microsoft\VisualBasic\Devices\Network.DownloadFile.vb (1)

160If String.IsNullOrWhiteSpace(address) Then

Microsoft\VisualBasic\Devices\Network.UploadFile.vb (1)

138If String.IsNullOrWhiteSpace(address) Then

Microsoft\VisualBasic\Devices\NetworkUtilities.vb (2)

49Return If(String.IsNullOrWhiteSpace(userName) OrElse String.IsNullOrWhiteSpace(password),

Microsoft\VisualBasic\Logging\FileLogTraceListener.vb (1)

594Debug.Assert(Not String.IsNullOrWhiteSpace(Path.GetDirectoryName(LogFileName)), "The log directory shouldn't be empty.")

Microsoft\VisualBasic\MyServices\Internal\WebClientCopy.vb (2)

158Debug.Assert((Not String.IsNullOrWhiteSpace(destinationFileName)) _ 187Debug.Assert((Not String.IsNullOrWhiteSpace(sourceFileName)) _

Microsoft.VisualStudio.TestPlatform.Common (2)

NullableHelpers.cs (2)

24/// <inheritdoc cref="string.IsNullOrWhiteSpace(string)"/> 27=> string.IsNullOrWhiteSpace(value);

Microsoft.VisualStudio.TestPlatform.Extensions.Html.TestLogger (2)

NullableHelpers.cs (2)

24/// <inheritdoc cref="string.IsNullOrWhiteSpace(string)"/> 27=> string.IsNullOrWhiteSpace(value);

Microsoft.VisualStudio.TestPlatform.Extensions.Trx.TestLogger (2)

NullableHelpers.cs (2)

24/// <inheritdoc cref="string.IsNullOrWhiteSpace(string)"/> 27=> string.IsNullOrWhiteSpace(value);

Microsoft.Web.Xdt.Extensions (1)

src\aspnetcore\src\Shared\ThrowHelpers\ArgumentThrowHelper.cs (1)

54if (string.IsNullOrWhiteSpace(argument))

MSBuild (8)

CommandLine\CommandLineParser.cs (3)

138if (string.IsNullOrWhiteSpace(Traits.MSBuildLoggingArgs)) 155if (string.IsNullOrWhiteSpace(unquotedArg)) 537found = !string.IsNullOrWhiteSpace(directoryResponseFile) && GatherAutoResponseFileSwitchesFromFullPath(directoryResponseFile, switchesFromAutoResponseFile, commandLine);

XMake.cs (5)

2848if (string.IsNullOrWhiteSpace(parameter)) 2871KnownTelemetry.LoggingConfigurationTelemetry.TerminalLoggerDefaultSource = string.IsNullOrWhiteSpace(dotnetCliEnvVar) ? "sdk" : "DOTNET_CLI_CONFIGURE_MSBUILD_TERMINAL_LOGGER"; 3059if (string.IsNullOrWhiteSpace(parameter)) 3092if (string.IsNullOrWhiteSpace(parameter)) 3263else if (!string.IsNullOrWhiteSpace(code))

NuGet.Build.Tasks (13)

BuildTasksUtility.cs (8)

246if (project.RestoreMetadata == null || string.IsNullOrWhiteSpace(project.RestoreMetadata.OutputPath) || string.IsNullOrWhiteSpace(project.RestoreMetadata.ProjectPath)) 297if (!string.IsNullOrWhiteSpace(restoreProjectStyleProperty)) 373if (string.IsNullOrWhiteSpace(projectDirectory)) 378if (string.IsNullOrWhiteSpace(projectName)) 706if (string.IsNullOrWhiteSpace(projectFullPath)) 723if (string.IsNullOrWhiteSpace(projectDirectory)) 728if (string.IsNullOrWhiteSpace(projectName))

RestoreTaskEx.cs (3)

101bool? enableBinaryLogger = !string.IsNullOrWhiteSpace(EnableBinaryLogger) && bool.TryParse(EnableBinaryLogger, out bool result) 106if (enableBinaryLogger != false && !string.IsNullOrWhiteSpace(BinaryLoggerParameters)) 127if (!string.IsNullOrWhiteSpace(EmbedFilesInBinlog))

StaticGraphRestoreTaskBase.cs (1)

46public bool IsSolutionPathDefined => !string.IsNullOrWhiteSpace(SolutionPath) && !string.Equals(SolutionPath, "*Undefined*", StringComparison.OrdinalIgnoreCase);

TaskLoggingQueue.cs (1)

54if (string.IsNullOrWhiteSpace(message))

NuGet.Build.Tasks.Console (22)

ExtensionMethods.cs (2)

75return string.IsNullOrWhiteSpace(value) 88return string.IsNullOrWhiteSpace(value)

MSBuildItemBase.cs (1)

40if (string.IsNullOrWhiteSpace(value))

MSBuildProjectInstance.cs (1)

61if (!string.IsNullOrWhiteSpace(trimmed))

MSBuildStaticGraphRestore.cs (11)

Program.cs (4)

151.Where(i => !string.IsNullOrWhiteSpace(i)) 153.Where(i => i.Length == 2 && !string.IsNullOrWhiteSpace(i[0]) && !string.IsNullOrWhiteSpace(i[1]))) 227return msbuildExeFilePath.Exists && !string.IsNullOrWhiteSpace(entryProjectFilePath);

ProjectWithInnerNodes.cs (1)

42if (string.IsNullOrWhiteSpace(targetFramework))

RestoreProjectAdapter.cs (2)

39if (string.IsNullOrWhiteSpace(targetFramework)) 63if (!string.IsNullOrWhiteSpace(trimmed))

NuGet.Build.Tasks.Pack (1)

GetPackOutputItemsTask.cs (1)

79if (string.IsNullOrWhiteSpace(NuspecFile) || !File.Exists(NuspecFile))

NuGet.CommandLine.XPlat (5)

Commands\LocalsCommand.cs (1)

56if (string.IsNullOrWhiteSpace(cacheLocation))

Commands\PackageSearch\JsonFormat\SearchResultPackagesConverter.cs (1)

28if (!string.IsNullOrWhiteSpace(value))

Commands\Signing\TrustedSignersCommand.cs (2)

240if (!string.IsNullOrWhiteSpace(name)) 251if (!string.IsNullOrWhiteSpace(sourceUrl))

Utility\MSBuildAPIUtility.cs (1)

356var versionOverrideExists = packageReferenceInProps?.Metadata.FirstOrDefault(i => i.Name.Equals("VersionOverride") && !string.IsNullOrWhiteSpace(i.EvaluatedValue));

NuGet.Commands (34)

ClientCertificatesCommand\ClientCertArgsExtensions.cs (3)

65if (!string.IsNullOrWhiteSpace(args.StoreLocation)) 78if (!string.IsNullOrWhiteSpace(args.StoreName)) 91if (!string.IsNullOrWhiteSpace(args.FindBy))

CommandRunners\LocalsCommandRunner.cs (2)

42if (((localsArgs.Arguments.Count == 0) || string.IsNullOrWhiteSpace(localsArgs.Arguments[0])) 111if (string.IsNullOrWhiteSpace(path))

RestoreCommand\DependencyGraphResolver.cs (6)

158if (!string.IsNullOrWhiteSpace(frameworkRuntimeDefinition.RuntimeIdentifier) && !hasInstallBeenCalledAlready) 196runtimeIdentifier: string.IsNullOrWhiteSpace(frameworkRuntimeDefinition.RuntimeIdentifier) ? null : frameworkRuntimeDefinition.RuntimeIdentifier, 233if (!string.IsNullOrWhiteSpace(frameworkRuntimeDefinition.RuntimeIdentifier)) 745string.IsNullOrWhiteSpace(frameworkRuntimeDefinition.RuntimeIdentifier) ? null : frameworkRuntimeDefinition.RuntimeIdentifier, 1390runtimeIdentifier: string.IsNullOrWhiteSpace(pair.RuntimeIdentifier) ? null : pair.RuntimeIdentifier, 1441RuntimeGraph? projectProviderRuntimeGraph = string.IsNullOrWhiteSpace(runtimeGraphPath) ? default : ProjectRestoreCommand.GetRuntimeGraph(runtimeGraphPath, _logger);

RestoreCommand\RestoreRequest.cs (1)

95_lockFileLazy = string.IsNullOrWhiteSpace(value) ? null : new Lazy<LockFile>(() => LockFileUtilities.GetLockFile(_lockFilePath, Log));

RestoreCommand\Utility\MSBuildRestoreUtility.cs (3)

1220if (string.IsNullOrWhiteSpace(value)) 1232if (string.IsNullOrWhiteSpace(value)) 1270CentralPackageVersion centralPackageVersion = new CentralPackageVersion(cv.GetProperty("Id"), string.IsNullOrWhiteSpace(version) ? VersionRange.All : VersionRange.Parse(version));

RestoreCommand\Utility\NoOpRestoreUtilities.cs (1)

104if (!string.IsNullOrWhiteSpace(request.LockFilePath) && !File.Exists(request.LockFilePath))

RestoreCommand\Utility\PackageSpecFactory.cs (17)

src\nuget-client\build\Shared\EqualityUtility.cs (1)

318return !string.IsNullOrWhiteSpace(value) && bool.FalseString.Equals(value.Trim(), StringComparison.OrdinalIgnoreCase);

NuGet.Common (1)

UriUtility.cs (1)

155if (string.IsNullOrWhiteSpace(source))

NuGet.Configuration (29)

PackageSource\PackageSourceCredential.cs (1)

199return string.IsNullOrWhiteSpace(str)

PackageSourceMapping\SearchTree.cs (3)

36if (string.IsNullOrWhiteSpace(packagePattern)) 107if (string.IsNullOrWhiteSpace(term)) 151if (string.IsNullOrWhiteSpace(term))

Settings\Items\FileClientCertItem.cs (10)

Settings\Items\MinPublishAgeExceptionItem.cs (1)

29if (string.IsNullOrWhiteSpace(value))

Settings\Items\OwnersItem.cs (1)

41var descendants = element.Nodes().Where(n => n is XText text && !string.IsNullOrWhiteSpace(text.Value) || n is XElement)

Settings\Items\PackageSourceMappingSourceItem.cs (1)

78var parsedDescendants = element.Nodes().Where(n => n is XElement || n is XText text && !string.IsNullOrWhiteSpace(text.Value))

Settings\Items\StoreClientCertItem.cs (6)

64if (string.IsNullOrWhiteSpace(findValue)) 76if (string.IsNullOrWhiteSpace(storeLocation)) 84if (string.IsNullOrWhiteSpace(storeName)) 92if (string.IsNullOrWhiteSpace(findBy)) 100if (string.IsNullOrWhiteSpace(findValue)) 283if (!string.IsNullOrWhiteSpace(findValue))

Settings\Items\TrustedSignerItem.cs (2)

56IEnumerable<SettingBase> parsedDescendants = element.Nodes().Where(n => n is XElement || n is XText text && !string.IsNullOrWhiteSpace(text.Value)) 86return element.Nodes().Where(n => n is XElement || n is XText text && !string.IsNullOrWhiteSpace(text.Value))

Settings\Items\UnknownItem.cs (1)

29var descendants = element.Nodes().Where(n => n is XText text && !string.IsNullOrWhiteSpace(text.Value) || n is XElement)

Settings\Settings.cs (1)

814if (!Path.IsPathRooted(settingsPath) && !string.IsNullOrWhiteSpace(settingsRoot))

src\nuget-client\build\Shared\EqualityUtility.cs (1)

318return !string.IsNullOrWhiteSpace(value) && bool.FalseString.Equals(value.Trim(), StringComparison.OrdinalIgnoreCase);

Utility\XElementUtility.cs (1)

88return string.IsNullOrWhiteSpace(textNode.Value);

NuGet.Credentials (4)

PluginCredentialProvider.cs (2)

217credentialResponse = string.IsNullOrWhiteSpace(trimmedOutput) 276if (!string.IsNullOrWhiteSpace(data))

PluginCredentialResponse.cs (2)

43public bool IsValid => (!String.IsNullOrWhiteSpace(Username) || !String.IsNullOrWhiteSpace(Password))

NuGet.LibraryModel (1)

src\nuget-client\build\Shared\EqualityUtility.cs (1)

318return !string.IsNullOrWhiteSpace(value) && bool.FalseString.Equals(value.Trim(), StringComparison.OrdinalIgnoreCase);

NuGet.PackageManagement (5)

PackageRestoreConsent.cs (2)

58if (string.IsNullOrWhiteSpace(settingsValue)) 88if (string.IsNullOrWhiteSpace(value))

src\nuget-client\build\Shared\EqualityUtility.cs (1)

318return !string.IsNullOrWhiteSpace(value) && bool.FalseString.Equals(value.Trim(), StringComparison.OrdinalIgnoreCase);

Utility\PackagesConfigLockFileUtility.cs (1)

76if (!string.IsNullOrWhiteSpace(nuGetLockFilePath))

Utility\XElementExtensions.cs (1)

336return string.IsNullOrWhiteSpace(textNode.Value);

NuGet.Packaging (15)

Core\NuspecUtility.cs (1)

75if (nameAttribute == null || string.IsNullOrWhiteSpace(nameAttribute.Value))

Licenses\LicenseExpressionTokenizer.cs (1)

24if (string.IsNullOrWhiteSpace(value))

Licenses\NuGetLicense.cs (1)

50if (!string.IsNullOrWhiteSpace(licenseIdentifier))

Licenses\NuGetLicenseException.cs (1)

33if (!string.IsNullOrWhiteSpace(exceptionIdentifier))

PackageCreation\Authoring\ManifestMetadata.cs (2)

359if ((string.IsNullOrWhiteSpace(_licenseUrl) && LicenseMetadata == null)) 370if (_licenseUrl != null && LicenseMetadata != null && (string.IsNullOrWhiteSpace(_licenseUrl) || !LicenseUrl!.Equals(LicenseMetadata.LicenseUrl)))

PackageCreation\Authoring\ManifestReader.cs (2)

192if (string.IsNullOrWhiteSpace(license)) 198if (string.IsNullOrWhiteSpace(versionValue))

Signing\Authoring\RepositorySignPackageRequest.cs (1)

77if (packageOwners.Any(packageOwner => string.IsNullOrWhiteSpace(packageOwner)))

Signing\Signatures\NuGetPackageOwners.cs (2)

28if (packageOwners.Any(packageOwner => string.IsNullOrWhiteSpace(packageOwner))) 52if (string.IsNullOrWhiteSpace(packageOwner))

Signing\Signatures\Signature.cs (1)

209if (!string.IsNullOrWhiteSpace(x509ChainString))

Signing\Timestamp\Timestamp.cs (1)

162if (!string.IsNullOrWhiteSpace(x509ChainString))

Signing\Utility\AttributeUtility.cs (1)

160if (packageOwners.Any(packageOwner => string.IsNullOrWhiteSpace(packageOwner)))

src\nuget-client\build\Shared\EqualityUtility.cs (1)

318return !string.IsNullOrWhiteSpace(value) && bool.FalseString.Equals(value.Trim(), StringComparison.OrdinalIgnoreCase);

NuGet.ProjectModel (2)

LockFile\Utf8JsonStreamLockFileLibraryConverter.cs (1)

52var nugetVersion = !string.IsNullOrWhiteSpace(version) ? NuGetVersion.Parse(version) : null;

src\nuget-client\build\Shared\EqualityUtility.cs (1)

318return !string.IsNullOrWhiteSpace(value) && bool.FalseString.Equals(value.Trim(), StringComparison.OrdinalIgnoreCase);

NuGet.Protocol (17)

Converters\MetadataFieldConverter.cs (1)

27return string.Join(", ", array.Values<string>().Where(s => !string.IsNullOrWhiteSpace(s)));

Converters\MetadataFieldStjConverter.cs (1)

41if (string.IsNullOrWhiteSpace(s)) { continue; }

Converters\MetadataStringOrArrayConverter.cs (1)

25return string.IsNullOrWhiteSpace(str) ? null : new string[] { str! };

Converters\MetadataStringOrArrayStjConverter.cs (1)

34return string.IsNullOrWhiteSpace(str) ? null : [str!];

LegacyFeed\V2FeedPackageInfo.cs (2)

269if (!string.IsNullOrWhiteSpace(versionRangeString) 281if (!string.IsNullOrWhiteSpace(frameworkString)

Model\LocalPackageSearchMetadata.cs (1)

55_ownersList = Owners != null ? Owners.Split(',').Where(s => !string.IsNullOrWhiteSpace(s)).Select(s => s.Trim()).ToList() : null;

Model\PackageSearchMetadata.cs (2)

112_owners = OwnersList != null ? string.Join(", ", OwnersList.Where(s => !string.IsNullOrWhiteSpace(s))) : null; 223if (string.IsNullOrWhiteSpace(LicenseExpression))

Plugins\Logging\PluginLogger.cs (1)

83if (string.IsNullOrWhiteSpace(_logDirectoryPath))

Plugins\Messages\GetAuthenticationCredentialsResponse.cs (2)

81public bool IsValid() => ResponseCode == MessageResponseCode.Success && (!string.IsNullOrWhiteSpace(Username) || !string.IsNullOrWhiteSpace(Password))

Providers\ReadmeUriTemplateResourceProvider.cs (1)

32resource = string.IsNullOrWhiteSpace(uriTemplate) ? null : new ReadmeUriTemplateResource(uriTemplate!);

Resources\PackageDetailsUriResourceV3.cs (1)

21if (string.IsNullOrWhiteSpace(uriTemplate)

Resources\PackageMetadataResourceV3.cs (1)

321if (string.IsNullOrWhiteSpace(catalogEntry.ReadmeFileUrl))

Resources\VulnerabilityInfoResourceV3.cs (1)

216if (string.IsNullOrWhiteSpace(name))

src\nuget-client\build\Shared\EqualityUtility.cs (1)

318return !string.IsNullOrWhiteSpace(value) && bool.FalseString.Equals(value.Trim(), StringComparison.OrdinalIgnoreCase);

NuGet.Versioning (5)

FloatRange.cs (1)

218if (versionString != null && !string.IsNullOrWhiteSpace(versionString))

NuGetVersionFactory.cs (1)

133if (string.IsNullOrWhiteSpace(str))

src\nuget-client\build\Shared\EqualityUtility.cs (1)

318return !string.IsNullOrWhiteSpace(value) && bool.FalseString.Equals(value.Trim(), StringComparison.OrdinalIgnoreCase);

VersionRangeFactory.cs (2)

223if (!string.IsNullOrWhiteSpace(minVersionString)) 256if (!string.IsNullOrWhiteSpace(maxVersionString))

OrleansServiceDefaults (1)

Extensions.cs (1)

70var useOtlpExporter = !string.IsNullOrWhiteSpace(builder.Configuration["OTEL_EXPORTER_OTLP_ENDPOINT"]);

Playground.ServiceDefaults (1)

Extensions.cs (1)

68var useOtlpExporter = !string.IsNullOrWhiteSpace(builder.Configuration["OTEL_EXPORTER_OTLP_ENDPOINT"]);

PresentationBuildTasks (3)

MS\Internal\MarkupCompiler\MarkupCompiler.cs (1)

2643&& !string.IsNullOrWhiteSpace(AssemblyVersion))

MS\Internal\MarkupCompiler\VersionHelper.cs (2)

63if (string.IsNullOrWhiteSpace(s)) 98if (string.IsNullOrWhiteSpace(elements[i]))

PresentationFramework (5)

System\Windows\Controls\ItemContainerGenerator.cs (1)

1054if (String.IsNullOrWhiteSpace(name))

System\Windows\Documents\MsSpellCheckLib\SpellChecker\SpellChecker.cs (1)

407if (_disposed || String.IsNullOrWhiteSpace(text))

System\Windows\Documents\WinRTSpellerInteropExtensions.cs (3)

162if (string.IsNullOrWhiteSpace(missingFragmentText) || 163string.IsNullOrWhiteSpace(lastTokenText) || 164string.IsNullOrWhiteSpace(documentText) ||

QuarantineTools.Tests (2)

ActiveIssueTests.cs (1)

426var attrArgs = string.IsNullOrWhiteSpace(issueUrl)

QuarantineScriptTests.cs (1)

370var attrArgs = string.IsNullOrWhiteSpace(issueUrl)

RepoTasks (5)

BatchHelixWorkItems.cs (4)

60if (string.IsNullOrWhiteSpace(tfm)) 66var shouldBatch = !string.IsNullOrWhiteSpace(tfm) && 67string.IsNullOrWhiteSpace(preCommands) && 179if (string.IsNullOrWhiteSpace(timeoutStr))

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

374if (string.IsNullOrWhiteSpace(dir))

Roslyn.Diagnostics.Analyzers (6)

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\RoslynString.cs (2)

17/// <inheritdoc cref="string.IsNullOrWhiteSpace(string)"/> 19=> string.IsNullOrWhiteSpace(value);

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

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Indentation\AbstractIndentation.Indenter.cs (1)

137while (token != default && string.IsNullOrWhiteSpace(token.ToString()))

Roslyn.Diagnostics.CSharp.Analyzers (2)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Formatting\Engine\Trivia\TriviaDataFactory.cs (2)

74Debug.Assert(string.IsNullOrWhiteSpace(this.TreeInfo.GetTextBetween(token1, token2))); 82Debug.Assert(string.IsNullOrWhiteSpace(this.TreeInfo.GetTextBetween(token1, token2)));

Roslyn.Diagnostics.VisualBasic.Analyzers (1)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\Extensions\SemanticModelExtensions.vb (1)

90Return If(String.IsNullOrWhiteSpace(result), [Shared].Extensions.ITypeSymbolExtensions.DefaultParameterName, result)

sdk-tasks (1)

src\sdk\src\Resolvers\Microsoft.NET.Sdk.WorkloadManifestReader\SdkFeatureBand.cs (1)

112var release = string.IsNullOrWhiteSpace(releaseVersion.Prerelease) ? string.Empty : $"-{releaseVersion.Prerelease}";

SelectTests (2)

GraphAffectedProjects.cs (1)

298if (!string.IsNullOrWhiteSpace(fullPath))

Program.cs (1)

1250return string.IsNullOrWhiteSpace(cause.Reason)

Seq.ServiceDefaults (1)

Extensions.cs (1)

69var useOtlpExporter = !string.IsNullOrWhiteSpace(builder.Configuration["OTEL_EXPORTER_OTLP_ENDPOINT"]);

Shared (1)

Throw\Throw.cs (1)

143if (string.IsNullOrWhiteSpace(argument))

Stress.AppHost (6)

CommandResources.cs (4)

112if (string.IsNullOrWhiteSpace(arguments.GetString("message")) || string.IsNullOrWhiteSpace(arguments.GetString("count"))) 162if (string.IsNullOrWhiteSpace(arguments.Message)) 247if (string.IsNullOrWhiteSpace(arguments.Target))

InteractionCommands.cs (2)

759if (!string.IsNullOrWhiteSpace(tenant.Value) && !Guid.TryParse(tenant.Value, out _)) 765if (!string.IsNullOrWhiteSpace(subscription.Value) && !Guid.TryParse(subscription.Value, out _))

SuperFileCheck (2)

Program.cs (2)

473.Where(x => !String.IsNullOrWhiteSpace(x)) 721if (String.IsNullOrWhiteSpace(tmpDirName))

System.CommandLine (12)

Completions\CompletionContext.cs (1)

80if (string.IsNullOrWhiteSpace(rawInput))

Help\HelpBuilder.cs (6)

120return string.Join(" ", GetUsageParts().Where(x => !string.IsNullOrWhiteSpace(x))); 200if (!string.IsNullOrWhiteSpace(heading)) 205if (!string.IsNullOrWhiteSpace(description)) 252if (!string.IsNullOrWhiteSpace(second)) 345if (string.IsNullOrWhiteSpace(text)) 512if (string.IsNullOrWhiteSpace(displayedDefaultValue))

Help\HelpBuilder.Default.cs (2)

85if (!string.IsNullOrWhiteSpace(helpName)) 154if (!string.IsNullOrWhiteSpace(argumentFirstColumnText))

Parsing\ParseError.cs (1)

15if (string.IsNullOrWhiteSpace(message))

Parsing\StringExtensions.cs (1)

122else if (!string.IsNullOrWhiteSpace(error))

Symbol.cs (1)

84if (string.IsNullOrWhiteSpace(value))

System.ComponentModel.Annotations (3)

System\ComponentModel\DataAnnotations\DataTypeAttribute.cs (1)

117if (DataType == DataType.Custom && string.IsNullOrWhiteSpace(CustomDataType))

System\ComponentModel\DataAnnotations\FileExtensionsAttribute.cs (1)

28get => string.IsNullOrWhiteSpace(_extensions) ? "png,jpg,jpeg,gif" : _extensions;

System\ComponentModel\DataAnnotations\RequiredAttribute.cs (1)

46return AllowEmptyStrings || value is not string stringValue || !string.IsNullOrWhiteSpace(stringValue);

System.Console (1)

src\runtime\src\libraries\Common\src\System\Text\EncodingHelper.Unix.cs (1)

40if (!string.IsNullOrWhiteSpace(locale)) break;

System.Data.Common (3)

System\Data\Common\DbProviderFactories.cs (3)

67if (string.IsNullOrWhiteSpace(assemblyQualifiedName)) 135return !string.IsNullOrWhiteSpace(providerInvariantName) && _registeredFactories.TryRemove(providerInvariantName, out _); 146if (string.IsNullOrWhiteSpace(providerInvariantName))

System.Data.Odbc (1)

System\Data\Odbc\OdbcConnection.cs (1)

940if (string.IsNullOrWhiteSpace(value))

System.Data.OleDb (1)

OleDbConnection.cs (1)

327if (string.IsNullOrWhiteSpace(value))

System.Diagnostics.Process (2)

Microsoft\Win32\SafeHandles\SafeProcessHandle.Unix.cs (2)

222string? cwd = !string.IsNullOrWhiteSpace(startInfo.WorkingDirectory) ? startInfo.WorkingDirectory : null; 360string? cwd = !string.IsNullOrWhiteSpace(startInfo.WorkingDirectory) ? startInfo.WorkingDirectory : null;

System.IO.Packaging (1)

System\IO\Packaging\InternalRelationshipCollection.cs (1)

145if (string.IsNullOrWhiteSpace(relationshipType))

System.Net.Http (4)

System\Net\Http\Headers\UriHeaderParser.cs (1)

63if (!string.IsNullOrWhiteSpace(input))

System\Net\Http\HttpResponseMessage.cs (1)

168string.IsNullOrWhiteSpace(ReasonPhrase) ? SR.net_http_message_not_success_statuscode : SR.net_http_message_not_success_statuscode_reason,

System\Net\Http\SocketsHttpHandler\CreditManager.cs (1)

23Debug.Assert(!string.IsNullOrWhiteSpace(name));

System\Net\Http\SocketsHttpHandler\HttpEnvironmentProxy.cs (1)

60if (string.IsNullOrWhiteSpace(value))

System.Net.HttpListener (5)

System\Net\Managed\HttpListenerContext.Managed.cs (1)

62if (string.IsNullOrWhiteSpace(headerValue))

System\Net\Managed\HttpListenerResponse.Managed.cs (1)

306if (!string.IsNullOrWhiteSpace(value))

System\Net\ServiceNameStore.cs (2)

27if (string.IsNullOrWhiteSpace(inputServiceName)) 41if (string.IsNullOrWhiteSpace(hostPortAndDistinguisher))

System\Net\WebSockets\HttpWebSocket.cs (1)

136bool isSecWebSocketKeyInvalid = string.IsNullOrWhiteSpace(secWebSocketKey);

System.Net.Requests (4)

System\Net\HttpWebRequest.cs (3)

456if (string.IsNullOrWhiteSpace(value)) 599if (string.IsNullOrWhiteSpace(value)) 650if (string.IsNullOrWhiteSpace(value))

System\Net\HttpWebResponse.cs (1)

269if (_characterSet == null && !string.IsNullOrWhiteSpace(contentType))

System.Net.Security (7)

System\Net\NegotiateAuthenticationPal.ManagedNtlm.cs (2)

303string.IsNullOrWhiteSpace(clientOptions.Credential.UserName) || 304string.IsNullOrWhiteSpace(clientOptions.Credential.Password))

System\Net\NegotiateAuthenticationPal.Unix.cs (4)

192string.IsNullOrWhiteSpace(clientOptions.Credential.UserName) || 193string.IsNullOrWhiteSpace(clientOptions.Credential.Password)) 240string.IsNullOrWhiteSpace(serverOptions.Credential.UserName) || 241string.IsNullOrWhiteSpace(serverOptions.Credential.Password))

System\Security\Authentication\ExtendedProtection\ServiceNameCollection.cs (1)

164if (string.IsNullOrWhiteSpace(inputServiceName))

System.Private.CoreLib (2)

src\runtime\src\libraries\System.Private.CoreLib\src\System\ArgumentException.cs (1)

119if (string.IsNullOrWhiteSpace(argument))

src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\Serialization\SerializationInfo.SerializationGuard.cs (1)

46Debug.Assert(!string.IsNullOrWhiteSpace(switchSuffix));

System.Private.Windows.Core (6)

System\Private\Windows\Nrbf\FullyQualifiedTypeName.cs (2)

15Debug.Assert(!string.IsNullOrWhiteSpace(assemblyName)); 16Debug.Assert(!string.IsNullOrWhiteSpace(fullTypeName));

System\Private\Windows\Ole\ClipboardCore.cs (1)

317if (string.IsNullOrWhiteSpace(format))

System\Private\Windows\Ole\Composition.NativeToManagedAdapter.cs (1)

644if (string.IsNullOrWhiteSpace(format))

System\Private\Windows\Ole\DataStore.cs (2)

29if (string.IsNullOrWhiteSpace(format)) 134if (string.IsNullOrWhiteSpace(format))

System.Runtime.Serialization.Schema (1)

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

124if (string.IsNullOrWhiteSpace(assemblyName))

System.Security.Claims (2)

System\Security\Claims\ClaimsIdentity.cs (1)

898if (!string.IsNullOrWhiteSpace(_label))

System\Security\Claims\GenericPrincipal.cs (1)

53if (!string.IsNullOrWhiteSpace(role))

System.ServiceModel.Http (1)

System\ServiceModel\Channels\ClientWebSocketTransportDuplexSessionChannel.cs (1)

131if (!(requested == null ? string.IsNullOrWhiteSpace(obtained) : requested.Equals(obtained, StringComparison.OrdinalIgnoreCase)))

System.ServiceModel.Primitives (1)

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

327if (string.IsNullOrWhiteSpace(asnString))

System.ServiceProcess.ServiceController (1)

System\ServiceProcess\ServiceController.cs (1)

458return !string.IsNullOrWhiteSpace(value) && !value.Contains('\\');

System.Text.RegularExpressions.Generator (1)

RegexGenerator.Emitter.cs (1)

65if (!string.IsNullOrWhiteSpace(parent.Namespace))

System.Windows.Forms (3)

System\Windows\Forms\Input\KeysConverter.cs (1)

154if (string.IsNullOrWhiteSpace(text))

System\Windows\Forms\OLE\Clipboard.cs (2)

92!string.IsNullOrWhiteSpace(format) && ContainsData(format, autoConvert: false); 147string.IsNullOrWhiteSpace(format) ? null : GetData(format, autoConvert: false);

System.Windows.Forms.Analyzers (1)

System\Windows\Forms\Analyzers\ApplicationConfig.FontDescriptor.cs (1)

31string fontFamily = string.IsNullOrWhiteSpace(name)

System.Windows.Forms.Analyzers.CSharp (2)

System\Windows\Forms\CSharp\Generators\ApplicationConfiguration\ApplicationConfigurationInitializeBuilder.cs (2)

13bool topLevelApp = string.IsNullOrWhiteSpace(projectNamespace); 35if (!string.IsNullOrWhiteSpace(defaultFont))

System.Windows.Forms.Design (3)

System\Drawing\Design\FontNameEditor.cs (1)

33if (string.IsNullOrWhiteSpace(fontName))

System\Drawing\Design\IconEditor.cs (1)

32if (string.IsNullOrWhiteSpace(extensions[i]))

System\Windows\Forms\Design\FormatControl.cs (1)

72return string.IsNullOrWhiteSpace(nullValue) ? null : nullValue.Trim();

System.Windows.Forms.Primitives (4)

System\Windows\Forms\Automation\UiaTextRange.cs (3)

645=> string.IsNullOrWhiteSpace(text) || index <= 0 || index >= text.Length || ((text[index - 1] == '\n') && (text[index] != '\n')); 654if (string.IsNullOrWhiteSpace(text) || index <= 0 || index >= text.Length || AtParagraphBoundary(text, index)) 805if (string.IsNullOrWhiteSpace(text.Substring(lineStartIndex, lineTextLength)))

Windows\Win32\PInvoke.LoadLibrary.cs (1)

15if (!string.IsNullOrWhiteSpace(startupPath))

testhost (4)

src\vstest\src\Microsoft.TestPlatform.Execution.Shared\DebuggerBreakpoint.cs (3)

28if (string.IsNullOrWhiteSpace(environmentVariable)) 122if (string.IsNullOrWhiteSpace(environmentVariable)) 148if (string.IsNullOrWhiteSpace(environmentVariable))

src\vstest\src\testhost.x86\DefaultEngineInvoker.cs (1)

257if (string.IsNullOrWhiteSpace(endpoint))

testhost.arm64 (4)

src\vstest\src\Microsoft.TestPlatform.Execution.Shared\DebuggerBreakpoint.cs (3)

28if (string.IsNullOrWhiteSpace(environmentVariable)) 122if (string.IsNullOrWhiteSpace(environmentVariable)) 148if (string.IsNullOrWhiteSpace(environmentVariable))

src\vstest\src\testhost.x86\DefaultEngineInvoker.cs (1)

257if (string.IsNullOrWhiteSpace(endpoint))

testhost.x86 (4)

DefaultEngineInvoker.cs (1)

257if (string.IsNullOrWhiteSpace(endpoint))

src\vstest\src\Microsoft.TestPlatform.Execution.Shared\DebuggerBreakpoint.cs (3)

28if (string.IsNullOrWhiteSpace(environmentVariable)) 122if (string.IsNullOrWhiteSpace(environmentVariable)) 148if (string.IsNullOrWhiteSpace(environmentVariable))

TestingAppHost1.ServiceDefaults (1)

Extensions.cs (1)

77var useOtlpExporter = !string.IsNullOrWhiteSpace(builder.Configuration["OTEL_EXPORTER_OTLP_ENDPOINT"]);

TestShop.ServiceDefaults (1)

Extensions.cs (1)

75var useOtlpExporter = !string.IsNullOrWhiteSpace(builder.Configuration["OTEL_EXPORTER_OTLP_ENDPOINT"]);

TypeScriptApiCompat (5)

AtsSurfaceParser.cs (3)

23if (string.IsNullOrWhiteSpace(rawLine)) 203var parameters = string.IsNullOrWhiteSpace(parametersText) 246if (!string.IsNullOrWhiteSpace(knownPackageName))

ExcludedPackageLoader.cs (1)

10if (string.IsNullOrWhiteSpace(filePath))

TypeScriptApiCompatRunner.cs (1)

23if (!string.IsNullOrWhiteSpace(options.ReportPath))

vbc (2)

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

VBCSCompiler (2)

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

vstest.console (5)

NullableHelpers.cs (2)

24/// <inheritdoc cref="string.IsNullOrWhiteSpace(string)"/> 27=> string.IsNullOrWhiteSpace(value);

src\vstest\src\Microsoft.TestPlatform.Execution.Shared\DebuggerBreakpoint.cs (3)

28if (string.IsNullOrWhiteSpace(environmentVariable)) 122if (string.IsNullOrWhiteSpace(environmentVariable)) 148if (string.IsNullOrWhiteSpace(environmentVariable))

vstest.console.arm64 (5)

src\vstest\src\Microsoft.TestPlatform.Execution.Shared\DebuggerBreakpoint.cs (3)

28if (string.IsNullOrWhiteSpace(environmentVariable)) 122if (string.IsNullOrWhiteSpace(environmentVariable)) 148if (string.IsNullOrWhiteSpace(environmentVariable))

src\vstest\src\vstest.console\NullableHelpers.cs (2)

24/// <inheritdoc cref="string.IsNullOrWhiteSpace(string)"/> 27=> string.IsNullOrWhiteSpace(value);